@synmux/claude-commit 0.1.1 → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 syn <syn@syn.as>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -20,14 +20,16 @@ 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[1m]──▶ summaries ──haiku──▶ commit message
+staged diff ──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[1m]`, Sonnet with a 1M-token
-   context). Diffs larger than 1M tokens simply produce more chunks.
-2. **Write** - the summaries are handed to a fast model (`haiku`) that writes the
-   final commit message according to your formatting rules.
+   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.
+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).
 
@@ -84,8 +86,8 @@ 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                                               |
-| `--model-summary <model>`                | Model used to summarize the diff (default `sonnet[1m]`)                                 |
-| `--model-final <model>`                  | Model used to write the message (default `haiku`)                                       |
+| `--model-summary <model>`                | Model used to summarize the diff (default `sonnet`)                                     |
+| `--model-final <model>`                  | Model used to write the message (default `sonnet`)                                      |
 | `-d, --dry-run`                          | Print the message to stdout without committing                                          |
 | `-y, --yes`                              | Commit without asking for confirmation                                                  |
 | `--no-spinner`                           | Disable the progress spinner                                                            |
@@ -150,8 +152,8 @@ keys are valid at every level:
   "interactiveCount": 3,
   "interactiveTemperature": 1,
   "models": {
-    "summary": "sonnet[1m]",
-    "final": "haiku"
+    "summary": "sonnet",
+    "final": "sonnet"
   },
   "maxChunkTokens": 600000,
   "charsPerToken": 3.5,
@@ -159,6 +161,12 @@ keys are valid at every level:
 }
 ```
 
+`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
+current Sonnet/Opus keep the full budget; Haiku, older pinned model ids, and
+unrecognised models are floored at 200k), so a single chunk can never overflow
+the model.
+
 ## Development
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synmux/claude-commit",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Generate git commit messages with Claude, using your Claude Code subscription.",
   "main": "index.ts",
   "module": "index.ts",
@@ -25,28 +25,32 @@
     "interactiveCount": 3,
     "interactiveTemperature": 1,
     "models": {
-      "summary": "sonnet[1m]",
-      "final": "haiku"
+      "summary": "sonnet",
+      "final": "sonnet"
     },
     "maxChunkTokens": 600000,
     "charsPerToken": 3.5,
     "allowApiKey": false
   },
   "devDependencies": {
-    "@anthropic-ai/claude-code": "^2.1.198",
+    "@anthropic-ai/claude-code": "^2.1.218",
     "@trunkio/launcher": "^1.3.4",
     "@types/bun": "^1.3.14",
     "prettier": "3.9.4",
     "skilld": "^2.0.0"
   },
   "peerDependencies": {
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.198",
-    "@opentui/core": "^0.4.2",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.218",
+    "@opentui/core": "^0.4.5",
     "commander": "^15.0.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/synmux/claude-commit"
+  },
   "scripts": {
     "start": "bun run bin/cco.ts",
     "test": "bun test",
@@ -55,5 +59,12 @@
     "lint:fix": "bun run trunk check -a --fix",
     "typecheck": "bun run tsc --noEmit",
     "prepare": "bun run skilld prepare || true"
-  }
+  },
+  "trustedDependencies": [
+    "@anthropic-ai/claude-code",
+    "@google/genai",
+    "onnxruntime-node",
+    "protobufjs",
+    "sharp"
+  ]
 }

package/src/agent.ts

@@ -8,9 +8,10 @@
  * `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. We deliberately disable every tool (`tools: []`) and
