@synmux/claude-commit 0.1.2 → 0.1.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 syn <4ibo6o2n2@mozmail.com>
+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

package/README.md

@@ -161,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.2",
+  "version": "0.1.3",
   "description": "Generate git commit messages with Claude, using your Claude Code subscription.",
   "main": "index.ts",
   "module": "index.ts",
@@ -33,20 +33,24 @@
     "allowApiKey": false
   },
   "devDependencies": {
-    "@anthropic-ai/claude-code": "^2.1.205",
+    "@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.205",
-    "@opentui/core": "^0.4.3",
+    "@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",

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,
@@ -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/generate.ts

@@ -11,7 +11,7 @@
  */
 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,
+  );
+}