fix: bound prepare-commit-msg hook latency (#271)

src/git/diff.ts

@@ -1,7 +1,8 @@
-import { execFileSync, spawnSync } from 'node:child_process';
+import { execFile, execFileSync, spawnSync } from 'node:child_process';
 import { accessSync, copyFileSync, existsSync, constants, mkdtempSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, isAbsolute, join, normalize, resolve } from 'node:path';
+import { promisify } from 'node:util';
 
 export interface DiffResult {
   diff: string;
@@ -31,6 +32,7 @@ const GIT_REPOSITORY_ENV_VARS = [
 ] as const;
 const GIT_EXECUTABLE_NAME = process.platform === 'win32' ? 'git.exe' : 'git';
 let gitExecutable: string | undefined;
+const execFileAsync = promisify(execFile);
 
 function getGitEnv(overrides: NodeJS.ProcessEnv = {}): NodeJS.ProcessEnv {
   const env = { ...process.env };
@@ -119,6 +121,55 @@ export function checkGitRepo(): void {
   }
 }
 
+export async function checkGitRepoWithSignal(signal?: AbortSignal): Promise<void> {
+  const executable = getGitExecutable();
+  try {
+    await execFileAsync(executable, ['rev-parse', '--git-dir'], {
+      encoding: 'utf-8',
+      signal,
+    });
+  } catch (err) {
+    if (signal?.aborted) {
+      throw signal.reason instanceof Error ? signal.reason : new Error('Git repository check was cancelled');
+    }
+
+    const nodeErr = err as NodeJS.ErrnoException & { stderr?: string };
+    if (nodeErr.code === 'ENOENT') {
+      throw new Error('git is not installed or not found in a supported location');
+    }
+
+    const stderr = nodeErr.stderr?.trim();
+    throw new Error(stderr || 'Not a git repository');
+  }
+}
+
+export async function getStagedDiffWithSignal(
+  cwd = process.cwd(),
+  indexFile?: string,
+  signal?: AbortSignal,
+): Promise<DiffResult> {
+  try {
+    const { stdout } = await execFileAsync(getGitExecutable(), ['diff', '--cached'], {
+      cwd,
+      encoding: 'utf-8',
+      env: getGitEnv(indexFile ? { GIT_INDEX_FILE: indexFile } : {}),
+      maxBuffer: GIT_DIFF_MAX_BUFFER,
+      signal,
+    });
+
+    return {
+      diff: stdout,
+      hasChanges: stdout.trim().length > 0,
+      staged: true,
+    };
+  } catch (err) {
+    if (signal?.aborted) {
+      throw signal.reason instanceof Error ? signal.reason : new Error('Git staged diff was cancelled');
+    }
+    throw err;
+  }
+}
+
 export function hasCommits(): boolean {
   try {
     const count = execFileSync(getGitExecutable(), ['rev-list', '--count', 'HEAD'], {

src/git/hook.ts

@@ -4,7 +4,7 @@
 import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
 import type { CommitEntry, Config, Suggestion, StyleProfile } from '../types.js';
-import { checkGitRepo, getGitExecutable, getStagedDiff } from './diff.js';
+import { checkGitRepo, checkGitRepoWithSignal, getGitExecutable, getStagedDiffWithSignal } from './diff.js';
 import type { DiffResult } from './diff.js';
 import { loadConfig } from '../config/store.js';
 import { appendEntry, buildProfile } from '../history/store.js';
@@ -15,6 +15,7 @@
 const POST_COMMIT_HOOK_NAME = 'post-commit';
 const PENDING_HOOK_ENTRY_FILE = 'commit-echo-pending-entry.json';
 const BACKUP_OWNER_MARKER = '# commit-echo managed backup';
+export const PREPARE_COMMIT_MSG_HOOK_TIMEOUT_MS = 5_000;
 
 export interface PrepareCommitMsgHookArgs {
   messageFile: string;
@@ -32,16 +33,17 @@
 }
 
 export interface PrepareCommitMsgHookDeps {
-  checkGitRepo: () => void;
+  checkGitRepo: (signal?: AbortSignal) => void | Promise<void>;
   loadConfig: () => Promise<Config>;
-  getStagedDiff: () => DiffResult;
+  getStagedDiff: (signal?: AbortSignal) => DiffResult | Promise<DiffResult>;
   buildProfile: (historySize: number) => Promise<StyleProfile>;
   generateSuggestions: typeof generateSuggestions;
   readMessageFile: (messageFile: string) => Promise<string>;
   writeMessageFile: (messageFile: string, content: string) => Promise<void>;
   writePendingEntryFile: (content: string) => Promise<void>;
   removePendingEntryFile: () => Promise<void>;
   warn: (message: string) => void;
+  timeoutMs?: number;
 }
 
 export interface InstalledCommitHooks {
@@ -602,12 +604,12 @@
   });
 }
 
 export async function runPrepareCommitMsgHook(
   args: PrepareCommitMsgHookArgs,
   deps: PrepareCommitMsgHookDeps = {
-    checkGitRepo,
+    checkGitRepo: checkGitRepoWithSignal,
     loadConfig,
-    getStagedDiff,
+    getStagedDiff: (signal) => getStagedDiffWithSignal(process.cwd(), undefined, signal),
     buildProfile,
     generateSuggestions,
     readMessageFile: async (messageFile) => readFile(messageFile, 'utf-8'),
@@ -622,39 +624,131 @@
     return;
   }
 
-  try {
-    deps.checkGitRepo();
+  const controller = new AbortController();
+  const timeoutMs = deps.timeoutMs ?? PREPARE_COMMIT_MSG_HOOK_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  let timeoutError: Error | undefined;
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  let timedOut = false;
+  let originalMessage: string | undefined;
+  let messageWriteAttempted = false;
 
-    const config = await deps.loadConfig().catch(() => null);
-    if (!config) {
-      deps.warn('commit-echo hook: no configuration found; skipping.');
-      await clearPendingEntryFile(deps.removePendingEntryFile);
+  const abortForTimeout = () => {
+    if (timedOut) {
       return;
     }
+    timedOut = true;
+    timeoutError = new Error('timed out after ' + timeoutMs + 'ms; leaving commit message unchanged.');
+    controller.abort(timeoutError);
+  };
 
-    const diffResult = deps.getStagedDiff();
-    if (!diffResult.hasChanges) {
-      await clearPendingEntryFile(deps.removePendingEntryFile);
-      return;
+  const ensureWithinDeadline = () => {
+    if (controller.signal.aborted) {
+      throw controller.signal.reason instanceof Error
+        ? controller.signal.reason
+        : (timeoutError ?? new Error('commit-echo hook request was cancelled'));
     }
 
-    const profile = await deps.buildProfile(config.historySize);
-    const { suggestions } = await deps.generateSuggestions(config, diffResult.diff, profile);
-    const selected = suggestions[0];
-    if (!selected) {
-      deps.warn('commit-echo hook: no suggestions were generated; leaving commit message unchanged.');
+    if (Date.now() >= deadline) {
+      abortForTimeout();
+      throw timeoutError!;
+    }
+  };
+
+  const timeout = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      abortForTimeout();
+      reject(timeoutError!);
+    }, timeoutMs);
+  });
+
+  let hookOperation: Promise<void> | undefined;
+
+  try {
+    hookOperation = (async () => {
+      await deps.checkGitRepo(controller.signal);
+      ensureWithinDeadline();
+
+      let config: Config | null;
+      try {
+        config = await deps.loadConfig();
+      } catch {
+        ensureWithinDeadline();
+        config = null;
+      }
+      ensureWithinDeadline();
+
+      if (!config) {
+        deps.warn('commit-echo hook: no configuration found; skipping.');
+        await clearPendingEntryFile(deps.removePendingEntryFile);
+        return;
+      }
+
+      const diffResult = await deps.getStagedDiff(controller.signal);
+      ensureWithinDeadline();
+
+      if (!diffResult.hasChanges) {
+        await clearPendingEntryFile(deps.removePendingEntryFile);
+        return;
+      }
+
+      const profile = await deps.buildProfile(config.historySize);
+      ensureWithinDeadline();
+
+      const { suggestions } = await deps.generateSuggestions(
+        config,
+        diffResult.diff,
+        profile,
+        undefined,
+        undefined,
+        controller.signal,
+      );
+      ensureWithinDeadline();
+
+      const selected = suggestions[0];
+      if (!selected) {
+        deps.warn('commit-echo hook: no suggestions were generated; leaving commit message unchanged.');
+        await clearPendingEntryFile(deps.removePendingEntryFile);
+        return;
+      }
+
+      originalMessage = await deps.readMessageFile(args.messageFile);
+      ensureWithinDeadline();
+
+      const nextContent = buildHookCommitMessage(selected, originalMessage);
+      ensureWithinDeadline();
+      messageWriteAttempted = true;
+      await deps.writeMessageFile(args.messageFile, nextContent);
+      ensureWithinDeadline();
+
+      await deps.writePendingEntryFile(buildPendingHookEntry(config, diffResult.diff));
+      ensureWithinDeadline();
+    })();
+
+    await Promise.race([hookOperation, timeout]);
+  } catch (err) {
+    if (timedOut) {
+      if (messageWriteAttempted) {
+        await hookOperation?.catch(() => {});
+      } else {
+        void hookOperation?.catch(() => {});
+      }
+
+      if (messageWriteAttempted && originalMessage !== undefined) {
+        await deps.writeMessageFile(args.messageFile, originalMessage).catch(() => {});
+      }
+
       await clearPendingEntryFile(deps.removePendingEntryFile);
+      const message = timeoutError?.message ?? (err instanceof Error ? err.message : String(err));
+      deps.warn('commit-echo hook: ' + message);
       return;
     }
 
-    const existingContent = await deps.readMessageFile(args.messageFile).catch(() => '');
-    const nextContent = buildHookCommitMessage(selected, existingContent);
-    await deps.writeMessageFile(args.messageFile, nextContent);
-    await deps.writePendingEntryFile(buildPendingHookEntry(config, diffResult.diff));
-  } catch (err) {
     await clearPendingEntryFile(deps.removePendingEntryFile);
     const message = err instanceof Error ? err.message : String(err);
-    deps.warn(`commit-echo hook: ${message}`);
+    deps.warn('commit-echo hook: ' + message);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
   }
 }
 

src/llm/client.ts

@@ -39,6 +39,7 @@ export async function generateSuggestions(
   profileParam?: StyleProfile,
   apiKeyParam?: string,
   precomputedTruncation?: TruncationInfo,
+  signal?: AbortSignal,
 ): Promise<{
   suggestions: Suggestion[];
   profile: StyleProfile;
@@ -73,6 +74,7 @@ export async function generateSuggestions(
     temperature: 0.7,
     maxTokens: 1024,
     apiKey,
+    signal,
   });
 
   const parsed = parseSuggestions(result.content);

src/providers/anthropic.ts

@@ -48,6 +48,9 @@ export class AnthropicProvider implements Provider {
         body: JSON.stringify(body),
       },
       'Anthropic API request',
+      DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
+      new AbortController(),
+      params.signal,
     );
 
     if (!response.ok) {
@@ -92,6 +95,8 @@ export class AnthropicProvider implements Provider {
       'Anthropic streaming request',
       DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
       controller,
+      params.signal,
+      false,
     );
 
     if (!response.ok) {

src/providers/cohere.ts

@@ -1,5 +1,5 @@
 import type { ChatParams, ChatResult, Provider } from '../types.js';
-import { fetchWithTimeout } from './request.js';
+import { DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS, fetchWithTimeout } from './request.js';
 
 export class CohereProvider implements Provider {
   async complete(params: ChatParams): Promise<ChatResult> {
@@ -40,6 +40,9 @@ export class CohereProvider implements Provider {
         body: JSON.stringify(body),
       },
       'Cohere API request',
+      DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
+      new AbortController(),
+      params.signal,
     );
 
     if (!response.ok) {

src/providers/openai-compatible.ts

@@ -43,6 +43,9 @@ export class OpenAICompatibleProvider implements Provider {
         body: JSON.stringify(buildOpenAiRequestBody(params)),
       },
       'OpenAI-compatible API request',
+      DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
+      new AbortController(),
+      params.signal,
     );
 
     if (!response.ok) {
@@ -89,6 +92,8 @@ export class OpenAICompatibleProvider implements Provider {
       'OpenAI-compatible streaming request',
       DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS,
       controller,
+      params.signal,
+      false,
     );
 
     if (!response.ok) {