@synmux/claude-commit 1.0.1 → 1.0.3

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,16 @@ interface CliOptions {
   config?: string;
   verbose?: boolean;
   skipArmored?: 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")
@@ -78,6 +90,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 +120,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 +162,21 @@ 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;
+  // 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);
   }
@@ -278,11 +342,26 @@ async function runNonInteractive(
         `${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", describeIgnoreStats(result.ignored)) + "\n",
+      );
+    }
+    if (config.lowPriorityPaths.length > 0) {
       process.stderr.write(
-        color("90", `--- summary ${i + 1} ---\n${summary}`) + "\n",
+        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 +397,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,
@@ -30,6 +31,13 @@ export const DEFAULT_CONFIG: Config = {
   maxChunkTokens: 600_000,
   charsPerToken: 3.5,
   skipArmored: false,
+  lowPriorityPaths: [],
+  ignore: [],
+  ollama: {
+    host: DEFAULT_OLLAMA_HOST,
+    context: DEFAULT_OLLAMA_CONTEXT,
+    keepAlive: null,
+  },
   allowApiKey: false,
 };
 
@@ -72,10 +80,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;
 }
 
@@ -127,18 +153,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 +305,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 +318,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;
 }