@synmux/claude-commit 1.0.2 → 1.0.4

package/src/agent.ts

@@ -1,6 +1,13 @@
 /**
- * Thin wrapper around the Claude Agent SDK that turns a single prompt into a
- * single text completion.
+ * 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
@@ -19,47 +26,12 @@ import {
   type SDKMessage,
 } from "@anthropic-ai/claude-agent-sdk";
 import { ClaudeCommitError } from "./errors";
-import type { ModelResult } from "./types";
+import { parseModelRef } from "./models";
+import { runOllamaPrompt } from "./ollama";
+import type { ModelResult, RunPromptOptions } from "./types";
 
-export interface RunPromptOptions {
-  /** Model string (alias like `sonnet`, `haiku`, or a full model id). */
-  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`). */
-  onStderr?: (data: string) => void;
-  /**
-   * Sampling temperature. Passed to the model via `CLAUDE_CODE_EXTRA_BODY`.
-   * 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, 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 SDK subprocess.
-   * Defaults to false: `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` are
-   * stripped so the run is billed to the Claude subscription.
-   */
-  allowApiKey?: boolean;
-}
+export type { RunPromptOptions } from "./types";
 
-/**
- * Environment variables that carry Claude API credentials. Their presence
- * switches the spawned `claude` binary from subscription auth to
- * pay-as-you-go API billing, so they are stripped from the subprocess
- * environment unless the user opts in via the `allowApiKey` config option.
- */
 export const GATED_CREDENTIAL_VARS = [
   "ANTHROPIC_API_KEY",
   "ANTHROPIC_AUTH_TOKEN",
@@ -195,11 +167,11 @@ export function buildQueryOptions(
 }
 
 /**
- * Run a single prompt and return the model's text response.
+ * Run a single prompt against a Claude model via the Agent SDK.
  *
  * Throws {@link ClaudeCommitError} on any model/authentication/quota failure.
  */
-export async function runPrompt(
+export async function runClaudePrompt(
   prompt: string,
   opts: RunPromptOptions,
 ): Promise<ModelResult> {
@@ -285,3 +257,24 @@ export async function runPrompt(
     ...(structured !== undefined ? { structured } : {}),
   };
 }
+
+/**
+ * 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 async function runPrompt(
+  prompt: string,
+  opts: RunPromptOptions,
+): Promise<ModelResult> {
+  const { provider } = parseModelRef(opts.model);
+  return provider === "ollama"
+    ? runOllamaPrompt(prompt, opts)
+    : runClaudePrompt(prompt, opts);
+}

package/src/cli.ts

@@ -14,12 +14,17 @@ import {
 } from "./git";
 import { presentCredentialVars } from "./agent";
 import { loadFileConfig, resolveConfig } from "./config";
-import { generateCommit } from "./generate";
+import {
+  generateCommit,
+  type IgnoreStats,
+  type LowPriorityStats,
+  type OllamaContextWindow,
+} from "./generate";
 import { Spinner } from "./ui/spinner";
 import { confirmCommit, editInEditor } from "./ui/editor";
 import { color } from "./ui/colors";
 import { ClaudeCommitError } from "./errors";
-import type { ModelConfig, PartialConfig } from "./types";
+import type { ModelConfig, OllamaConfig, PartialConfig } from "./types";
 
 export const VERSION = getVersion();
 
@@ -40,9 +45,17 @@ interface CliOptions {
   config?: string;
   verbose?: boolean;
   skipArmored?: boolean;
+  filenamesOnly?: boolean;
+  /** `false` when `--no-low-priority-paths` was passed (Commander's negated-flag shape). */
+  lowPriorityPaths?: boolean;
+  /** `false` when `--no-ignore` was passed (Commander's negated-flag shape). */
+  ignore?: boolean;
+  ollamaHost?: string;
+  ollamaContext?: number | "auto";
 }
 
-function buildProgram(): Command {
+/** Build the Commander program. Exported for tests. */
+export function buildProgram(): Command {
   const program = new Command();
   program
     .name("cco")
@@ -71,6 +84,10 @@ function buildProgram(): Command {
       'template for the first line, e.g. "[PROJ-1] {message}"',
     )
     .option("-p, --prompt <text>", "extra instructions appended to the prompt")
+    .option(
+      "-f, --filenames-only",
+      "skip summarisation and use only filenames (faster, less useful messages)",
+    )
     .option("--model-summary <model>", "model used to summarize the diff")
     .option("--model-final <model>", "model used to write the final message")
     .option(
@@ -78,6 +95,26 @@ function buildProgram(): Command {
       "omit armored/encoded lines (age/gpg armor, base64 blobs) from the " +
         "summarized diff; recommended for chezmoi-style encrypted repos",
     )
+    .option(
+      "--no-low-priority-paths",
+      'ignore the "lowPriorityPaths" config for this run, so every change ' +
+        "weighs the same",
+    )
+    .option(
+      "--no-ignore",
+      'disregard the "ignore" config for this run, so every staged change is ' +
+        "read",
+    )
+    .option(
+      "--ollama-host <url>",
+      "base URL of the Ollama server for ollama: models",
+    )
+    .option(
+      "--ollama-context <tokens|auto>",
+      "context window for Ollama models: a token count, or auto to use " +
+        "the server's own choice for this machine",
+      parseContextFlag,
+    )
     .option("-d, --dry-run", "print the message to stdout without committing")
     .option("-y, --yes", "commit without asking for confirmation")
     .option("--no-spinner", "disable the progress spinner")
@@ -88,22 +125,39 @@ function buildProgram(): Command {
       [
         "",
         "Authentication:",
-        "  Uses the Claude Agent SDK with your Claude Code subscription (run",
-        "  `claude login`). ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN are ignored",
-        '  unless the config sets "allowApiKey": true (pay-as-you-go billing).',
+        "  Claude models use the Claude Agent SDK with your Claude Code",
+        "  subscription (run `claude login`). ANTHROPIC_API_KEY /",
+        "  ANTHROPIC_AUTH_TOKEN are ignored unless the config sets",
+        '  "allowApiKey": true (pay-as-you-go billing).',
+        "",
+        "Ollama models:",
+        "  Prefix a model with `ollama:` to run it on a local Ollama server,",
+        "  e.g. --model-summary ollama:ornith-1.5:35b. Everything after the",
+        "  prefix is the Ollama model name, tag included. The server needs no",
+        "  credential; point cco at it with --ollama-host or $OLLAMA_HOST.",
         "",
         "Examples:",
         "  cco                     generate and commit a message for staged changes",
         "  cco -a -c               stage everything and write a Conventional Commit",
         "  cco -i                  pick from several options interactively",
         "  cco --dry-run | cat     print a message without committing",
+        "  cco --model-summary ollama:ornith-1.5:35b",
+        "                          read the diff locally, write the message with Claude",
       ].join("\n"),
     );
   return program;
 }
 
-/** Map parsed CLI flags onto a partial config (only set keys the user provided). */
-function flagsToConfig(opts: CliOptions): PartialConfig {
+/** `--ollama-context` accepts a token count or the literal `auto`. */
+function parseContextFlag(value: string): number | "auto" {
+  return value.trim().toLowerCase() === "auto" ? "auto" : parseInt(value, 10);
+}
+
+/**
+ * Map parsed CLI flags onto a partial config (only set keys the user
+ * provided). Exported for tests.
+ */
+export function flagsToConfig(opts: CliOptions): PartialConfig {
   const cfg: PartialConfig = {};
   if (opts.conventional !== undefined)
     cfg.conventionalCommits = opts.conventional;
@@ -113,6 +167,22 @@ function flagsToConfig(opts: CliOptions): PartialConfig {
   if (opts.template !== undefined) cfg.template = opts.template;
   if (opts.prompt !== undefined) cfg.customPrompt = opts.prompt;
   if (opts.skipArmored !== undefined) cfg.skipArmored = opts.skipArmored;
+  if (opts.filenamesOnly !== undefined) cfg.filenamesOnly = opts.filenamesOnly;
+  // A negated flag arrives as `false`; an empty list overrides any
+  // configured patterns because lists replace rather than merge.
+  if (opts.lowPriorityPaths === false) cfg.lowPriorityPaths = [];
+  if (opts.ignore === false) cfg.ignore = [];
+  const ollama: Partial<OllamaConfig> = {};
+  if (opts.ollamaHost) ollama.host = opts.ollamaHost;
+  if (opts.ollamaContext === "auto") {
+    ollama.context = "auto";
+  } else if (
+    opts.ollamaContext !== undefined &&
+    Number.isFinite(opts.ollamaContext)
+  ) {
+    ollama.context = Math.max(1, opts.ollamaContext);
+  }
+  if (Object.keys(ollama).length) cfg.ollama = ollama;
   if (opts.count !== undefined && Number.isFinite(opts.count)) {
     cfg.interactiveCount = Math.max(1, opts.count);
   }
@@ -258,7 +328,7 @@ async function runNonInteractive(
   const useSpinner = opts.spinner !== false && process.stderr.isTTY;
   const spinner = new Spinner(useSpinner, config.spinner);
 
-  spinner.start("Reading diff");
+  spinner.start(config.filenamesOnly ? "Reading filenames" : "Reading diff");
   let result;
   try {
     result = await generateCommit(diff, config, {
@@ -275,14 +345,29 @@ async function runNonInteractive(
     process.stderr.write(
       color(
         "90",
-        `${result.chunkCount} chunk(s), cost $${result.costUsd.toFixed(4)}`,
+        `${config.filenamesOnly ? "filenames only (summariser skipped)" : `${result.chunkCount} chunk(s)`}, cost $${result.costUsd.toFixed(4)}`,
       ) + "\n",
     );
-    for (const [i, summary] of result.summaries.entries()) {
+    for (const window of result.ollamaContexts) {
+      process.stderr.write(color("90", describeOllamaContext(window)) + "\n");
+    }
+    if (config.ignore.length > 0) {
       process.stderr.write(
-        color("90", `--- summary ${i + 1} ---\n${summary}`) + "\n",
+        color("90", describeIgnoreStats(result.ignored)) + "\n",
       );
     }
+    if (config.lowPriorityPaths.length > 0) {
+      process.stderr.write(
+        color("90", describeLowPriorityStats(result.lowPriority)) + "\n",
+      );
+    }
+    for (const [index, summary] of result.summaries.entries()) {
+      const label =
+        summary.priority === "low"
+          ? `--- summary ${index + 1} (low priority) ---`
+          : `--- summary ${index + 1} ---`;
+      process.stderr.write(color("90", `${label}\n${summary.text}`) + "\n");
+    }
   }
 
   let message = result.messages[0]!;
@@ -318,6 +403,46 @@ async function runNonInteractive(
   return 0;
 }
 
+/**
+ * One verbose line saying how the low-priority patterns applied. Without it
+ * a pattern that matched nothing and one that matched everything (and was
+ * promoted) are indistinguishable from the message alone.
+ */
+export function describeLowPriorityStats(stats: LowPriorityStats): string {
+  const files = `${stats.totalFiles} file${stats.totalFiles === 1 ? "" : "s"}`;
+  if (stats.matchedFiles === 0) {
+    return `low-priority paths: matched none of ${files}`;
+  }
+  if (stats.promoted) {
+    return `low-priority paths: matched all ${files} - nothing else changed, so treated as primary`;
+  }
+  return `low-priority paths: matched ${stats.matchedFiles} of ${files}`;
+}
+
+/**
+ * One verbose line per Ollama model naming the context window it ran with
+ * and where the number came from. With `"auto"` this is the only place the
+ * server's choice is visible, and it is the first thing to check when a
+ * summary reads as if it saw half the diff.
+ */
+export function describeOllamaContext(window: OllamaContextWindow): string {
+  const source =
+    window.source === "auto" ? "chosen by the server" : "from config";
+  return `ollama: ${window.model} context ${window.tokens} tokens (${source})`;
+}
+
+/**
+ * One verbose line saying how the ignore patterns applied. The counts are
+ * the only way to tell a pattern that quietly matched nothing from one that
+ * quietly removed half the commit.
+ */
+export function describeIgnoreStats(stats: IgnoreStats): string {
+  const files = `${stats.totalFiles} file${stats.totalFiles === 1 ? "" : "s"}`;
+  return stats.ignoredFiles === 0
+    ? `ignore: matched none of ${files}`
+    : `ignore: dropped ${stats.ignoredFiles} of ${files} before reading`;
+}
+
 function firstLine(text: string): string {
   return text.split("\n", 1)[0] ?? text;
 }

package/src/config.ts

@@ -11,7 +11,8 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { ClaudeCommitError } from "./errors";
 import { DEFAULT_SPINNER, isSpinnerName } from "./ui/spinner";
-import type { Config, ModelConfig, PartialConfig } from "./types";
+import { DEFAULT_OLLAMA_CONTEXT, DEFAULT_OLLAMA_HOST } from "./models";
+import type { Config, ModelConfig, OllamaConfig, PartialConfig } from "./types";
 
 export const DEFAULT_CONFIG: Config = {
   conventionalCommits: false,
@@ -29,7 +30,15 @@ export const DEFAULT_CONFIG: Config = {
   },
   maxChunkTokens: 600_000,
   charsPerToken: 3.5,
+  filenamesOnly: false,
   skipArmored: false,
+  lowPriorityPaths: [],
+  ignore: [],
+  ollama: {
+    host: DEFAULT_OLLAMA_HOST,
+    context: DEFAULT_OLLAMA_CONTEXT,
+    keepAlive: null,
+  },
   allowApiKey: false,
 };
 
@@ -72,10 +81,28 @@ async function findGlobalConfigFile(
   return undefined;
 }
 
-/** Deep-ish merge of a partial config over a base config (only `models` is nested). */
+/**
+ * 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 function mergeConfig(base: Config, override: PartialConfig): Config {
   const models: ModelConfig = { ...base.models, ...(override.models ?? {}) };
-  const merged: Config = { ...base, ...override, models };
+  const ollama: OllamaConfig = { ...base.ollama, ...(override.ollama ?? {}) };
+  const lowPriorityPaths = [
+    ...(override.lowPriorityPaths ?? base.lowPriorityPaths),
+  ];
+  const ignore = [...(override.ignore ?? base.ignore)];
+  const merged: Config = {
+    ...base,
+    ...override,
+    models,
+    ollama,
+    lowPriorityPaths,
+    ignore,
+  };
   return merged;
 }
 
@@ -94,6 +121,7 @@ export function sanitizePartial(raw: unknown): PartialConfig {
   bool("multiline");
   bool("interactive");
   bool("skipArmored");
+  bool("filenamesOnly");
   bool("allowApiKey");
 
   if (typeof obj.template === "string") out.template = obj.template;
@@ -127,18 +155,64 @@ export function sanitizePartial(raw: unknown): PartialConfig {
   if (typeof obj.charsPerToken === "number" && obj.charsPerToken > 0) {
     out.charsPerToken = obj.charsPerToken;
   }
+  // An explicit empty list is meaningful for either path option: it clears
+  // patterns inherited from a lower layer, so it is kept rather than
+  // treated as "unset".
+  if (Array.isArray(obj.lowPriorityPaths)) {
+    out.lowPriorityPaths = cleanPatternList(obj.lowPriorityPaths);
+  }
+  if (Array.isArray(obj.ignore)) {
+    out.ignore = cleanPatternList(obj.ignore);
+  }
 
   if (obj.models && typeof obj.models === "object") {
     const m = obj.models as Record<string, unknown>;
     const models: Partial<ModelConfig> = {};
-    if (typeof m.summary === "string") models.summary = m.summary;
-    if (typeof m.final === "string") models.final = m.final;
+    // A blank model name is not an override, it is a mistake: leaving the
+    // key unset keeps the layer below, which is a working model.
+    if (typeof m.summary === "string" && m.summary.trim() !== "") {
+      models.summary = m.summary.trim();
+    }
+    if (typeof m.final === "string" && m.final.trim() !== "") {
+      models.final = m.final.trim();
+    }
     if (Object.keys(models).length) out.models = models;
   }
 
+  if (obj.ollama && typeof obj.ollama === "object") {
+    const o = obj.ollama as Record<string, unknown>;
+    const ollama: Partial<OllamaConfig> = {};
+    if (typeof o.host === "string" && o.host.trim() !== "") {
+      ollama.host = o.host.trim();
+    }
+    if (typeof o.context === "number" && o.context > 0) {
+      ollama.context = Math.floor(o.context);
+    } else if (o.context === "auto") {
+      ollama.context = "auto";
+    }
+    if (typeof o.keepAlive === "string" || typeof o.keepAlive === "number") {
+      ollama.keepAlive = o.keepAlive;
+    } else if (o.keepAlive === null) {
+      ollama.keepAlive = null;
+    }
+    if (Object.keys(ollama).length) out.ollama = ollama;
+  }
+
   return out;
 }
 
+/**
+ * Clean one raw path-pattern list: drop non-strings and blanks, trim the
+ * rest. Shared by `lowPriorityPaths` and `ignore`, which take the same
+ * pattern language (see `src/paths.ts`).
+ */
+function cleanPatternList(raw: unknown[]): string[] {
+  return raw
+    .filter((entry): entry is string => typeof entry === "string")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== "");
+}
+
 async function readJsonIfExists(path: string): Promise<unknown | undefined> {
   const file = Bun.file(path);
   if (!(await file.exists())) return undefined;
@@ -233,7 +307,11 @@ export async function loadFileConfig(
   return result;
 }
 
-/** Merge two partial configs (only `models` is nested). */
+/**
+ * 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 function mergePartial(
   base: PartialConfig,
   override: PartialConfig,
@@ -242,6 +320,13 @@ export function mergePartial(
   if (base.models || override.models) {
     out.models = { ...base.models, ...override.models };
   }
+  if (base.ollama || override.ollama) {
+    out.ollama = { ...base.ollama, ...override.ollama };
+  }
+  const lowPriorityPaths = override.lowPriorityPaths ?? base.lowPriorityPaths;
+  if (lowPriorityPaths) out.lowPriorityPaths = [...lowPriorityPaths];
+  const ignore = override.ignore ?? base.ignore;
+  if (ignore) out.ignore = [...ignore];
   return out;
 }