@gitkraken/core-gitlens 0.3.1 → 0.4.100

package/src/git/remotes/gitlab.ts

@@ -34,114 +34,112 @@ export class GitLabRemoteProvider extends RemoteProvider<GitLabRepositoryDescrip
 
 	private _autolinks: (AutolinkReference | DynamicAutolinkReference)[] | undefined;
 	override get autolinks(): (AutolinkReference | DynamicAutolinkReference)[] {
-		if (this._autolinks === undefined) {
-			this._autolinks = [
-				...super.autolinks,
-				{
-					prefix: '#',
-					url: this.issueLinkPattern,
-					alphanumeric: false,
-					ignoreCase: false,
-					title: `Open Issue #<num> on ${this.name}`,
-
-					type: 'issue',
-					description: `${this.name} Issue #<num>`,
-				},
-				{
-					prefix: '!',
-					url: `${this.baseUrl}/-/merge_requests/<num>`,
-					alphanumeric: false,
-					ignoreCase: false,
-					title: `Open Merge Request !<num> on ${this.name}`,
-
-					type: 'pullrequest',
-					description: `${this.name} Merge Request !<num>`,
-				},
-				{
-					descriptors: [
-						{
-							regex: autolinkFullIssuesRegex,
-							url: (repo, num) => `${this.protocol}://${this.domain}/${repo}/-/issues/${num}`,
-							title: (repo, num) => `Open Issue #${num} from ${repo} on ${this.name}`,
-							label: (repo, num) => `GitLab Issue ${repo}#${num}`,
-						},
-					],
-					parse: (text: string, autolinks: Map<string, Autolink>) => {
-						let ownerAndRepo: string;
-						let num: string;
-
-						let match;
-						do {
-							match = autolinkFullIssuesRegex.exec(text);
-							if (match == null) break;
-
-							[, ownerAndRepo, num] = match;
-
-							const [owner, repo] = ownerAndRepo.split('/', 2);
-							autolinks.set(num, {
-								provider: this,
-								id: num,
-								prefix: `${ownerAndRepo}#`,
-								url: `${this.protocol}://${this.domain}/${ownerAndRepo}/-/issues/${num}`,
-								alphanumeric: false,
-								ignoreCase: true,
-								title: `Open Issue #<num> from ${ownerAndRepo} on ${this.name}`,
-
-								type: 'issue',
-								description: `${this.name} Issue ${ownerAndRepo}#${num}`,
-								descriptor: {
-									key: this.remoteKey,
-									owner: owner,
-									name: repo,
-								} satisfies GitLabRepositoryDescriptor,
-							});
-						} while (true);
+		this._autolinks ??= [
+			...super.autolinks,
+			{
+				prefix: '#',
+				url: this.issueLinkPattern,
+				alphanumeric: false,
+				ignoreCase: false,
+				title: `Open Issue #<num> on ${this.name}`,
+
+				type: 'issue',
+				description: `${this.name} Issue #<num>`,
+			},
+			{
+				prefix: '!',
+				url: `${this.baseUrl}/-/merge_requests/<num>`,
+				alphanumeric: false,
+				ignoreCase: false,
+				title: `Open Merge Request !<num> on ${this.name}`,
+
+				type: 'pullrequest',
+				description: `${this.name} Merge Request !<num>`,
+			},
+			{
+				descriptors: [
+					{
+						regex: autolinkFullIssuesRegex,
+						url: (repo, num) => `${this.protocol}://${this.domain}/${repo}/-/issues/${num}`,
+						title: (repo, num) => `Open Issue #${num} from ${repo} on ${this.name}`,
+						label: (repo, num) => `GitLab Issue ${repo}#${num}`,
 					},
+				],
+				parse: (text: string, autolinks: Map<string, Autolink>) => {
+					let ownerAndRepo: string;
+					let num: string;
+
+					let match;
+					do {
+						match = autolinkFullIssuesRegex.exec(text);
+						if (match == null) break;
+
+						[, ownerAndRepo, num] = match;
+
+						const [owner, repo] = ownerAndRepo.split('/', 2);
+						autolinks.set(num, {
+							provider: this,
+							id: num,
+							prefix: `${ownerAndRepo}#`,
+							url: `${this.protocol}://${this.domain}/${ownerAndRepo}/-/issues/${num}`,
+							alphanumeric: false,
+							ignoreCase: true,
+							title: `Open Issue #<num> from ${ownerAndRepo} on ${this.name}`,
+
+							type: 'issue',
+							description: `${this.name} Issue ${ownerAndRepo}#${num}`,
+							descriptor: {
+								key: this.remoteKey,
+								owner: owner,
+								name: repo,
+							} satisfies GitLabRepositoryDescriptor,
+						});
+					} while (true);
 				},
-				{
-					descriptors: [
-						{
-							regex: autolinkFullMergeRequestsRegex,
-							url: (repo, num) => `${this.protocol}://${this.domain}/${repo}/-/merge_requests/${num}`,
-							title: (repo, num) => `Open Merge Request !${num} from ${repo} on ${this.name}`,
-							label: (repo, num) => `${this.name} Merge Request ${repo}!${num}`,
-						},
-					],
-					parse: (text: string, autolinks: Map<string, Autolink>) => {
-						let ownerAndRepo: string;
-						let num: string;
-
-						let match;
-						do {
-							match = autolinkFullMergeRequestsRegex.exec(text);
-							if (match == null) break;
-
-							[, ownerAndRepo, num] = match;
-
-							const [owner, repo] = ownerAndRepo.split('/', 2);
-							autolinks.set(num, {
-								provider: this,
-								id: num,
-								prefix: `${ownerAndRepo}!`,
-								url: `${this.protocol}://${this.domain}/${ownerAndRepo}/-/merge_requests/${num}`,
-								alphanumeric: false,
-								ignoreCase: true,
-								title: `Open Merge Request !<num> from ${ownerAndRepo} on ${this.name}`,
-
-								type: 'pullrequest',
-								description: `${this.name} Merge Request !${num} from ${ownerAndRepo}`,
-
-								descriptor: {
-									key: this.remoteKey,
-									owner: owner,
-									name: repo,
-								} satisfies GitLabRepositoryDescriptor,
-							});
-						} while (true);
+			},
+			{
+				descriptors: [
+					{
+						regex: autolinkFullMergeRequestsRegex,
+						url: (repo, num) => `${this.protocol}://${this.domain}/${repo}/-/merge_requests/${num}`,
+						title: (repo, num) => `Open Merge Request !${num} from ${repo} on ${this.name}`,
+						label: (repo, num) => `${this.name} Merge Request ${repo}!${num}`,
 					},
+				],
+				parse: (text: string, autolinks: Map<string, Autolink>) => {
+					let ownerAndRepo: string;
+					let num: string;
+
+					let match;
+					do {
+						match = autolinkFullMergeRequestsRegex.exec(text);
+						if (match == null) break;
+
+						[, ownerAndRepo, num] = match;
+
+						const [owner, repo] = ownerAndRepo.split('/', 2);
+						autolinks.set(num, {
+							provider: this,
+							id: num,
+							prefix: `${ownerAndRepo}!`,
+							url: `${this.protocol}://${this.domain}/${ownerAndRepo}/-/merge_requests/${num}`,
+							alphanumeric: false,
+							ignoreCase: true,
+							title: `Open Merge Request !<num> from ${ownerAndRepo} on ${this.name}`,
+
+							type: 'pullrequest',
+							description: `${this.name} Merge Request !${num} from ${ownerAndRepo}`,
+
+							descriptor: {
+								key: this.remoteKey,
+								owner: owner,
+								name: repo,
+							} satisfies GitLabRepositoryDescriptor,
+						});
+					} while (true);
 				},
-			];
-		}
+			},
+		];
 		return this._autolinks;
 	}
 

package/src/git/run.types.ts

@@ -1,13 +1,61 @@
 import type { CacheController } from '../utils/promiseCache.js';
+import type { GitWarningKey } from './errors.js';
 
 export type GitErrorHandling = 'throw' | 'ignore';
 
+/**
+ * Why a run was aborted. DIAGNOSTIC ONLY — log it, never branch control flow on it. A timeout kill and a
+ * caller abort both terminate the process with SIGTERM and surface as the same error, so this is derived
+ * from a duration heuristic and can be wrong near the timeout boundary.
+ */
+export type GitRunCancellation = 'aborted' | 'timeout' | 'unknown';
+
+/**
+ * Why a run produced no answer. Every value is structurally distinguishable, so these are safe to branch on.
+ *
+ * There is deliberately no `untrusted` member: an untrusted workspace is refused before the command is ever
+ * attempted, so it REJECTS with `WorkspaceUntrustedError` rather than resolving a result.
+ */
+export type GitRunFailure =
+	/** Terminated by a signal other than SIGTERM. Any `stdout` is partial. */
+	| 'signal'
+	/** No process ever ran — queue rejection, spawn failure (e.g. ENOENT). */
+	| 'unstarted';
+
+/**
+ * How a run ended — the answer to "can I trust `stdout`?", which `exitCode` alone cannot give.
+ *
+ * A non-zero exit is NOT a failure: `diff --quiet` exits 1 for "differences found", `merge-base
+ * --is-ancestor` for "no". Those are answers, and they're `exited`. What callers must not do is read the
+ * empty `stdout` of a `warned`/`cancelled`/`failed` run as a real result — which is what a bare
+ * `exitCode === 0` check does, since several failure paths report zero.
+ */
+export type GitRunCompletion =
+	/** Ran to completion. Interpreting `code` is the caller's business; `stdout` is trustworthy. */
+	| { readonly status: 'exited'; readonly code: number }
+	/**
+	 * Exited non-zero, but stderr matched a known-benign pattern, so the error was swallowed and `stdout`
+	 * is empty. Whether that empty is a real ANSWER (`noCommits` on a fresh repo) or a failure
+	 * (`notARepository`) depends on `warning` — it is never safe to read as a plain empty result.
+	 *
+	 * `warning` is `undefined` for a swallow that matched no table entry; treat that like any warning you
+	 * haven't explicitly whitelisted, i.e. not an answer. The process did exit, so `exitCode` is present
+	 * whenever git reported a numeric one.
+	 */
+	| { readonly status: 'warned'; readonly warning: GitWarningKey | undefined; readonly error: Error }
+	| { readonly status: 'cancelled'; readonly reason: GitRunCancellation; readonly error: Error }
+	| { readonly status: 'failed'; readonly reason: GitRunFailure; readonly error: Error };
+
 export type GitResult<T extends string | Buffer | unknown = string> = {
-	readonly exitCode: number;
+	/**
+	 * The process's exit code. ABSENT when no process exited — see {@link completion}. Deliberately optional:
+	 * defaulting to `0` made a failed run indistinguishable from a clean success.
+	 */
+	readonly exitCode?: number;
 	readonly stdout: T;
 	readonly stderr?: T;
 
-	readonly cancelled?: boolean;
+	readonly completion: GitRunCompletion;
 };
 
 /**
@@ -18,8 +66,10 @@ export interface GitResultCache {
 	getOrCreate(
 		repoPath: string,
 		key: string,
-		factory: (cacheable: CacheController) => Promise<GitResult<unknown>>,
-		options?: { createTTL?: number; accessTTL?: number },
+		// `signal` is the aggregate cancellation — it fires only when every current caller has aborted.
+		// Bind shared work to it (not any single caller's signal) so one caller's abort can't reject riders.
+		factory: (cacheable: CacheController, signal?: AbortSignal) => Promise<GitResult<unknown>>,
+		options?: { createTTL?: number; accessTTL?: number; cancellation?: AbortSignal },
 	): Promise<GitResult<unknown>>;
 }
 

package/src/git/utils/branch.utils.ts

@@ -3,7 +3,18 @@ import type { GitBranch, GitTrackingUpstream } from '../models/branch.js';
 import type { GitBranchReference, GitReference } from '../models/reference.js';
 import { shortenRevision } from './revision.utils.js';
 
-const detachedHEADRegex = /^(HEAD|\(.*\))$/;
+/**
+ * The names git uses where a branch name would go when HEAD isn't on a branch — `(HEAD detached
+ * at|from <rev>)`, `(no branch)`, `(no branch, rebasing <name>)`, `(no branch, bisect started on
+ * <name>)`, and `git status --porcelain=v2`'s `branch.head` token `(detached)` — plus bare `HEAD`
+ * and our own {@link formatDetachedHeadName} output (`(<rev>...)`).
+ *
+ * Deliberately NOT "anything parenthesized": parentheses are legal in ref names, so `(release)`,
+ * `v1.0(rc)` and `feat/(wip)` are all real branches a user can be on. Matching those made
+ * `GitBranch` rewrite a genuine branch's `name` to the synthesized `(sha…)` label and re-key its
+ * `id` by SHA, which corrupts its identity for every downstream consumer.
+ */
+const detachedHEADRegex = /^(?:HEAD|\(detached\)|\(HEAD detached (?:at|from) .+\)|\(no branch.*\)|\(.+\.\.\.\))$/;
 
 export function formatDetachedHeadName(sha: string): string {
 	return `(${shortenRevision(sha)}...)`;

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

@@ -27,10 +27,10 @@ export function calculateContributionScore(
 	stats: GitCommitStats | undefined,
 	timestamp: number,
 	options: ContributorScoreOptions = defaultContributorScoreOptions,
+	now: number = Date.now(),
 ): number {
 	if (stats == null) return 0;
 
-	const now = Date.now();
 	const ageInDays = (now - timestamp) / (24 * 3600 * 1000);
 
 	// Time decay factor (exponential decay)

package/src/git/utils/fileStatus.utils.ts

@@ -53,3 +53,10 @@ const conflictStatuses = new Set<string>(['U', 'AA', 'AU', 'UA', 'DD', 'DU', 'UD
 export function isConflictStatus(status: string | undefined): status is 'U' | GitFileConflictStatus {
 	return status != null && conflictStatuses.has(status);
 }
+
+/** Repo-relative pathspec entries for a file. Renames/copies need BOTH sides: git applies pathspec limiting
+ *  before rename detection, so `git diff -- <new>` drops the old path's deletion and the patch reads as a
+ *  bare add (applying it duplicates the file instead of renaming it). */
+export function getFileDiffPathspecs(file: { path: string; originalPath?: string }): string[] {
+	return file.originalPath ? [file.path, file.originalPath] : [file.path];
+}

package/src/git/utils/graph.utils.ts

@@ -0,0 +1,46 @@
+import type { GitGraphRow } from '../models/graph.js';
+
+/**
+ * Cursor-anchored concatenation of an accumulated rows window with a freshly-paged set — the SAME
+ * cursor-anchored append the graph webview's reducer performs: keep prior rows up to and including the
+ * cursor sha (trimming anything below it), then append the page; a cursor missing from the prior rows
+ * appends after all of them (the reducer's fallthrough).
+ *
+ * Owns the canonical cursor-trim rule for the provider-side accumulated window (`GitGraphSession.window`)
+ * and the host's rows mirror. Its ledger analogue (`appendRowsLedger` in the graph webview's
+ * `graphRowsSplice.ts`) MUST stay in lockstep with this so the row mirror and its fingerprint ledger
+ * can't drift.
+ */
+export function appendRowsAtCursor(
+	prior: readonly GitGraphRow[],
+	startingCursor: string,
+	page: readonly GitGraphRow[],
+): GitGraphRow[] {
+	const cursorIndex = prior.findIndex(r => r.sha === startingCursor);
+	const keep = cursorIndex >= 0 ? cursorIndex + 1 : prior.length;
+	// Single-pass copy: preallocate the exact length, copy the kept prefix, then append the page — avoids
+	// the intermediate array a `slice` + double-spread allocates.
+	const result = new Array<GitGraphRow>(keep + page.length);
+	for (let i = 0; i < keep; i++) {
+		result[i] = prior[i];
+	}
+	for (let i = 0; i < page.length; i++) {
+		result[keep + i] = page[i];
+	}
+	return result;
+}
+
+/**
+ * Write-once cross-generation avatar merge: carry a prior graph generation's resolved avatar URLs forward into
+ * a fresh generation's map WITHOUT overwriting its own entries. Resolved URLs are cheap to keep across a
+ * rebuild/page and the fresh map's entries always win, so a stale carry-forward can never clobber current data.
+ */
+export function mergeAvatarsForward(prior: ReadonlyMap<string, string>, incoming: Map<string, string>): void {
+	if (prior.size === 0) return;
+
+	for (const [email, url] of prior) {
+		if (!incoming.has(email)) {
+			incoming.set(email, url);
+		}
+	}
+}

package/src/git/utils/issue.utils.ts

@@ -30,6 +30,7 @@ export function serializeIssue(value: IssueShape): IssueShape {
 		},
 		id: value.id,
 		nodeId: value.nodeId,
+		issueType: value.issueType,
 		title: value.title,
 		url: value.url,
 		createdDate: value.createdDate,

package/src/git/utils/pullRequest.utils.ts

@@ -92,7 +92,9 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 		},
 		id: value.id,
 		nodeId: value.nodeId,
+		number: value.number,
 		title: value.title,
+		body: value.body,
 		url: value.url,
 		createdDate: value.createdDate,
 		updatedDate: value.updatedDate,
@@ -116,6 +118,9 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 						sha: value.refs.head.sha,
 						branch: value.refs.head.branch,
 						url: value.refs.head.url,
+						cloneHttps: value.refs.head.cloneHttps,
+						cloneSsh: value.refs.head.cloneSsh,
+						isFork: value.refs.head.isFork,
 					},
 					base: {
 						exists: value.refs.base.exists,
@@ -124,6 +129,9 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 						sha: value.refs.base.sha,
 						branch: value.refs.base.branch,
 						url: value.refs.base.url,
+						cloneHttps: value.refs.base.cloneHttps,
+						cloneSsh: value.refs.base.cloneSsh,
+						isFork: value.refs.base.isFork,
 					},
 					isCrossRepository: value.refs.isCrossRepository,
 				}
@@ -136,6 +144,7 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 		reviewDecision: value.reviewDecision,
 		reviewRequests: value.reviewRequests,
 		assignees: value.assignees,
+		authoredByMe: value.authoredByMe,
 		project: value.project
 			? {
 					id: value.project.id,