Adds take-side fallback for all conflict types in AI Resolve - #5393

The AI Resolve mode in the Commit Graph WIP details panel could only
auto-merge text conflicts; binary, symlink, submodule, file-mode,
add/add, and rename conflicts were skipped (or errored) and left as
dead-end "needs review" rows with no way to act on them.

- Classifies every conflict by kind from its XY status + per-stage
  file modes/oids, and detects rename/rename, rename/delete, and
  rename/modify conflicts by reusing the merge-base rename correlation
  already used for conflict diffs
- Labels skipped and errored rows by conflict type and offers inline
  Take Current / Take Incoming / Delete actions, gated by which side
  has content to take
- Queues a chosen side as a pending resolution that rides the same
  review-then-Apply lifecycle as AI resolutions (applied on Apply,
  dropped on Discard) rather than mutating the working tree on click;
  the rename/rename loser is queued as a pending delete so the panel
  mirrors exactly what will be applied
- Decodes UTF-16/BOM-encoded files in the conflict read path so their
  conflicts parse and resolve instead of being skipped as marker-less

Author: ianhattendorf

CHANGELOG.md

@@ -16,6 +16,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 - Adds an _Open in Integrated Terminal_ option for worktrees in the _Commit Graph_ and the _Worktrees_ view — opens the selected worktree's folder in the integrated terminal, matching the action already available for repositories and folders ([#5386](https://github.com/gitkraken/vscode-gitlens/issues/5386))
 - Adds a _Reveal in Explorer View_ option for working tree (WIP) files in the _Inspect_ and _Commit Graph_ views — right-click a staged, unstaged, or conflicted working file to reveal and select it in VS Code's Explorer view ([#5387](https://github.com/gitkraken/vscode-gitlens/issues/5387))
 - Adds _Focus on Branch_, _Focus on Worktree_, and _Solo Branch_ options to the _Commit Graph_ — right-click a branch or worktree in the side bar (or a graph row) to focus the graph and minimap on it, and right-click a working tree (WIP) row to focus or solo the graph on that worktree's branch ([#5388](https://github.com/gitkraken/vscode-gitlens/issues/5388))