- * load no settings (`settingSources: []`) so the run is a clean, isolated,
- * prompt-in/text-out request.
+ * 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 {
   query,
@@ -21,7 +22,7 @@ import { ClaudeCommitError } from "./errors";
 import type { ModelResult } from "./types";
 
 export interface RunPromptOptions {
-  /** Model string (alias like `haiku`, `sonnet[1m]`, or a full model id). */
+  /** Model string (alias like `sonnet`, `haiku`, or a full model id). */
   model: string;
   /** Full custom system prompt. */
   system: string;
@@ -150,31 +151,59 @@ function describeAssistantError(code: string): string {
 }
 
 /**
- * Run a single prompt and return the model's text response.
+ * Build the Agent SDK options for one isolated, single-turn text completion.
  *
- * Throws {@link ClaudeCommitError} on any model/authentication/quota failure.
+ * 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 leaks the user's global Claude Code configuration
+ * into the request - observed at ~850k tokens of MCP tool definitions, which
+ * overflows the context window before the diff is even counted.
  */
-export async function runPrompt(
-  prompt: string,
+export function buildQueryOptions(
   opts: RunPromptOptions,
-): Promise<ModelResult> {
-  const subprocessEnv = buildSubprocessEnv({
-    baseEnv: process.env,
-    allowApiKey: opts.allowApiKey ?? false,
-    ...(opts.temperature != null ? { temperature: opts.temperature } : {}),
-  });
-  const options: Options = {
+  subprocessEnv?: Record<string, string | undefined>,
+): Options {
+  return {
     model: opts.model,
     systemPrompt: opts.system,
     tools: [], // pure text completion: no Bash/Read/Edit/etc.
+    skills: [],
+    mcpServers: {},
+    strictMcpConfig: true,
+    plugins: [],
+    settingSources: [],
     maxTurns: 1,
-    settingSources: [], // ignore user/project/local settings, CLAUDE.md, MCP, plugins
     includePartialMessages: Boolean(opts.onText),
     ...(opts.abortController ? { abortController: opts.abortController } : {}),
     ...(opts.onStderr ? { stderr: opts.onStderr } : {}),
     ...(subprocessEnv ? { env: subprocessEnv } : {}),
     ...(opts.outputFormat ? { outputFormat: opts.outputFormat } : {}),
   };
+}
+
+/**
+ * Run a single prompt and return the model's text response.
+ *
+ * Throws {@link ClaudeCommitError} on any model/authentication/quota failure.
+ */
+export async function runPrompt(
+  prompt: string,
+  opts: RunPromptOptions,
+): Promise<ModelResult> {
+  const subprocessEnv = buildSubprocessEnv({
+    baseEnv: process.env,
+    allowApiKey: opts.allowApiKey ?? false,
+    ...(opts.temperature != null ? { temperature: opts.temperature } : {}),
+  });
+  const options = buildQueryOptions(opts, subprocessEnv);
 
   let resultText: string | null = null;
   let costUsd = 0;

package/src/config.ts

@@ -22,8 +22,8 @@ export const DEFAULT_CONFIG: Config = {
   interactiveCount: 3,
   interactiveTemperature: 1,
   models: {
-    summary: "sonnet[1m]",
-    final: "haiku",
+    summary: "sonnet",
+    final: "sonnet",
   },
   maxChunkTokens: 600_000,
   charsPerToken: 3.5,

package/src/generate.ts

@@ -4,14 +4,14 @@
  *   diff ──split──▶ [chunk, chunk, ...] ──summary model──▶ [summary, ...]
  *        ──final model──▶ commit message(s)
  *
- * The summary model (default `sonnet[1m]`) reads each diff chunk and writes a
+ * The summary model (default `sonnet`) reads each diff chunk and writes a
  * factual summary; chunking keeps each request within the model's context
- * window. The final model (default `haiku`) turns the summaries into the commit
+ * window. The final model (default `sonnet`) turns the summaries into the commit
  * message(s), applying the configured formatting rules.
  */
 import { runPrompt } from "./agent";
 import { splitDiff } from "./diff";
-import { tokensToChars } from "./tokens";
+import { clampChunkTokens, tokensToChars } from "./tokens";
 import { ClaudeCommitError } from "./errors";
 import {
   buildFinalSystem,
@@ -58,7 +58,14 @@ export async function generateCommit(
 ): Promise<GenerateResult> {
   const { count = 1, progress = {}, abortController } = options;
 
-  const maxChars = tokensToChars(config.maxChunkTokens, config.charsPerToken);
+  // 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.
+  const chunkTokens = clampChunkTokens(
+    config.models.summary,
+    config.maxChunkTokens,
+  );
+  const maxChars = tokensToChars(chunkTokens, config.charsPerToken);
   const chunks = splitDiff(diff, maxChars);
   if (chunks.length === 0) {
     throw new ClaudeCommitError("There are no staged changes to summarize.");

package/src/tokens.ts

@@ -18,3 +18,45 @@ export function estimateTokens(text: string, charsPerToken: number): number {
 export function tokensToChars(tokens: number, charsPerToken: number): number {
   return Math.floor(tokens * charsPerToken);
 }
+
+/**
+ * Models with a native (or explicitly requested) 1M-token context window:
+ * current-generation Sonnet/Opus (4.6 and later), Fable/Mythos, the bare
+ * `sonnet` / `opus` aliases (which resolve to current-generation models), and
+ * any id carrying the legacy `[1m]` long-context suffix.
+ *
+ * Everything else - Haiku, pre-4.6 pinned ids, unknown or custom models -
+ * gets the conservative 200k floor. Worst case we split the diff into more
+ * chunks than strictly necessary, which is always safe; assuming 1M for a
+ * 200k model would instead fail the whole run with "Prompt is too long".
+ */
+const MILLION_TOKEN_CONTEXT_MODELS =
+  /\[1m\]|^(claude-)?(sonnet|opus)$|sonnet-5|sonnet-4-6|opus-4-[678]|fable|mythos/i;
+
+/** The context window (input token capacity) for a model name or alias. */
+export function contextWindowTokens(model: string): number {
+  return MILLION_TOKEN_CONTEXT_MODELS.test(model) ? 1_000_000 : 200_000;
+}
+
+/**
+ * Tokens reserved out of the context window before sizing diff chunks: the
+ * system prompt, the Agent SDK'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 const CONTEXT_RESERVE_TOKENS = 32_000;
+
+/**
+ * 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.
+ */
+export function clampChunkTokens(
+  model: string,
+  maxChunkTokens: number,
+): number {
+  return Math.min(
+    maxChunkTokens,
+    contextWindowTokens(model) - CONTEXT_RESERVE_TOKENS,
+  );
+}

package/src/types.ts

@@ -4,9 +4,9 @@
 
 /** Which models to use for each stage of the pipeline. */
 export interface ModelConfig {
-  /** Model used to read diffs and write summaries. Defaults to `sonnet[1m]`. */
+  /** 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 `haiku`. */
+  /** Model used to turn summaries into the final commit message. Defaults to `sonnet`. */
   final: string;
 }