From 458b0f0a3a9d5089ff46bb09aa854679ec2e843f Mon Sep 17 00:00:00 2001 From: Anddy Sahir Agudelo <44873492+AnddyAgudelo@users.noreply.github.com> Date: Sun, 15 Nov 2026 04:34:19 -0500 Subject: [PATCH] fix(git): honor commit message cancel before the agent spawns (#10937) Cancel only reached the lane token installed at spawn, so a Cancel during the staged-context read or agent-env preparation was ignored and the agent still ran. Register a pending lane token for the whole request: it settles the request as canceled immediately and blocks the later spawn; a spawned agent replaces it with its own kill token as before, and the latest request on a lane wins. Closes #10855 Co-authored-by: Neil --- ...lesystem-git-commit-generation-handlers.ts | 75 +++++++++++-------- .../runtime-git-generation-admission.test.ts | 32 +++++++- .../git/runtime-git-generation-commands.ts | 69 ++++++++++------- .../source-control-generation-lanes.test.ts | 62 +++++++++++++++ .../source-control-generation-lanes.ts | 25 +++++++ 5 files changed, 200 insertions(+), 63 deletions(-) create mode 100644 src/main/text-generation/execution/source-control-generation-lanes.test.ts diff --git a/src/main/ipc/filesystem/filesystem-git-commit-generation-handlers.ts b/src/main/ipc/filesystem/filesystem-git-commit-generation-handlers.ts index fba3d8d737b..be2f2753823 100644 --- a/src/main/ipc/filesystem/filesystem-git-commit-generation-handlers.ts +++ b/src/main/ipc/filesystem/filesystem-git-commit-generation-handlers.ts @@ -19,6 +19,10 @@ import { getLocalGitOptionsForRegisteredWorktree } from '../local-worktree-runti import { withLinkedIssueDraftContext } from '../../../shared/source-control/ai/recipes/source-control-ai-action-variables' import { resolveSourceControlAiLinkedIssue } from '../source-control/source-control-ai-linked-issue' import { prepareLocalCommitMessageAgentEnv } from '../../text-generation/execution/commit-message-agent-environment' +import { + CANCELED_GENERATION_RESULT, + runCancelableLocalGeneration +} from '../../text-generation/execution/source-control-generation-lanes' import type { FilesystemHandlerContext } from './filesystem-handler-context' import { getLocalAgentRuntimeTarget, @@ -78,38 +82,47 @@ export function registerFilesystemGitCommitGenerationHandlers( args.worktreePath, worktreePath ) - let context - try { - context = await getStagedCommitContext(worktreePath, { - ...gitOptions, - admissionTier: 'interactive' - }) - } catch (error) { - console.error('[filesystem] Failed to read staged commit context:', error) - return { - success: false, - ...textGenerationFailure('stagedChangesReadFailed') + return runCancelableLocalGeneration( + 'commit-message', + worktreePath, + async (isCanceled) => { + let context + try { + context = await getStagedCommitContext(worktreePath, { + ...gitOptions, + admissionTier: 'interactive' + }) + } catch (error) { + console.error('[filesystem] Failed to read staged commit context:', error) + return { + success: false, + ...textGenerationFailure('stagedChangesReadFailed') + } + } + if (!context) { + return { success: false, ...textGenerationFailure('noStagedChanges') } + } + context = withLinkedIssueDraftContext( + context, + resolveSourceControlAiLinkedIssue(store, args, worktreePath) + ) + const localEnv = await prepareLocalCommitMessageAgentEnv( + resolvedSettings.params.agentId, + commitMessageAgentEnv, + getLocalAgentRuntimeTarget(gitOptions) + ) + if (!localEnv.ok) { + return { success: false, error: localEnv.error } + } + if (isCanceled()) { + return CANCELED_GENERATION_RESULT + } + return generateCommitMessageFromContext( + context, + resolvedSettings.params, + getLocalTextGenerationTarget(worktreePath, gitOptions, localEnv.env) + ) } - } - if (!context) { - return { success: false, ...textGenerationFailure('noStagedChanges') } - } - context = withLinkedIssueDraftContext( - context, - resolveSourceControlAiLinkedIssue(store, args, worktreePath) - ) - const localEnv = await prepareLocalCommitMessageAgentEnv( - resolvedSettings.params.agentId, - commitMessageAgentEnv, - getLocalAgentRuntimeTarget(gitOptions) - ) - if (!localEnv.ok) { - return { success: false, error: localEnv.error } - } - return generateCommitMessageFromContext( - context, - resolvedSettings.params, - getLocalTextGenerationTarget(worktreePath, gitOptions, localEnv.env) ) } ) diff --git a/src/main/runtime/integrations/git/runtime-git-generation-admission.test.ts b/src/main/runtime/integrations/git/runtime-git-generation-admission.test.ts index 1a459683ebb..97c2fab4fda 100644 --- a/src/main/runtime/integrations/git/runtime-git-generation-admission.test.ts +++ b/src/main/runtime/integrations/git/runtime-git-generation-admission.test.ts @@ -36,10 +36,15 @@ vi.mock('../../../source-control/pull-request-linked-issue', () => ({ vi.mock('../../../text-generation/execution/commit-message-agent-environment', () => ({ prepareLocalCommitMessageAgentEnv: mocks.prepareLocalCommitMessageAgentEnv })) -vi.mock('../../../text-generation/commit-message-text-generation', () => ({ - generateCommitMessageFromContext: mocks.generateCommitMessageFromContext, - generatePullRequestFieldsFromContext: mocks.generatePullRequestFieldsFromContext -})) +vi.mock('../../../text-generation/commit-message-text-generation', async () => { + const { cancelLocalGeneration } = + await import('../../../text-generation/execution/source-control-generation-lanes') + return { + cancelGenerateCommitMessageLocal: (cwd: string) => cancelLocalGeneration('commit-message', cwd), + generateCommitMessageFromContext: mocks.generateCommitMessageFromContext, + generatePullRequestFieldsFromContext: mocks.generatePullRequestFieldsFromContext + } +}) vi.mock('../../../source-control/pull-request-template', () => ({ resolveHostedReviewBodyForGeneration: mocks.resolveHostedReviewBodyForGeneration })) @@ -91,6 +96,25 @@ describe('RuntimeGitGenerationCommands admission', () => { mocks.generatePullRequestFieldsFromContext.mockResolvedValue({ success: true, fields: {} }) }) + it('honors a commit message cancel issued while staged context is loading', async () => { + const stagedContext = Promise.withResolvers() + mocks.getStagedCommitContext.mockReturnValue(stagedContext.promise) + const commands = makeCommands(makeTarget('/repo')) + + const result = commands.generateRuntimeCommitMessage('id:wt-1', settingsOverride) + await vi.waitFor(() => expect(mocks.getStagedCommitContext).toHaveBeenCalledOnce()) + await commands.cancelRuntimeGenerateCommitMessage('id:wt-1') + + await expect(result).resolves.toEqual({ + success: false, + error: 'Generation canceled.', + canceled: true + }) + stagedContext.resolve({ branch: 'main', stagedSummary: 'M\tREADME.md', stagedPatch: '+hello' }) + await nextTurn() + expect(mocks.generateCommitMessageFromContext).not.toHaveBeenCalled() + }) + describe('linked-issue lifetime', () => { function commands(): RuntimeGitGenerationCommands { return makeCommands(makeTarget('/repo')) diff --git a/src/main/runtime/integrations/git/runtime-git-generation-commands.ts b/src/main/runtime/integrations/git/runtime-git-generation-commands.ts index f81be24f0c3..ab7386b8645 100644 --- a/src/main/runtime/integrations/git/runtime-git-generation-commands.ts +++ b/src/main/runtime/integrations/git/runtime-git-generation-commands.ts @@ -26,6 +26,10 @@ import type { } from '../../../text-generation/source-control-text-generation-types' import type { GeneratePullRequestFieldsResult } from '../../../text-generation/commit-message-text-generation' import { getPullRequestDraftContext } from '../../../text-generation/pull-request-context/pull-request-context' +import { + CANCELED_GENERATION_RESULT, + runCancelableLocalGeneration +} from '../../../text-generation/execution/source-control-generation-lanes' import { localGitOptionsForTarget, runtimeGitRouteForTarget, @@ -80,35 +84,44 @@ export class RuntimeGitGenerationCommands { return { success: false, error: SSH_HOST_NOT_SERVED_MESSAGE } } - let context: CommitMessageDraftContext | null - try { - context = await getStagedCommitContext(target.worktree.path, { - ...localGitOptionsForTarget(target), - admissionTier: 'interactive' - }) - } catch (error) { - console.error('[runtime-git] Failed to read staged commit context:', error) - return { - success: false, - ...textGenerationFailure('stagedChangesReadFailed') + return runCancelableLocalGeneration( + 'commit-message', + target.worktree.path, + async (isCanceled) => { + let context: CommitMessageDraftContext | null + try { + context = await getStagedCommitContext(target.worktree.path, { + ...localGitOptionsForTarget(target), + admissionTier: 'interactive' + }) + } catch (error) { + console.error('[runtime-git] Failed to read staged commit context:', error) + return { + success: false, + ...textGenerationFailure('stagedChangesReadFailed') + } + } + if (!context) { + return { success: false, ...textGenerationFailure('noStagedChanges') } + } + context = withLinkedIssueDraftContext(context, linkedIssueForTarget(this.host, target)) + const localEnv = await prepareLocalCommitMessageAgentEnv( + resolvedSettings.params.agentId, + this.host.getCommitMessageAgentEnvironment?.(), + localAgentRuntimeTargetForTarget(target) + ) + if (!localEnv.ok) { + return { success: false, error: localEnv.error } + } + if (isCanceled()) { + return CANCELED_GENERATION_RESULT + } + return generateCommitMessageFromContext( + context, + resolvedSettings.params, + localTextGenerationTargetForTarget(target, localEnv.env) + ) } - } - if (!context) { - return { success: false, ...textGenerationFailure('noStagedChanges') } - } - context = withLinkedIssueDraftContext(context, linkedIssueForTarget(this.host, target)) - const localEnv = await prepareLocalCommitMessageAgentEnv( - resolvedSettings.params.agentId, - this.host.getCommitMessageAgentEnvironment?.(), - localAgentRuntimeTargetForTarget(target) - ) - if (!localEnv.ok) { - return { success: false, error: localEnv.error } - } - return generateCommitMessageFromContext( - context, - resolvedSettings.params, - localTextGenerationTargetForTarget(target, localEnv.env) ) } diff --git a/src/main/text-generation/execution/source-control-generation-lanes.test.ts b/src/main/text-generation/execution/source-control-generation-lanes.test.ts new file mode 100644 index 00000000000..fb8555f6023 --- /dev/null +++ b/src/main/text-generation/execution/source-control-generation-lanes.test.ts @@ -0,0 +1,62 @@ +import { describe, expect, it, vi } from 'vitest' +import { + CANCELED_GENERATION_RESULT, + cancelLocalGeneration, + clearLocalGenerationCancelToken, + localGenerationLaneKey, + runCancelableLocalGeneration, + setLocalGenerationCancelToken +} from './source-control-generation-lanes' + +describe('runCancelableLocalGeneration', () => { + it('settles as canceled when cancel lands before the agent spawns', async () => { + const preparation = Promise.withResolvers() + const spawn = vi.fn() + const run = runCancelableLocalGeneration('commit-message', '/repo', async (isCanceled) => { + await preparation.promise + if (isCanceled()) { + return 'skipped' + } + spawn() + return 'spawned' + }) + + cancelLocalGeneration('commit-message', '/repo') + + await expect(run).resolves.toBe(CANCELED_GENERATION_RESULT) + preparation.resolve() + await preparation.promise + expect(spawn).not.toHaveBeenCalled() + }) + + it('hands cancel to the token a spawned agent installs over the pending one', async () => { + const laneKey = localGenerationLaneKey('commit-message', '/repo') + const killAgent = vi.fn() + const agent = Promise.withResolvers() + const run = runCancelableLocalGeneration('commit-message', '/repo', () => { + setLocalGenerationCancelToken(laneKey, killAgent) + return agent.promise.finally(() => clearLocalGenerationCancelToken(laneKey, killAgent)) + }) + + cancelLocalGeneration('commit-message', '/repo') + expect(killAgent).toHaveBeenCalledOnce() + agent.resolve('agent canceled') + await expect(run).resolves.toBe('agent canceled') + }) + + it('leaves a newer request cancelable after an older one on the lane finishes', async () => { + const older = runCancelableLocalGeneration('commit-message', '/repo', async () => 'older') + const newerPreparation = Promise.withResolvers() + const newer = runCancelableLocalGeneration( + 'commit-message', + '/repo', + () => newerPreparation.promise + ) + await expect(older).resolves.toBe('older') + + cancelLocalGeneration('commit-message', '/repo') + + await expect(newer).resolves.toBe(CANCELED_GENERATION_RESULT) + newerPreparation.resolve('late') + }) +}) diff --git a/src/main/text-generation/execution/source-control-generation-lanes.ts b/src/main/text-generation/execution/source-control-generation-lanes.ts index 60adb2f35de..222c48c9b6e 100644 --- a/src/main/text-generation/execution/source-control-generation-lanes.ts +++ b/src/main/text-generation/execution/source-control-generation-lanes.ts @@ -29,3 +29,28 @@ export function clearLocalGenerationCancelToken(laneKey: string, cancel: () => v cancelTokensByLane.delete(laneKey) } } + +export const CANCELED_GENERATION_RESULT = { + success: false, + error: 'Generation canceled.', + canceled: true +} as const + +/** Holds the lane's cancel token across pre-spawn awaits; a spawned agent replaces it with its own kill token. */ +export function runCancelableLocalGeneration( + operation: TextGenerationOperation, + cwd: string, + run: (isCanceled: () => boolean) => Promise +): Promise { + const laneKey = localGenerationLaneKey(operation, cwd) + let canceled = false + const canceledBeforeSpawn = Promise.withResolvers() + const cancel = (): void => { + canceled = true + canceledBeforeSpawn.resolve(CANCELED_GENERATION_RESULT) + } + setLocalGenerationCancelToken(laneKey, cancel) + return Promise.race([run(() => canceled), canceledBeforeSpawn.promise]).finally(() => + clearLocalGenerationCancelToken(laneKey, cancel) + ) +}