guito 1.0.6 → 1.0.8

package/CHANGELOG.md

@@ -4,6 +4,39 @@ All notable changes to Guito are documented in this file. The project follows [S
 
 ## [Unreleased]
 
+## [1.0.8] - 2026-10-02
+
+### Changed
+
+- Pull requests are now reviewed with the latest Opus model by default (the **Claude model** setting, `guito.aiReview.model` inside the extension). Pick **Claude Code's default** to go back to whatever Claude Code itself is set to.
+
+### Added
+
+- VS Code extension: a Generate Commit Message button in the Source Control view's title bar drafts the message with Claude Code, using the same server call as the working panel's Generate message button, and fills the Git commit message box.
+- Choose how hard Claude thinks. New **Review effort** and **Commit message effort** settings (`guito.aiReview.effort` and `guito.aiReview.commitMessageEffort` inside the extension) pass Claude Code's `--effort` level, from low to max, to pull request reviews and commit message drafts. Reviews default to high and commit messages to low; pick **Claude Code's default** to use whatever Claude Code itself is set to. An effort picker next to the model picker in a pull request's **Review** tab, preselected from the setting, overrides it for a single run, and the review's summary line shows which effort produced it.
+- Choose how long drafted commit messages are. The new **Commit message style** setting (`guito.aiReview.commitMessageStyle` inside the extension) picks Oneliner, Brief or Descriptive. Oneliner is the default and drafts only the subject line; Brief adds a short description and Descriptive explains what changed and why in full.
+
+### Fixed
+
+- The **Claude model** and **Commit message model** pickers in Settings, and the model picker in a pull request's Review tab, now show the model actually selected instead of the first option.
+
+## [1.0.7] - 2026-10-01
+
+### Added
+
+- Draft commit messages with Claude. A new **Generate message** button in the uncommitted-changes panel hands the pending changes to Claude Code running on this machine and fills the commit message and description boxes with the reply, matching the language and style of your recent commits. The **Commit message model** setting (`guito.aiReview.commitMessageModel` inside the extension) picks the model; haiku is the default, since a subject line is a small question. Nothing is committed automatically: the draft lands in the boxes for you to review and edit, and Guito falls back to every uncommitted change when nothing is staged.
+- Choose which Claude model reviews your pull requests. A new **Claude model** setting (the `guito.aiReview.model` VS Code setting inside the extension) sets the default for the automated reviewer, and the model picker in the pull request dialog's **Review** tab — preselected from that setting — overrides it for a single run; the review's summary line shows which model produced it. Aliases like "opus" always mean the latest model of that family Claude Code has.
+- Scrolling to the end of the commit history now loads the next page automatically, so long histories can be explored without touching the footer; the **Load more commits** and **Load all** buttons remain available for explicit control.
+- Pull request completion and auto-complete now follow the target branch's merge policy. Guito reads the project's Azure DevOps branch policies and offers only the merge strategies the "Merge Types" policies covering the pull request allow (so a squash-only branch no longer lists the other strategies, which Azure would reject anyway), notes in the dialog when the list is limited by policy, and still applies the **Allow merge completion** setting on top. Branches without a merge policy keep offering every strategy.
+
+### Fixed
+
+- Canceling auto-complete on an Azure DevOps pull request now verifies the server actually cleared it. Azure DevOps sometimes answers the clearing PATCH with 200 OK while silently leaving auto-complete enabled, which made the button appear to do nothing; Guito now checks the pull request the server returns, retries with the alternate payload shape, and reports an error when auto-complete is still set.
+
+### Removed
+
+- The `guito.aiReview.claudeArgs` setting. Models are chosen with the new model settings instead: `guito.aiReview.model` for pull request reviews and `guito.aiReview.commitMessageModel` for commit messages.
+
 ## [1.0.6] - 2026-09-24
 
 ### Added

package/README.md

@@ -60,6 +60,8 @@ Click **Uncommitted changes** to open the staged and unstaged file lists. Click
 
 Enter a commit message and optional description, then choose **Commit staged changes**. Only staged changes are committed; unstaged edits remain on disk. Commit drafts stay available when you close and reopen the panel during the session.
 
+**Generate message** drafts a subject and description with Claude Code running on your machine, from the staged diff when anything is staged and from every uncommitted change otherwise, matching the language and style of your recent commits. The draft fills the boxes for you to review and edit; nothing is committed automatically. The **Commit message model** setting picks the model, and **Commit message style** picks how much it writes: Oneliner (the default) drafts only the subject line, Brief adds a short description, and Descriptive explains the change in full. In the VS Code extension, the same button is also in the Source Control view's title bar, and it fills the Git commit message box.
+
 ## CLI options
 
 ```text
@@ -83,6 +85,40 @@ Run the command from anywhere inside the Git worktree you want Guito to manage.
 
 The standalone server can execute Git commands against the current repository. Keep it on a trusted machine and do not expose its port to untrusted networks.
 
+## Settings
+
+Inside the VS Code extension, every preference below is a native VS Code setting in the `guito` namespace: open the Settings editor and search for "Guito". In the browser client, the same preferences live in the settings dialog behind the toolbar's gear icon and are stored per repository in `.git/guito-settings.json`, which is never committed. VS Code settings win over the stored file when both are set.
+
+The settings dialog also manages preferences that have no VS Code equivalent: the repository's Git user name and email, the fetch and push URLs of the configured remotes, and issue-linking rules. An issue-linking rule (a regular expression plus a URL template) turns issue references in commit messages into links; it can be saved for the repository or globally, and global rules are stored in your Git configuration as `guito.issueRegex` and `guito.issueUrl`.
+
+### General
+
+| Setting                          | Description                                                                                                                                             |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `guito.autoReload`               | Reload commits and the working tree automatically when the repository changes outside Guito, for example from a terminal. On by default.                 |
+| `guito.showGraph`                | Show the Git graph beside the commit history. On by default.                                                                                            |
+| `guito.showStashes`              | Show stash entries above the commit history. Off by default.                                                                                            |
+| `guito.showTags`                 | Show tag badges attached to commits. On by default.                                                                                                     |
+| `guito.showRemoteBranches`       | Show remote branches in the repository panel and the branch pills on commits. On by default.                                                            |
+| `guito.fileListView`             | How changed-file lists are shown: `flat` (default) lists every file with its full path, `tree` groups them into collapsible folders.                    |
+| `guito.refListView`              | How branches and tags are shown in the repository panel: `flat` (default) lists full names, `tree` groups them into collapsible namespace folders.      |
+| `guito.sidePanelSectionsExpanded`| Open the repository panel with all sections expanded. On by default.                                                                                    |
+| `guito.searchMode`               | How commit search behaves: `navigate` (default) keeps the full history and jumps between matches, `filter` shows only matching commits.                 |
+| `guito.searchCaseSensitive`      | Match commit and repository panel searches using the query's exact letter casing and accents. Off by default.                                           |
+| `guito.diffViewer`               | Where file diffs open: `vscode` (default) uses the native VS Code diff tab, `guito` uses Guito's own dialog. Binary files always use Guito's dialog.    |
+| `guito.issueRegex`               | Regular expression that recognizes issue references in commit messages, for example `#(\d+)`. Inside the extension this is the issue-linking rule; it wins over the rule saved in the settings dialog. |
+| `guito.issueUrl`                 | URL template for issue links; capture groups from the issue regex are inserted with `$1`, `$2`, and so on.                                              |
+
+### Azure DevOps
+
+| Setting                        | Description                                                                                                                                                          |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `guito.azureDevOpsUrl`         | Base URL of your on-prem Azure DevOps Server, for example `https://server/DefaultCollection`. Enables pull request creation and the automated reviewer; requests authenticate with Windows integrated auth. |
+| `guito.prBranchNameTemplate`   | Branch name template used when Guito creates a new branch for a pull request. Defaults to `pr/${randomstring}`. Variables: `${username}`, `${randomstring}`, `${branch}`, `${targetbranch}`, `${title}`, `${repository}`, `${date}` (UTC `YYYY-MM-DD`), `${time}` (UTC `HHmmss`), and `${timestamp}`. |
+| `guito.allowMerge`             | Offer the "No fast-forward (merge commit)" and "Semi-linear merge" pull request completion strategies. On by default.                                                |
+
+The `guito.aiReview.*` settings that configure the automated pull request reviewer are listed under [Automated pull request review](#automated-pull-request-review).
+
 ## Automated pull request review
 
 Guito can hand your Azure DevOps pull requests to [Claude Code](https://claude.com/claude-code) running on your own machine, then queue what it finds for you to approve.
@@ -103,10 +139,14 @@ Inside VS Code the reviewer also runs while no Guito panel is open, so pull requ
 | -------------------------------- | ---------------------------------------------------------------------------------------- |
 | `guito.aiReview.enabled`         | Turns automated review on. Off by default.                                               |
 | `guito.aiReview.scope`           | `reviewer` (default), `mine`, or `all`.                                                  |
-| `guito.aiReview.pollMinutes`     | Minutes between checks. Defaults to 5.                                                   |
+| `guito.aiReview.pollMinutes`     | Minutes between checks. Defaults to 30.                                                  |
 | `guito.aiReview.includeDrafts`   | Also review draft pull requests. Off by default.                                         |
 | `guito.aiReview.claudePath`      | Path to the Claude Code executable. Empty means Guito looks for it (see above).           |
-| `guito.aiReview.claudeArgs`      | Extra Claude Code arguments, for example `["--model", "opus"]`.                          |
+| `guito.aiReview.model`           | Which Claude model reviews pull requests. Defaults to opus.                              |
+| `guito.aiReview.commitMessageModel` | Which Claude model drafts commit messages. Defaults to haiku.                          |
+| `guito.aiReview.effort`          | Claude Code effort level for reviews (`low` to `max`). Defaults to high; empty uses Claude Code's default. |
+| `guito.aiReview.commitMessageEffort` | Claude Code effort level for commit messages. Defaults to low; empty uses Claude Code's default. |
+| `guito.aiReview.commitMessageStyle` | `oneliner` (default), `brief`, or `descriptive`.                                      |
 | `guito.aiReview.timeoutSeconds`  | How long one review may take. Defaults to 600.                                           |
 | `guito.aiReview.instructions`    | Extra reviewing instructions, such as your team's conventions.                           |
 

package/bin/ai-review.js

@@ -3,17 +3,38 @@ import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const SEVERITIES = ['blocker', 'concern', 'suggestion', 'nit'];
+/** Effort levels Claude Code accepts for --effort; '' leaves it to Claude Code. */
+export const AI_REVIEW_EFFORTS = ['', 'low', 'medium', 'high', 'xhigh', 'max'];
+/** How much a drafted commit message says beyond its subject line. */
+export const COMMIT_MESSAGE_STYLES = ['oneliner', 'brief', 'descriptive'];
+/** The --effort arguments for one run, or none when Claude Code decides. */
+export function effortArgs(effort) {
+    return effort ? ['--effort', effort] : [];
+}
 export const DEFAULT_AI_REVIEW_CONFIG = {
     enabled: false,
     scope: 'reviewer',
-    pollMinutes: 5,
+    pollMinutes: 30,
     includeDrafts: false,
     claudePath: '',
-    claudeArgs: [],
+    model: 'opus',
+    commitMessageModel: 'haiku',
+    effort: 'high',
+    commitMessageEffort: 'low',
+    commitMessageStyle: 'oneliner',
     timeoutSeconds: 600,
     maxDiffChars: 300000,
     instructions: '',
 };
+/** A known effort level, or undefined so an unknown value keeps the default. */
+export function normalizeEffort(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const effort = value.trim().toLowerCase();
+    return AI_REVIEW_EFFORTS.includes(effort)
+        ? effort
+        : undefined;
+}
 /** Normalizes a partial config (settings file or VS Code) onto the defaults. */
 export function resolveAiReviewConfig(...sources) {
     const config = { ...DEFAULT_AI_REVIEW_CONFIG };
@@ -33,8 +54,21 @@ export function resolveAiReviewConfig(...sources) {
         if (typeof source.claudePath === 'string' && source.claudePath.trim()) {
             config.claudePath = source.claudePath.trim();
         }
-        if (Array.isArray(source.claudeArgs)) {
-            config.claudeArgs = source.claudeArgs.map((arg) => String(arg)).filter(Boolean);
+        if (typeof source.model === 'string') {
+            config.model = source.model.trim();
+        }
+        if (typeof source.commitMessageModel === 'string') {
+            config.commitMessageModel = source.commitMessageModel.trim();
+        }
+        const effort = normalizeEffort(source.effort);
+        if (effort !== undefined)
+            config.effort = effort;
+        const commitMessageEffort = normalizeEffort(source.commitMessageEffort);
+        if (commitMessageEffort !== undefined)
+            config.commitMessageEffort = commitMessageEffort;
+        const commitMessageStyle = String(source.commitMessageStyle ?? '').trim().toLowerCase();
+        if (COMMIT_MESSAGE_STYLES.includes(commitMessageStyle)) {
+            config.commitMessageStyle = commitMessageStyle;
         }
         if (Number.isFinite(source.timeoutSeconds)) {
             config.timeoutSeconds = Math.min(Math.max(Number(source.timeoutSeconds), 30), 3600);
@@ -83,12 +117,7 @@ async function bundledClaudeCandidates() {
     const home = homedir();
     const binary = process.platform === 'win32' ? 'claude.exe' : 'claude';
     const found = [];
-    for (const root of [
-        '.vscode',
-        '.vscode-insiders',
-        '.vscode-server',
-        '.vscode-server-insiders',
-    ]) {
+    for (const root of ['.vscode', '.vscode-insiders', '.vscode-server', '.vscode-server-insiders']) {
         const extensions = join(home, root, 'extensions');
         let entries;
         try {
@@ -132,8 +161,9 @@ export async function resolveClaudeCommand(configured) {
 /**
  * Runs the Claude Code CLI in print mode. The prompt goes over stdin because a
  * pull request diff is far larger than the Windows command line allows.
+ * Exported because the commit message drafter runs the CLI the same way.
  */
-const runClaudeCli = (prompt, { command, args, cwd, timeoutMs }) => new Promise((resolve, reject) => {
+export const runClaudeCli = (prompt, { command, args, cwd, timeoutMs, signal }) => new Promise((resolve, reject) => {
     const child = spawn(command, args, {
         cwd,
         windowsHide: true,
@@ -148,6 +178,7 @@ const runClaudeCli = (prompt, { command, args, cwd, timeoutMs }) => new Promise(
             return;
         settled = true;
         clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
         if (error)
             reject(error);
         else
@@ -157,6 +188,16 @@ const runClaudeCli = (prompt, { command, args, cwd, timeoutMs }) => new Promise(
         child.kill();
         finish(new Error(`The review timed out after ${Math.round(timeoutMs / 1000)}s.`));
     }, timeoutMs);
+    const onAbort = () => {
+        child.kill();
+        finish(new Error('The review was cancelled.'));
+    };
+    if (signal) {
+        if (signal.aborted)
+            onAbort();
+        else
+            signal.addEventListener('abort', onAbort);
+    }
     child.stdout.on('data', (chunk) => {
         stdout += String(chunk);
     });
@@ -339,9 +380,7 @@ export function buildReviewPrompt(input) {
         'EXISTING COMMENT THREADS ON THE PULL REQUEST:',
         renderThreads(threads),
         '',
-        input.skipped.length
-            ? `NOT SHOWN (binary or unreviewable): ${input.skipped.join(', ')}\n`
-            : '',
+        input.skipped.length ? `NOT SHOWN (binary or unreviewable): ${input.skipped.join(', ')}\n` : '',
         input.instructions.trim() ? `TEAM INSTRUCTIONS:\n${input.instructions.trim()}\n` : '',
         REVIEW_CONTRACT,
         '',
@@ -371,6 +410,7 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
     const running = new Set();
     let timer;
     let activePoll = null;
+    let pollAbort;
     // One review at a time: each one spawns a CLI and burns Azure DevOps calls.
     let queue = Promise.resolve();
     const serialize = (action) => {
@@ -422,7 +462,10 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
             const rawLine = Number(entry?.line);
             const line = inDiff && Number.isInteger(rawLine) && anchors.get(file).has(rawLine) ? rawLine : null;
             const rawEnd = Number(entry?.endLine);
-            const endLine = line !== null && Number.isInteger(rawEnd) && rawEnd >= line && anchors.get(file).has(rawEnd)
+            const endLine = line !== null &&
+                Number.isInteger(rawEnd) &&
+                rawEnd >= line &&
+                anchors.get(file).has(rawEnd)
                 ? rawEnd
                 : null;
             const severity = SEVERITIES.includes(entry?.severity)
@@ -451,9 +494,28 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
         return accepted.sort((a, b) => SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity));
     };
     const runReview = async (pullRequestId, options = {}) => {
+        // A pass the poller cancelled before this review's turn must not start.
+        if (options.signal?.aborted) {
+            return (await stateOf(pullRequestId)) ?? emptyState(pullRequestId);
+        }
         const pullRequest = await deps.loadPullRequest(pullRequestId);
         const previousState = (await stateOf(pullRequestId)) ?? emptyState(pullRequestId);
+        // A per-review model choice wins over the configured one. An alias such
+        // as "opus" always means the latest model of that family Claude Code has.
+        const model = typeof options.model === 'string' && options.model.trim()
+            ? options.model.trim()
+            : config.model;
+        // A per-review effort wins too, '' included: it asks for Claude Code's
+        // own default rather than the configured level.
+        const effort = normalizeEffort(options.effort) ?? config.effort;
+        // A different model or effort earns a fresh look at code already reviewed
+        // at this commit; when new commits exist, they alone are reviewed with it.
+        // Reviews stored before effort was recorded are not re-run just for that.
+        const freshLook = ((previousState.model ?? '') !== model ||
+            (previousState.effort !== undefined && previousState.effort !== effort)) &&
+            previousState.reviewedCommit === pullRequest.sourceCommit;
         if (!options.force &&
+            !freshLook &&
             previousState.reviewedCommit &&
             previousState.reviewedCommit === pullRequest.sourceCommit) {
             return previousState;
@@ -497,16 +559,20 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
                 const command = await resolveClaudeCommand(config.claudePath);
                 const args = [
                     '-p',
+                    // Background reviews should not show up in the user's Claude Code session history.
+                    '--no-session-persistence',
                     '--output-format',
                     'json',
-                    ...(config.claudeArgs.length ? config.claudeArgs : []),
+                    ...(model ? ['--model', model] : []),
+                    ...effortArgs(effort),
                 ];
-                log(`AI review: reviewing pull request ${pullRequestId} with ${command}`);
+                log(`AI review: reviewing pull request ${pullRequestId} with ${command}${model ? ` (${model})` : ''}${effort ? `, ${effort} effort` : ''}`);
                 const raw = await runModel(prompt, {
                     command,
                     args,
                     cwd: repositoryPath,
                     timeoutMs: config.timeoutSeconds * 1000,
+                    signal: options.signal,
                 });
                 const review = parseModelReview(raw);
                 summary = review.summary;
@@ -521,6 +587,8 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
                     ...current,
                     title: pullRequest.title,
                     reviewedCommit: pullRequest.sourceCommit,
+                    model,
+                    effort,
                     reviewedAt: now().toISOString(),
                     passes: current.passes + 1,
                     status: 'idle',
@@ -539,16 +607,23 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
             return next;
         }
         catch (error) {
+            const cancelled = options.signal?.aborted === true;
             const message = error?.message ? String(error.message) : String(error);
-            log(`AI review: pull request ${pullRequestId} failed: ${message}`);
+            log(cancelled
+                ? `AI review: pull request ${pullRequestId} was cancelled.`
+                : `AI review: pull request ${pullRequestId} failed: ${message}`);
             return mutateStore((store) => {
                 const current = store.pullRequests[String(pullRequestId)] ?? previousState;
-                const state = {
-                    ...current,
-                    status: 'error',
-                    error: message,
-                    errorCommit: pullRequest.sourceCommit,
-                };
+                // A cancelled review is not a failure: the pull request is left as it
+                // was, so switching the reviewer back on reviews the same commit.
+                const state = cancelled
+                    ? { ...current, status: 'idle', error: '' }
+                    : {
+                        ...current,
+                        status: 'error',
+                        error: message,
+                        errorCommit: pullRequest.sourceCommit,
+                    };
                 store.pullRequests[String(pullRequestId)] = state;
                 return state;
             });
@@ -558,12 +633,14 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
         }
     };
     /** One pass over the pull requests in scope; reviews those with new code. */
-    const runPoll = async () => {
+    const runPoll = async (signal) => {
         const reviewed = [];
         try {
             const pullRequests = (await deps.listPullRequests()).filter(wanted);
             const store = await deps.readStore();
             for (const pullRequest of pullRequests) {
+                if (signal?.aborted)
+                    break;
                 if (!pullRequest.sourceCommit)
                     continue;
                 const state = store.pullRequests?.[String(pullRequest.id)];
@@ -573,8 +650,8 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
                     continue;
                 if (state?.status === 'error' && state.errorCommit === pullRequest.sourceCommit)
                     continue;
-                const next = await serialize(() => runReview(pullRequest.id));
-                if (next.status !== 'error')
+                const next = await serialize(() => runReview(pullRequest.id, { signal }));
+                if (!signal?.aborted && next.status !== 'error')
                     reviewed.push(pullRequest.id);
             }
         }
@@ -592,6 +669,11 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
             return pullRequest.isMine;
         return pullRequest.isReviewer;
     };
+    const clearTimer = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+    };
     const reviewer = {
         updateConfig(next) {
             const wasEnabled = config.enabled;
@@ -683,22 +765,24 @@ export function createAiReviewer(deps, initialConfig = DEFAULT_AI_REVIEW_CONFIG,
                 return Promise.resolve([]);
             // A caller asking for a poll while one runs waits for that pass rather
             // than being told, misleadingly, that there was nothing to review.
-            activePoll ?? (activePoll = runPoll().finally(() => {
+            activePoll ?? (activePoll = runPoll((pollAbort = new AbortController()).signal).finally(() => {
                 activePoll = null;
+                pollAbort = undefined;
             }));
             return activePoll;
         },
         start() {
-            reviewer.stop();
+            clearTimer();
             if (!config.enabled)
                 return;
             timer = setInterval(() => void reviewer.poll(), config.pollMinutes * 60000);
             timer.unref?.();
         },
         stop() {
-            if (timer)
-                clearInterval(timer);
-            timer = undefined;
+            clearTimer();
+            // Switching the reviewer off also cancels the pass in flight: the CLI
+            // run is aborted and the pass's remaining pull requests are skipped.
+            pollAbort?.abort();
         },
         onFindings(listener) {
             listeners.add(listener);

package/bin/commit-message.js

@@ -0,0 +1,169 @@
+import { effortArgs, resolveClaudeCommand, runClaudeCli, } from './ai-review.js';
+/**
+ * One-shot commit message drafting.
+ *
+ * The pending changes are handed to the Claude Code CLI running on this
+ * machine (Claude Haiku by default: a subject line is cheap), and the reply
+ * fills the working panel's message box. Nothing is committed — the user
+ * still reviews and edits the text before pressing the commit button.
+ */
+/** Alias handed to `--model`; '' would leave the choice to Claude Code. */
+export const DEFAULT_COMMIT_MESSAGE_MODEL = 'haiku';
+/** A message draft is a small question; it must not outstay the review budget. */
+const COMMIT_MESSAGE_TIMEOUT_SECONDS = 120;
+/** Haiku does not need the whole diff budget the reviewer configures. */
+const COMMIT_MESSAGE_MAX_DIFF_CHARS = 100000;
+const oneLine = (value) => String(value ?? '')
+    .replace(/\s+/g, ' ')
+    .trim();
+/** Renders one file's diff compactly; only +/- markers, no line numbers. */
+function renderFile(file, budget) {
+    const renamed = file.oldPath && file.oldPath !== file.path ? ` (renamed from ${file.oldPath})` : '';
+    const header = `--- ${file.path}${renamed} [${file.status}] ---`;
+    if (file.status === 'binary' || !file.lines.length)
+        return `${header}\n(binary or empty diff)`;
+    const rows = [header];
+    let used = header.length;
+    let truncated = false;
+    for (const line of file.lines) {
+        const row = line.type === 'add'
+            ? `+${line.text}`
+            : line.type === 'del'
+                ? `-${line.text}`
+                : ` ${line.text}`;
+        if (used + row.length + 1 > budget) {
+            truncated = true;
+            break;
+        }
+        rows.push(row);
+        used += row.length + 1;
+    }
+    if (truncated)
+        rows.push('(diff truncated: file too large)');
+    return rows.join('\n');
+}
+/** What the "description" field holds for each commit message style. */
+const DESCRIPTION_BY_STYLE = {
+    oneliner: '\\"\\" always; the subject line is the whole message',
+    brief: 'one to three short sentences or bullet points on what changed and why, wrapped at 72 characters; \\"\\" when the subject alone is clear',
+    descriptive: 'a full body explaining what changed, why, and anything a reviewer should know, wrapped at 72 characters, using bullet points for separate changes',
+};
+const commitMessageContract = (style) => `Reply with one JSON object and nothing else:
+{"subject": "<one line, imperative mood, at most 72 characters, no trailing period>",
+ "description": "<${DESCRIPTION_BY_STYLE[style]}>"}
+
+Rules:
+- Summarize the change as a whole; do not walk through the diff file by file.
+- Match the language and style of the recent commit subjects when they are given.
+- Do not invent ticket numbers, prefixes or attribution the diff does not show.
+- Answer only from the diff below. Do not use tools and do not ask questions.`;
+/** Builds the drafting prompt for the pending changes. */
+export function buildCommitMessagePrompt(input) {
+    const perFile = Math.max(2000, Math.floor(input.maxDiffChars / Math.max(input.files.length, 1)));
+    const body = input.files.map((file) => renderFile(file, perFile)).join('\n');
+    const sections = [
+        'You are writing the commit message for changes in a Git repository.',
+        '',
+        input.branch ? `Branch: ${input.branch}` : '',
+        input.scope === 'staged'
+            ? 'The diff below is exactly what is staged for the next commit.'
+            : 'Nothing is staged yet; the diff below is every uncommitted change, staged or not.',
+        input.recentSubjects.length
+            ? 'RECENT COMMIT SUBJECTS (match their language and style):\n' +
+                input.recentSubjects.map((subject) => `  - ${subject}`).join('\n')
+            : '',
+        '',
+        commitMessageContract(input.style),
+        '',
+        'DIFF',
+        '====',
+        body || '(no changes)',
+    ];
+    return sections.filter((section) => section !== '').join('\n');
+}
+/** Unwraps `--output-format json` and tolerates a fenced or plain-text reply. */
+export function parseCommitMessage(raw) {
+    let text = raw.trim();
+    if (!text)
+        throw new Error('Claude Code returned an empty response.');
+    try {
+        const envelope = JSON.parse(text);
+        if (envelope && typeof envelope === 'object' && !Array.isArray(envelope)) {
+            if (envelope.is_error === true) {
+                throw new Error(String(envelope.result ?? 'Claude Code reported an error.'));
+            }
+            if (typeof envelope.result === 'string')
+                text = envelope.result.trim();
+        }
+    }
+    catch (error) {
+        // Not the CLI envelope; fall through and read the text as the message.
+        if (error?.message?.startsWith('Claude Code'))
+            throw error;
+    }
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenced)
+        text = fenced[1].trim();
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start !== -1 && end > start) {
+        try {
+            const message = JSON.parse(text.slice(start, end + 1));
+            const subject = oneLine(message?.subject);
+            if (subject)
+                return { subject, description: String(message?.description ?? '').trim() };
+        }
+        catch {
+            // Malformed JSON; fall through and read the text as the message.
+        }
+    }
+    // Plain text: the first line is the subject, the rest is the description.
+    const [first, ...rest] = text.split('\n');
+    const subject = oneLine(first);
+    if (!subject) {
+        throw new Error(`Claude Code did not return a commit message: ${text.slice(0, 300)}`);
+    }
+    return { subject, description: rest.join('\n').trim() };
+}
+/** Drafts a commit message by running the Claude Code CLI over the changes. */
+export async function generateCommitMessage(options) {
+    const model = options.model?.trim() ||
+        options.config.commitMessageModel.trim() ||
+        DEFAULT_COMMIT_MESSAGE_MODEL;
+    const prompt = buildCommitMessagePrompt({
+        branch: options.branch,
+        scope: options.scope,
+        files: options.files,
+        recentSubjects: options.recentSubjects,
+        maxDiffChars: Math.min(options.config.maxDiffChars, COMMIT_MESSAGE_MAX_DIFF_CHARS),
+        style: options.config.commitMessageStyle,
+    });
+    const command = await resolveClaudeCommand(options.config.claudePath);
+    const effort = options.config.commitMessageEffort;
+    const args = [
+        '-p',
+        // Background drafts should not show up in the user's Claude Code session history.
+        '--no-session-persistence',
+        '--output-format',
+        'json',
+        ...(model ? ['--model', model] : []),
+        ...effortArgs(effort),
+    ];
+    options.log?.(`AI commit message: drafting with ${command} (${model}${effort ? `, ${effort} effort` : ''})`);
+    const runModel = options.runModel ?? runClaudeCli;
+    const raw = await runModel(prompt, {
+        command,
+        args,
+        cwd: options.cwd,
+        timeoutMs: Math.min(options.config.timeoutSeconds, COMMIT_MESSAGE_TIMEOUT_SECONDS) * 1000,
+        signal: options.signal,
+    });
+    const { subject, description } = parseCommitMessage(raw);
+    // A one-liner stays one line even when the model adds a body anyway.
+    return {
+        subject,
+        description: options.config.commitMessageStyle === 'oneliner' ? '' : description,
+        scope: options.scope,
+        model,
+    };
+}