+- Adds manual take-side fallbacks and conflict-type labels to the AI **Resolve** mode in the _Commit Graph_ WIP details panel — conflicts the AI can't auto-merge (binary, symlink, submodule, file-mode, add/add, and rename/rename or rename/delete conflicts) are now labeled by type and offer inline _Take Current_, _Take Incoming_, and _Delete_ actions instead of dead-ending as "needs review"; resolving a rename/rename conflict also removes the other side's renamed file. Also decodes UTF-16/BOM-encoded files so their conflicts can be resolved rather than skipped ([#5393](https://github.com/gitkraken/vscode-gitlens/issues/5393))
 
 ### Changed
 

packages/git/src/utils/conflictResolution.utils.ts

@@ -2,6 +2,71 @@ import type { GitFileConflictStatus } from '../models/fileStatus.js';
 
 export type ConflictResolutionAction = 'take-ours' | 'take-theirs' | 'delete' | 'unsupported';
 
+/**
+ * A richer description of a conflict than the raw XY status code — used to label conflicts the
+ * AI text resolver can't parse (binary, symlink, submodule, mode-only, add/add) and to surface
+ * rename conflicts. Derived by {@link classifyConflictKind} from the XY status plus, when
+ * available, the per-stage file modes/oids and rename/binary hints the caller computes.
+ */
+export type ConflictKind =
+	| 'text'
+	| 'binary'
+	| 'symlink'
+	| 'submodule'
+	| 'mode-only'
+	| 'add-add'
+	| 'delete-modify'
+	| 'both-deleted'
+	| 'rename-rename'
+	| 'rename-delete'
+	| 'rename-modify'
+	| 'unknown';
+
+export type ConflictRenameKind = 'rename-rename' | 'rename-delete' | 'rename-modify';
+
+const symlinkMode = '120000';
+const submoduleMode = '160000';
+
+/**
+ * Classifies a conflict into a {@link ConflictKind}. Pure — all detection that needs git/IO
+ * (rename correlation, binary sniffing) is computed by the caller and passed via `hints`. When
+ * `modes`/`oids` are omitted (e.g. a webview caller that only has the XY status), it still returns
+ * a useful coarse kind; pass the per-stage data for the fine-grained symlink/submodule/mode-only split.
+ */
+export function classifyConflictKind(
+	status: GitFileConflictStatus,
+	modes?: { base?: string; current?: string; incoming?: string },
+	oids?: { base?: string; current?: string; incoming?: string },
+	hints?: { binary?: boolean; rename?: ConflictRenameKind },
+): ConflictKind {
+	if (hints?.rename != null) return hints.rename;
+
+	if (status === 'DD') return 'both-deleted';
+	if (status === 'UD' || status === 'DU') return 'delete-modify';
+
+	const presentModes = [modes?.current, modes?.incoming, modes?.base].filter((m): m is string => m != null);
+	if (presentModes.includes(submoduleMode)) return 'submodule';
+	if (presentModes.includes(symlinkMode)) return 'symlink';
+
+	if (hints?.binary) return 'binary';
+
+	// Both sides present with identical content (same oid) but different mode → only the file mode
+	// conflicts (e.g. one side flipped the executable bit).
+	if (
+		modes?.current != null &&
+		modes?.incoming != null &&
+		modes.current !== modes.incoming &&
+		oids?.current != null &&
+		oids.current === oids?.incoming
+	) {
+		return 'mode-only';
+	}
+
+	if (status === 'AA' || status === 'AU' || status === 'UA') return 'add-add';
+
+	return 'text';
+}
+
 export function classifyConflictAction(
 	status: GitFileConflictStatus,
 	resolution: 'current' | 'incoming',
@@ -29,3 +94,64 @@ export function canStageCurrent(status: GitFileConflictStatus): boolean {
 export function canStageIncoming(status: GitFileConflictStatus): boolean {
 	return status !== 'AU' && status !== 'DD';
 }
+
+/** A short label + one-line description for a {@link ConflictKind}, used to explain conflicts the AI
+ *  resolver can't auto-merge (and rename conflicts) wherever they're surfaced. */
+export function getConflictKindLabel(kind: ConflictKind, renameOf?: string): { label: string; description: string } {
+	const named = renameOf ? `"${renameOf}"` : 'The file';
+	switch (kind) {
+		case 'binary':
+			return {
+				label: 'Binary conflict',
+				description: 'Binary file changed on both sides — choose a side to keep',
+			};
+		case 'symlink':
+			return {
+				label: 'Symlink conflict',
+				description: 'Symbolic link changed on both sides — choose a side to keep',
+			};
+		case 'submodule':
+			return {
+				label: 'Submodule conflict',
+				description: 'Submodule reference changed on both sides — choose a side to keep',
+			};
+		case 'mode-only':
+			return {
+				label: 'File mode conflict',
+				description: 'Only the file mode differs (e.g. the executable bit) — choose a side to keep',
+			};
+		case 'add-add':
+			// Covers AA (added on both sides) as well as AU/UA (added on one side) — keep the wording
+			// accurate for all three rather than asserting "both sides".
+			return {
+				label: 'Add conflict',
+				description: 'Conflicting file additions — choose a side to keep',
+			};
+		case 'delete-modify':
+			return {
+				label: 'Modified and deleted',
+				description: 'Deleted on one side and modified on the other — keep the file or delete it',
+			};
+		case 'both-deleted':
+			return { label: 'Deleted on both sides', description: 'Deleted on both sides — confirm the deletion' };
+		case 'rename-rename':
+			return {
+				label: 'Renamed differently',
+				description: `${named} was renamed differently on each side — choose which name to keep`,
+			};
+		case 'rename-delete':
+			return {
+				label: 'Renamed and deleted',
+				description: `${named} was renamed on one side and deleted on the other — keep the file or delete it`,
+			};
+		case 'rename-modify':
+			return {
+				label: 'Renamed and modified',
+				description: `${named} was renamed on one side and modified on the other`,
+			};
+		case 'text':
+			return { label: 'Text conflict', description: 'Conflicting changes on both sides' };
+		default:
+			return { label: 'Conflict', description: 'Resolve this conflict manually' };
+	}
+}

src/git/utils/-webview/__tests__/conflictKind.utils.test.ts

@@ -0,0 +1,67 @@
+import * as assert from 'assert';
+import type { GitFile } from '@gitlens/git/models/file.js';
+import type { GitFileConflictStatus } from '@gitlens/git/models/fileStatus.js';
+import type { GitConflictFile } from '@gitlens/git/models/staging.js';
+import { detectRename } from '../conflictKind.utils.js';
+
+function conflictFile(path: string, status: GitFileConflictStatus): GitConflictFile {
+	const file: GitConflictFile = { path: path, repoPath: '/repo', status: status, conflictStatus: status };
+	return file;
+}
+
+function renamed(originalPath: string, path: string): GitFile {
+	return { path: path, originalPath: originalPath, status: 'R' };
+}
+
+function deleted(path: string): GitFile {
+	return { path: path, status: 'D' };
+}
+
+function modified(path: string): GitFile {
+	return { path: path, status: 'M' };
+}
+
+suite('git/-webview/conflictKind.utils', () => {
+	suite('detectRename', () => {
+		test('rename/rename — both sides rename the original to different targets', () => {
+			// ours-renamed.txt is added-by-us (AU); ours renamed orig→ours-renamed, theirs renamed orig→theirs-renamed.
+			const result = detectRename(
+				conflictFile('ours-renamed.txt', 'AU'),
+				[renamed('orig.txt', 'ours-renamed.txt')],
+				[renamed('orig.txt', 'theirs-renamed.txt')],
+			);
+			assert.deepStrictEqual(result, {
+				kind: 'rename-rename',
+				renameOf: 'orig.txt',
+				renamePairPath: 'theirs-renamed.txt',
+			});
+		});
+
+		test('rename/delete — one side renames, the other deletes (UD)', () => {
+			const result = detectRename(
+				conflictFile('ours-kept.txt', 'UD'),
+				[renamed('orig.txt', 'ours-kept.txt')],
+				[deleted('orig.txt')],
+			);
+			assert.deepStrictEqual(result, { kind: 'rename-delete', renameOf: 'orig.txt' });
+		});
+
+		test('rename+modify — one side renames, the other modifies content (UU)', () => {
+			const result = detectRename(
+				conflictFile('all-renamed.txt', 'UU'),
+				[renamed('all-rename-modify.txt', 'all-renamed.txt')],
+				[modified('all-rename-modify.txt')],
+			);
+			assert.deepStrictEqual(result, { kind: 'rename-modify', renameOf: 'all-rename-modify.txt' });
+		});
+
+		test('no rename — plain content conflict returns undefined', () => {
+			const result = detectRename(conflictFile('file.txt', 'UU'), [modified('file.txt')], [modified('file.txt')]);
+			assert.strictEqual(result, undefined);
+		});
+
+		test('returns undefined when no diff data is available', () => {
+			assert.strictEqual(detectRename(conflictFile('file.txt', 'UU'), undefined, undefined), undefined);
+		});
+	});
+});

src/git/utils/-webview/conflictKind.utils.ts

@@ -0,0 +1,121 @@
+import type { GitFile } from '@gitlens/git/models/file.js';
+import type { GitFileConflictStatus } from '@gitlens/git/models/fileStatus.js';
+import type { GitConflictFile } from '@gitlens/git/models/staging.js';
+import type { ConflictKind, ConflictRenameKind } from '@gitlens/git/utils/conflictResolution.utils.js';
+import {
+	canStageCurrent,
+	canStageIncoming,
+	classifyConflictKind,
+} from '@gitlens/git/utils/conflictResolution.utils.js';
+import { getConflictIncomingRef, resolveConflictFilePaths } from '@gitlens/git/utils/pausedOperationStatus.utils.js';
+import { getSettledValue } from '@gitlens/utils/promise.js';
+import type { GitRepositoryService } from '../../gitRepositoryService.js';
+
+export interface ConflictFileInfo {
+	readonly path: string;
+	readonly conflictStatus: GitFileConflictStatus;
+	readonly kind: ConflictKind;
+	readonly canStageCurrent: boolean;
+	readonly canStageIncoming: boolean;
+	/** Original (pre-rename) path when a rename is involved. */
+	readonly renameOf?: string;
+	/** For rename/rename: the other side's target path (the "loser" to remove when taking a side). */
+	readonly renamePairPath?: string;
+}
+
+/**
+ * Builds a per-path map describing each conflicted file richly enough to label it and offer the
+ * right take-side actions — the conflict {@link ConflictKind}, which sides can be staged, and any
+ * rename relationship. Rename detection mirrors `openConflictChanges`: diff the merge-base against
+ * each side with rename detection on, then correlate via {@link resolveConflictFilePaths} (conflict
+ * files from `git status` don't carry `originalPath`).
+ *
+ * Binary sniffing is intentionally NOT done here (it would cost a working-tree read per file). A
+ * conflicted file that would otherwise classify as `text` but was skipped by the AI resolver (no
+ * markers) is binary/unsupported by inference — callers labeling skipped rows should treat a
+ * `text` kind as `binary`.
+ */
+export async function getConflictFileInfos(
+	svc: GitRepositoryService,
+	conflictFiles?: GitConflictFile[],
+): Promise<Map<string, ConflictFileInfo>> {
+	conflictFiles ??= await svc.status.getConflictingFiles();
+
+	const infos = new Map<string, ConflictFileInfo>();
+	if (!conflictFiles.length) return infos;
+
+	// Rename detection needs the merge-base + the incoming ref to diff each side with `-M`. When the
+	// paused-operation status (or its merge-base) is unavailable, fall back to mode/oid/status-only
+	// classification — every file still gets a usable kind, just without rename labels.
+	let currentFiles: GitFile[] | undefined;
+	let incomingFiles: GitFile[] | undefined;
+
+	const pausedStatus = await svc.pausedOps?.getPausedOperationStatus?.();
+	const mergeBase = pausedStatus?.mergeBase;
+	if (pausedStatus != null && mergeBase != null) {
+		const incomingRef = getConflictIncomingRef(pausedStatus) ?? pausedStatus.HEAD.ref;
+		const [currentResult, incomingResult] = await Promise.allSettled([
+			svc.diff.getDiffStatus(mergeBase, 'HEAD', { renameLimit: 0 }),
+			svc.diff.getDiffStatus(mergeBase, incomingRef, { renameLimit: 0 }),
+		]);
+		currentFiles = getSettledValue(currentResult);
+		incomingFiles = getSettledValue(incomingResult);
+	}
+
+	for (const file of conflictFiles) {
+		const status = file.conflictStatus;
+		const rename = detectRename(file, currentFiles, incomingFiles);
+
+		const kind = classifyConflictKind(
+			status,
+			{ base: file.base?.mode, current: file.current?.mode, incoming: file.incoming?.mode },
+			{ base: file.base?.oid, current: file.current?.oid, incoming: file.incoming?.oid },
+			{ rename: rename?.kind },
+		);
+
+		infos.set(file.path, {
+			path: file.path,
+			conflictStatus: status,
+			kind: kind,
+			canStageCurrent: canStageCurrent(status),
+			canStageIncoming: canStageIncoming(status),
+			renameOf: rename?.renameOf,
+			renamePairPath: rename?.renamePairPath,
+		});
+	}
+
+	return infos;
+}
+
+export function detectRename(
+	file: GitConflictFile,
+	currentFiles: GitFile[] | undefined,
+	incomingFiles: GitFile[] | undefined,
+): { kind: ConflictRenameKind; renameOf: string; renamePairPath?: string } | undefined {
+	if (currentFiles == null && incomingFiles == null) return undefined;
+
+	const path = file.path;
+	// `resolveConflictFilePaths` checks a rename on either side and returns the merge-base (original)
+	// path as `lhsPath`. A differing lhsPath means this conflicted file was renamed by some side.
+	const { lhsPath } = resolveConflictFilePaths(currentFiles, incomingFiles, path);
+	if (lhsPath === path) return undefined;
+
+	const renameOf = lhsPath;
+	const status = file.conflictStatus;
+
+	// One side renamed, the other deleted the original.
+	if (status === 'UD' || status === 'DU') return { kind: 'rename-delete', renameOf: renameOf };
+
+	// Did both sides rename the same original to (different) targets?
+	const isRenameTo = (f: GitFile) => (f.status === 'R' || f.status === 'C') && f.originalPath === renameOf;
+	const currentTargets = (currentFiles ?? []).filter(isRenameTo).map(f => f.path);
+	const incomingTargets = (incomingFiles ?? []).filter(isRenameTo).map(f => f.path);
+
+	if (currentTargets.length && incomingTargets.length) {
+		const renamePairPath = [...currentTargets, ...incomingTargets].find(p => p !== path);
+		return { kind: 'rename-rename', renameOf: renameOf, renamePairPath: renamePairPath };
+	}
+
+	// One side renamed, the other modified content at the original path.
+	return { kind: 'rename-modify', renameOf: renameOf };
+}