@gitkraken/core-gitlens 0.3.0 → 0.4.0

package/src/git/models/repository.ts

@@ -7,7 +7,6 @@ import type { UnifiedDisposable } from '../../utils/disposable.js';
 import { createDisposable } from '../../utils/disposable.js';
 import type { Event } from '../../utils/event.js';
 import { Emitter } from '../../utils/event.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
 import { basename, normalizePath } from '../../utils/path.js';
 import type { Uri } from '../../utils/uri.js';
 import { fileUri } from '../../utils/uri.js';
@@ -84,8 +83,6 @@ export interface RepositoryInit {
 	readonly gitDir: GitDir | undefined;
 	readonly index: number;
 	readonly root: boolean;
-	readonly closed?: boolean;
-	readonly suspended?: boolean;
 	readonly watchService: RepositoryWatchService;
 }
 
@@ -118,19 +115,21 @@ export class Repository {
 	readonly root: boolean;
 
 	protected readonly _gitDir: GitDir | undefined;
-	protected _pendingResumeTimer: ReturnType<typeof setTimeout> | undefined;
 	protected _repoSubscription: RepositorySubscription | undefined;
-	protected _suspended: boolean;
 	protected _watchHandle: WatchHandle | undefined;
 	protected readonly _watchService: RepositoryWatchService;
 
 	private _pendingWorkingTreeChange?: RepositoryWorkingTreeChangeEvent;
 	private _pendingWorkingTreeFlush = false;
 	private _repoChangeListener: UnifiedDisposable | undefined;
+	/** Outstanding leases on the shared {@link _watchHandle} across `watch()` + `watchWorkingTree()`. */
+	private _watchHandleRefs = 0;
+	/** Outstanding `watch()` (repo-change) leases; drives the single shared bridge subscription. */
+	private _watchRefs = 0;
+	private _disposed = false;
 
 	constructor(init: RepositoryInit) {
 		({
-			closed: this._closed = init.closed ?? false,
 			id: this.id,
 			index: this.index,
 			gitDir: this._gitDir,
@@ -138,7 +137,6 @@ export class Repository {
 			path: this.path,
 			provider: this.provider,
 			root: this.root,
-			suspended: this._suspended = init.suspended ?? false,
 			uri: this.uri,
 			watchService: this._watchService,
 		} = init);
@@ -156,45 +154,25 @@ export class Repository {
 				this._name = `${prefix}${this._name}`;
 			}
 		}
-
-		this.setupWatching();
 	}
 
 	dispose(): void {
-		clearTimeout(this._pendingResumeTimer);
+		this._disposed = true;
 		this._repoChangeListener?.dispose();
 		this._repoChangeListener = undefined;
 		this._repoSubscription?.dispose();
 		this._repoSubscription = undefined;
 		this._watchHandle?.dispose();
 		this._watchHandle = undefined;
+		this._watchHandleRefs = 0;
+		this._watchRefs = 0;
 		this._onDidChange.dispose();
 		this._onDidChangeWorkingTree.dispose();
 	}
 
-	protected _closed: boolean;
-	get closed(): boolean {
-		return this._closed;
-	}
-	set closed(value: boolean) {
-		const changed = this._closed !== value;
-		this._closed = value;
-		if (changed) {
-			if (this._closed) {
-				// When closing, fire immediately even if suspended
-				this.fireChange('closed', true);
-
-				this._repoChangeListener?.dispose();
-				this._repoChangeListener = undefined;
-				this._repoSubscription?.dispose();
-				this._repoSubscription = undefined;
-			} else {
-				this.setupWatching();
-				this.fireChange('opened');
-			}
-
-			this.onClosedChanged(value);
-		}
+	/** Indicates whether this repository currently has an active `watch()` (repo-change) lease. */
+	get watching(): boolean {
+		return this._watchRefs > 0;
 	}
 
 	get etag(): number {
@@ -249,41 +227,6 @@ export class Repository {
 		return this.provider.virtual;
 	}
 
-	@trace({ onlyExit: true })
-	suspend(): void {
-		this._suspended = true;
-		this._watchHandle?.session.suspend();
-
-		if (this._pendingResumeTimer != null) {
-			clearTimeout(this._pendingResumeTimer);
-			this._pendingResumeTimer = undefined;
-		}
-	}
-
-	@trace({ onlyExit: true })
-	resume(delayMs?: number): void {
-		if (delayMs) {
-			if (this._pendingResumeTimer != null) {
-				clearTimeout(this._pendingResumeTimer);
-			}
-			this._pendingResumeTimer = setTimeout(() => {
-				this._pendingResumeTimer = undefined;
-				this.resume();
-			}, delayMs);
-			return;
-		}
-
-		const scope = getScopedLogger();
-
-		if (!this._suspended) {
-			scope?.addExitInfo('ignored; not suspended');
-			return;
-		}
-
-		this._suspended = false;
-		this._watchHandle?.session.resume();
-	}
-
 	waitForRepoChange(timeoutMs: number): Promise<boolean> {
 		let timeoutId: ReturnType<typeof setTimeout> | undefined;
 		let listener: UnifiedDisposable | undefined;
@@ -313,17 +256,57 @@ export class Repository {
 		]);
 	}
 
+	/**
+	 * Starts watching this repository's `.git` directory for repo-change events (delivered via
+	 * {@link onDidChange}) and returns a lease. Ref-counted: the underlying watch handle is acquired
+	 * on the first lease (across `watch()` and {@link watchWorkingTree}) and released when the last
+	 * is disposed. The model is inert until watched. No-ops (returns a disposable that does nothing)
+	 * for repositories without a git directory (e.g. virtual repos).
+	 */
+	@trace({ onlyExit: true })
+	watch(): UnifiedDisposable {
+		const acquired = this.acquireWatchHandle();
+		if (acquired == null) return createDisposable(() => {});
+
+		if (this._watchRefs++ === 0) {
+			const sub = acquired.handle.session.subscribe();
+			this._repoSubscription = sub;
+			this._repoChangeListener = sub.onDidChange(e => this.onSessionRepoChange(e));
+		}
+
+		return createDisposable(
+			() => {
+				// Repo already torn down — its handle/subscriptions are gone; skip to avoid a negative refcount
+				if (this._disposed) return;
+
+				if (--this._watchRefs === 0) {
+					this._repoChangeListener?.dispose();
+					this._repoChangeListener = undefined;
+					this._repoSubscription?.dispose();
+					this._repoSubscription = undefined;
+				}
+				acquired.lease.dispose();
+			},
+			{ once: true },
+		);
+	}
+
 	@trace({ onlyExit: true })
 	watchWorkingTree(delay: number = 2500): UnifiedDisposable {
-		const sub = this._watchHandle?.session.subscribeToWorkingTree({ delayMs: delay });
-		if (sub == null) return createDisposable(() => {});
+		const acquired = this.acquireWatchHandle();
+		if (acquired == null) return createDisposable(() => {});
 
+		const sub = acquired.handle.session.subscribeToWorkingTree({ delayMs: delay });
 		const listener = sub.onDidChangeWorkingTree(e => this.onWorkingTreeChanged(e.paths));
 
-		return createDisposable(() => {
-			listener.dispose();
-			sub.dispose();
-		});
+		return createDisposable(
+			() => {
+				listener.dispose();
+				sub.dispose();
+				acquired.lease.dispose();
+			},
+			{ once: true },
+		);
 	}
 
 	/**
@@ -338,7 +321,7 @@ export class Repository {
 	protected fireChange(change: RepositoryChange, force: boolean): void;
 	@trace()
 	protected fireChange(...args: RepositoryChange[] | [RepositoryChange, boolean]): void {
-		const lastArg = args[args.length - 1];
+		const lastArg = args.at(-1);
 		const force = typeof lastArg === 'boolean' ? lastArg : false;
 		const changes = (force ? args.slice(0, -1) : args) as RepositoryChange[];
 
@@ -353,9 +336,6 @@ export class Repository {
 		this._watchHandle?.session.fireChange(...changes);
 	}
 
-	/** Called when the closed state changes. Override to add behavior (e.g., branch access tracking). */
-	protected onClosedChanged(_closed: boolean): void {}
-
 	/** Called when the watch service notifies of FETCH_HEAD changes. */
 	protected onFetchHeadChanged(): void {
 		// Don't reset `_lastFetched` here: the FS watcher can fire even when the on-disk mtime
@@ -414,39 +394,50 @@ export class Repository {
 			(this._pendingWorkingTreeChange.uris as Set<Uri>).add(fileUri(p));
 		}
 
-		if (this._suspended) return;
 		if (this._pendingWorkingTreeFlush) return;
 
 		this._pendingWorkingTreeFlush = true;
 		queueMicrotask(() => {
 			this._pendingWorkingTreeFlush = false;
 			const e = this._pendingWorkingTreeChange;
-			if (e == null || this._suspended) return;
+			if (e == null) return;
 
 			this._pendingWorkingTreeChange = undefined;
 			this._onDidChangeWorkingTree.fire(e);
 		});
 	}
 
-	@trace({ onlyExit: true })
-	private setupWatching(): void {
-		if (this._gitDir == null || this._closed) return;
-		if (this._repoSubscription != null) return;
-
-		const scope = getScopedLogger();
+	/**
+	 * Lazily acquires (and ref-counts) the shared {@link _watchHandle} for this repository, returning
+	 * the handle plus a one-shot lease whose disposal decrements the ref count (releasing the handle
+	 * when the last lease is gone). Returns `undefined` for repositories without a git directory.
+	 */
+	private acquireWatchHandle(): { handle: WatchHandle; lease: UnifiedDisposable } | undefined {
+		if (this._gitDir == null || this._disposed) return undefined;
 
 		this._watchHandle ??= this._watchService.watch(this.path, this._gitDir, {
 			onFetchHeadChanged: () => this.onFetchHeadChanged(),
 			onGitIgnoreChanged: () => this.onGitIgnoreChanged(),
 			onIgnoresChanged: () => this.onIgnoresChanged(),
 		} satisfies WatchHooks);
-		if (this._watchHandle == null) return;
-
-		const sub = this._watchHandle.session.subscribe();
-		this._repoSubscription = sub;
-		this._repoChangeListener = sub.onDidChange(e => this.onSessionRepoChange(e));
-
-		scope?.trace(`subscribed to repo changes for '${this.uri.toString()}'`);
+		const handle = this._watchHandle;
+		if (handle == null) return undefined;
+
+		this._watchHandleRefs++;
+		const lease = createDisposable(
+			() => {
+				// Repo already torn down — the handle is gone; skip to avoid a negative refcount
+				if (this._disposed) return;
+
+				if (--this._watchHandleRefs === 0) {
+					this._watchHandle?.dispose();
+					this._watchHandle = undefined;
+				}
+			},
+			{ once: true },
+		);
+
+		return { handle: handle, lease: lease };
 	}
 
 	static is(repository: unknown): repository is Repository {

package/src/git/models/statusFile.ts

@@ -94,6 +94,18 @@ export class GitStatusFile implements GitFile {
 		return this.conflictStatus != null;
 	}
 
+	/**
+	 * True when the file has both staged (index) and unstaged (working-tree) changes and is not
+	 * conflicted. Used by the host-side discard flows to apply partial-discard semantics — drop the
+	 * working-tree delta while preserving the staged portion. Centralized here so those host paths
+	 * agree on what "mixed" means. (The webview button predicate can't consume this getter — it
+	 * runs against the wire `GitFileChangeShape` and infers the same state from the duplicate
+	 * staged/unstaged rows the WIP feed emits per mixed path.)
+	 */
+	get mixed(): boolean {
+		return this.indexStatus != null && this.workingTreeStatus != null && this.conflictStatus == null;
+	}
+
 	get staged(): boolean {
 		return this.indexStatus != null;
 	}

package/src/git/providers/commits.ts

@@ -78,6 +78,10 @@ export interface GitCommitReachability {
 export interface GitCommitsSubProvider {
 	getCommit(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<GitCommit | undefined>;
 	getCommitCount(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<number | undefined>;
+	/** Whether `rev` has any commits not reachable from any remote-tracking ref (i.e. unpushed/unpublished).
+	 *  Cheap early-exit probe (`rev-list --not --remotes <rev> -n 1`) — it does NOT count them. Returns
+	 *  `undefined` when it can't be determined. */
+	hasUnpublishedCommits?(repoPath: string, rev: string, cancellation?: AbortSignal): Promise<boolean | undefined>;
 	/** Cheap author/committer date lookup for a single revision. Skips the full commit parse (no files, parents, or message) — use when only the dates are needed. Pass a full SHA so caching stays correct (commits are immutable; refs are not). */
 	getCommitDates?(
 		repoPath: string,

package/src/git/providers/config.ts

@@ -88,11 +88,7 @@ export interface GitConfigSubProvider {
 		| []
 	>;
 
-	getGkConfig?(
-		repoPath: string,
-		key: GkConfigKeys | DeprecatedGkConfigKeys,
-		options?: { type?: GitConfigType },
-	): Promise<string | undefined>;
+	getGkConfig?(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys): Promise<string | undefined>;
 	getGkConfigRegex?(repoPath: string, pattern: string): Promise<Map<string, string>>;
 	setGkConfig?(
 		repoPath: string,

package/src/git/providers/operations.ts

@@ -21,31 +21,14 @@ export interface GitOperationResult {
 export type GitOperationRunOptions = Pick<GitRunOptions, 'env' | 'cancellation' | 'timeout'>;
 
 export interface GitOperationsSubProvider {
-	checkout(
-		repoPath: string,
-		ref: string,
-		options?: { createBranch?: string | undefined } | { path?: string | undefined },
-		runOptions?: GitOperationRunOptions,
-	): Promise<void>;
 	/**
-	 * Checks out one side of a conflicted path during a paused merge/rebase/cherry-pick.
-	 * Executes `git checkout --ours|--theirs -- <path>`, leaving the file unstaged.
+	 * Switches the repository to a branch or ref. Pure branch/ref switching — does not accept
+	 * a path. For path-level operations use {@link restore}.
 	 */
-	checkoutConflictedPath(
-		repoPath: string,
-		path: string,
-		side: 'ours' | 'theirs',
-		runOptions?: GitOperationRunOptions,
-	): Promise<void>;
-	/**
-	 * Checks out one side for multiple conflicted paths during a paused merge/rebase/cherry-pick.
-	 * Batches paths into `git checkout --ours|--theirs -- <paths...>`, chunked to stay under the
-	 * CLI length limit. Leaves files unstaged.
-	 */
-	checkoutConflictedPaths(
+	checkout(
 		repoPath: string,
-		paths: string[],
-		side: 'ours' | 'theirs',
+		ref: string,
+		options?: { createBranch?: string | undefined; noTracking?: boolean },
 		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
 	cherryPick(
@@ -110,8 +93,24 @@ export interface GitOperationsSubProvider {
 		options?: {
 			autoStash?: boolean;
 			branch?: string;
+			/** Command set as `sequence.editor` — edits the interactive rebase todo list. */
 			editor?: string;
 			interactive?: boolean;
+			/**
+			 * Set when the `editor` is a script that rewrites the todo by command word + SHA (e.g. the
+			 * Commit Graph's headless squash/drop/reword) rather than a human. Forces git to emit a plain,
+			 * natural-order todo by disabling `rebase.autosquash` (which would reorder commits and rewrite
+			 * `pick`→`fixup` for `fixup!`/`squash!` commits) and `rebase.abbreviateCommands` (which would
+			 * emit `p` instead of `pick`). Both honor the user's git config otherwise.
+			 */
+			programmaticEditor?: boolean;
+			/**
+			 * Command git uses to edit per-commit messages (the combined message a `squash` produces, or a
+			 * `reword`). Applied as `GIT_EDITOR` — which git's interactive-rebase `reword`/`squash` step honors,
+			 * unlike `core.editor` — with `core.editor` also set as a fallback. When omitted, git falls back to
+			 * the user's configured editor.
+			 */
+			messageEditor?: string;
 			onto?: string;
 			updateRefs?: boolean;
 			source?: unknown;
@@ -124,6 +123,27 @@ export interface GitOperationsSubProvider {
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
 		runOptions?: GitOperationRunOptions,
 	): Promise<void>;
+	/**
+	 * Restores the working-tree copy of one or more paths. Single path or array; arrays are
+	 * chunked under the CLI length limit and dispatched as one git invocation per chunk
+	 * (typically one for normal-sized batches).
+	 *
+	 * Source selection — `options` is mutually exclusive (`side` wins if both are supplied):
+	 *
+	 * - **No options** (`git checkout -- <paths>`): copies the index to the working tree, leaving
+	 *   the index untouched. Use to drop unstaged changes (mixed-file partial discard preserves
+	 *   the staged portion this way).
+	 * - **`{ ref }`** (`git checkout <ref> -- <paths>`): resets BOTH the index and the working
+	 *   tree of the path(s) to `<ref>`. Use to fully revert files to HEAD, a specific commit, etc.
+	 * - **`{ side }`** (`git checkout --ours|--theirs -- <paths>`): conflict-resolution
+	 *   shortcut, valid only during a paused merge/rebase/cherry-pick. Leaves files unstaged.
+	 */
+	restore(
+		repoPath: string,
+		path: string | string[],
+		options?: { ref?: string; side?: 'ours' | 'theirs' },
+		runOptions?: GitOperationRunOptions,
+	): Promise<void>;
 	revert(
 		repoPath: string,
 		refs: string[],

package/src/git/providers/worktrees.ts

@@ -5,12 +5,24 @@ export interface GitWorktreesSubProvider {
 	createWorktree(
 		repoPath: string,
 		path: string,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+		options?: {
+			commitish?: string;
+			createBranch?: string;
+			detach?: boolean;
+			force?: boolean;
+			noTracking?: boolean;
+		},
 	): Promise<void>;
 	createWorktreeWithResult(
 		repoPath: string,
 		path: string,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+		options?: {
+			commitish?: string;
+			createBranch?: string;
+			detach?: boolean;
+			force?: boolean;
+			noTracking?: boolean;
+		},
 	): Promise<GitWorktree | undefined>;
 	getWorktree(
 		repoPath: string,

package/src/git/remotes/custom.ts

@@ -35,6 +35,29 @@ export class CustomRemoteProvider extends RemoteProvider {
 		return [];
 	}
 
+	get avatarUrlTemplate(): string | undefined {
+		return this.urls.avatar;
+	}
+
+	getUrlForAvatar(email: string, size: number): string | undefined {
+		if (this.urls.avatar == null) return undefined;
+
+		// Split on the last `@` so local-parts that contain `@` are preserved (per RFC 5322)
+		const at = email.lastIndexOf('@');
+		const emailName = at === -1 ? email : email.slice(0, at);
+		const domain = at === -1 ? '' : email.slice(at + 1);
+
+		// Component-encode identity values — commit emails are attacker-controllable and
+		// must never be able to inject URL-structural characters (`/`, `?`, `#`, ...) into the
+		// resulting URL
+		return interpolate(this.urls.avatar, {
+			email: encodeURIComponent(email),
+			emailName: encodeURIComponent(emailName),
+			domain: encodeURIComponent(domain),
+			size: String(size),
+		});
+	}
+
 	protected override getUrlForRepository(): string {
 		return this.getUrl(this.urls.repository, this.getContext());
 	}

package/src/git/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' };
+	}
+}

package/src/git/utils/contributor.utils.ts

@@ -79,3 +79,27 @@ export function calculateDistribution<T extends string>(
 export function matchContributor(c: GitContributor, user: GitUser): boolean {
 	return c.name === user.name && c.email === user.email && c.username === user.username;
 }
+
+/** Appends `Co-authored-by:` trailers for the given coauthors to a commit message, replacing
+ *  any existing trailer block. Each coauthor is the `Name <email>` form (GitContributor.coauthor). */
+export function appendCoauthorsToMessage(message: string, coauthors: Iterable<string>): string {
+	const index = message.indexOf('Co-authored-by: ');
+	if (index !== -1) {
+		message = message.substring(0, index - 1).trimEnd();
+	}
+
+	for (const coauthor of coauthors) {
+		let newlines;
+		if (message.includes('Co-authored-by: ')) {
+			newlines = '\n';
+		} else if (message.length !== 0 && message.endsWith('\n')) {
+			newlines = '\n\n';
+		} else {
+			newlines = '\n\n\n';
+		}
+
+		message += `${newlines}Co-authored-by: ${coauthor}`;
+	}
+
+	return message;
+}