@gitkraken/core-gitlens 0.1.0

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

@@ -0,0 +1,49 @@
+import type { GitFileStatus } from '../models/fileStatus.js';
+
+const statusIconsMap = {
+	'.': undefined,
+	'!': 'icon-status-ignored.svg',
+	'?': 'icon-status-untracked.svg',
+	A: 'icon-status-added.svg',
+	D: 'icon-status-deleted.svg',
+	M: 'icon-status-modified.svg',
+	R: 'icon-status-renamed.svg',
+	C: 'icon-status-copied.svg',
+	AA: 'icon-status-conflict.svg',
+	AU: 'icon-status-conflict.svg',
+	UA: 'icon-status-conflict.svg',
+	DD: 'icon-status-conflict.svg',
+	DU: 'icon-status-conflict.svg',
+	UD: 'icon-status-conflict.svg',
+	UU: 'icon-status-conflict.svg',
+	T: 'icon-status-modified.svg',
+	U: 'icon-status-modified.svg',
+};
+
+export function getGitFileStatusIcon(status: GitFileStatus): string {
+	return statusIconsMap[status] ?? 'icon-status-unknown.svg';
+}
+
+const statusTextMap = {
+	'.': 'Unchanged',
+	'!': 'Ignored',
+	'?': 'Untracked',
+	A: 'Added',
+	D: 'Deleted',
+	M: 'Modified',
+	R: 'Renamed',
+	C: 'Copied',
+	AA: 'Added (Both)',
+	AU: 'Added (Current)',
+	UA: 'Added (Incoming)',
+	DD: 'Deleted (Both)',
+	DU: 'Deleted (Current)',
+	UD: 'Deleted (Incoming)',
+	UU: 'Modified (Both)',
+	T: 'Modified',
+	U: 'Updated but Unmerged',
+};
+
+export function getGitFileStatusText(status: GitFileStatus | keyof typeof statusTextMap): string {
+	return statusTextMap[status] ?? 'Unknown';
+}

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

@@ -0,0 +1,81 @@
+import type { Issue, IssueRepositoryIdentityDescriptor, IssueShape } from '../models/issue.js';
+
+export function getRepositoryIdentityForIssue(issue: IssueShape | Issue): IssueRepositoryIdentityDescriptor {
+	if (issue.repository == null) throw new Error('Missing repository');
+
+	return {
+		remote: {
+			url: issue.repository.url,
+			domain: issue.provider.domain,
+		},
+		name: `${issue.repository.owner}/${issue.repository.repo}`,
+		provider: {
+			id: issue.provider.id,
+			domain: issue.provider.domain,
+			repoDomain: issue.repository.owner,
+			repoName: issue.repository.repo,
+			repoOwnerDomain: issue.repository.owner,
+		},
+	};
+}
+
+export function serializeIssue(value: IssueShape): IssueShape {
+	const serialized: IssueShape = {
+		type: value.type,
+		provider: {
+			id: value.provider.id,
+			name: value.provider.name,
+			domain: value.provider.domain,
+			icon: value.provider.icon,
+		},
+		id: value.id,
+		nodeId: value.nodeId,
+		title: value.title,
+		url: value.url,
+		createdDate: value.createdDate,
+		updatedDate: value.updatedDate,
+		closedDate: value.closedDate,
+		closed: value.closed,
+		state: value.state,
+		author: {
+			id: value.author.id,
+			name: value.author.name,
+			avatarUrl: value.author.avatarUrl,
+			url: value.author.url,
+		},
+		repository:
+			value.repository == null
+				? undefined
+				: {
+						owner: value.repository.owner,
+						repo: value.repository.repo,
+						url: value.repository.url,
+					},
+		project:
+			value.project == null
+				? undefined
+				: {
+						id: value.project.id,
+						name: value.project.name,
+						resourceId: value.project.resourceId,
+						resourceName: value.project.resourceName,
+					},
+		assignees: value.assignees.map(assignee => ({
+			id: assignee.id,
+			name: assignee.name,
+			avatarUrl: assignee.avatarUrl,
+			url: assignee.url,
+		})),
+		labels:
+			value.labels == null
+				? undefined
+				: value.labels.map(label => ({
+						color: label.color,
+						name: label.name,
+					})),
+		commentsCount: value.commentsCount,
+		thumbsUpCount: value.thumbsUpCount,
+		body: value.body,
+	};
+	return serialized;
+}

package/src/git/utils/issueOrPullRequest.utils.ts

@@ -0,0 +1,23 @@
+import type { IssueOrPullRequest } from '../models/issueOrPullRequest.js';
+
+export function serializeIssueOrPullRequest(value: IssueOrPullRequest): IssueOrPullRequest {
+	const serialized: IssueOrPullRequest = {
+		type: value.type,
+		provider: {
+			id: value.provider.id,
+			name: value.provider.name,
+			domain: value.provider.domain,
+			icon: value.provider.icon,
+		},
+		id: value.id,
+		nodeId: value.nodeId,
+		title: value.title,
+		url: value.url,
+		createdDate: value.createdDate,
+		updatedDate: value.updatedDate,
+		closedDate: value.closedDate,
+		closed: value.closed,
+		state: value.state,
+	};
+	return serialized;
+}

package/src/git/utils/mergeConflicts.utils.ts

@@ -0,0 +1,21 @@
+import type { ConflictDetectionErrorReason, ConflictDetectionResult } from '../models/mergeConflicts.js';
+
+export function createConflictDetectionError(reason: ConflictDetectionErrorReason): ConflictDetectionResult {
+	return { status: 'error', reason: reason, message: getConflictDetectionErrorMessage(reason) };
+}
+
+function getConflictDetectionErrorMessage(reason: ConflictDetectionErrorReason): string {
+	switch (reason) {
+		case 'unsupported':
+			return 'Unable to detect conflicts because Git 2.38 or later is required';
+		case 'noParent':
+			return 'Unable to detect conflicts because the selection includes the initial commit';
+		case 'noMergeBase':
+			return "Unable to detect conflicts because the branches don't share a common history";
+		case 'refNotFound':
+			return "Unable to detect conflicts because the branch or commit doesn't exist";
+		case 'other':
+		default:
+			return 'Unable to detect conflicts';
+	}
+}

package/src/git/utils/pausedOperationStatus.utils.ts

@@ -0,0 +1,156 @@
+import type { GitFile } from '../models/file.js';
+import type { GitPausedOperationStatus } from '../models/pausedOperationStatus.js';
+import type { GitReference } from '../models/reference.js';
+
+/**
+ * Gets the ref for the incoming side of a conflict:
+ * - rebase: REBASE_HEAD (the commit being applied)
+ * - revert: parent of REVERT_HEAD (git's "theirs" in a revert is the state before the reverted commit)
+ * - cherry-pick/merge: the operation-specific HEAD (CHERRY_PICK_HEAD, MERGE_HEAD)
+ */
+export function getConflictIncomingRef(status: GitPausedOperationStatus): string | undefined {
+	if (status.type === 'rebase') return status.steps.current.commit?.ref ?? status.HEAD.ref;
+	if (status.type === 'revert') return `${status.HEAD.ref}^`;
+	return status.HEAD.ref;
+}
+
+/**
+ * Gets the reference representing the "current" (ours/HEAD) side of the operation
+ * For rebase, falls back to `onto` when no branch/tag points at the onto commit
+ */
+export function getConflictCurrentRef(status: GitPausedOperationStatus): GitReference | undefined {
+	if (status.type === 'rebase') return status.current ?? status.onto;
+	return status.current;
+}
+
+export const pausedOperationStatusStringsByType = {
+	'cherry-pick': {
+		label: 'Cherry picking',
+		conflicts: 'Resolve conflicts to continue cherry picking',
+		directionality: 'into',
+	},
+	merge: {
+		label: 'Merging',
+		conflicts: 'Resolve conflicts to continue merging',
+		directionality: 'into',
+	},
+	rebase: {
+		label: 'Rebasing',
+		conflicts: 'Resolve conflicts to continue rebasing',
+		directionality: 'onto',
+		pending: 'Pending rebase of',
+	},
+	revert: {
+		label: 'Reverting',
+		conflicts: 'Resolve conflicts to continue reverting',
+		directionality: 'in',
+	},
+} as const;
+
+/**
+ * Resolves the correct file paths for each side of a merge conflict diff when the file may have been renamed.
+ *
+ * Conflict files from `git status` don't carry `originalPath`, so we use diff status (from
+ * `git diff --name-status -M`) to detect renames between the merge-base and each branch.
+ *
+ * Note: The diff status must NOT use a pathspec filter, because git applies pathspecs before
+ * rename detection — so `git diff -M BASE HEAD -- new.ts` returns `A new.ts` instead of `R old.ts new.ts`
+ * when the file was renamed from `old.ts`.
+ *
+ * @param currentFiles - Diff status from merge-base to my ref (e.g. merge-base..HEAD for current changes)
+ * @param incomingFiles - Diff status from merge-base to the other ref (e.g. merge-base..incoming for current changes)
+ * @param filePath - The file's current path in the working tree
+ * @returns The resolved LHS path (at merge-base) and RHS path (at myRef)
+ */
+export function resolveConflictFilePaths(
+	currentFiles: GitFile[] | undefined,
+	incomingFiles: GitFile[] | undefined,
+	filePath: string,
+): { lhsPath: string; rhsPath: string } {
+	// Check if the file was renamed between merge-base and my side
+	const currentRename = currentFiles?.find(
+		f => (f.status === 'R' || f.status === 'C') && f.path === filePath && f.originalPath,
+	);
+	if (currentRename?.originalPath) {
+		// My side renamed: merge-base has the original name, my side has the new name
+		return { lhsPath: currentRename.originalPath, rhsPath: filePath };
+	}
+
+	// Check if the other side renamed the file
+	if (incomingFiles != null) {
+		const incomingRename = incomingFiles.find(
+			f => (f.status === 'R' || f.status === 'C') && f.path === filePath && f.originalPath,
+		);
+		if (incomingRename?.originalPath) {
+			// Other side renamed: merge-base AND my side both have the original name
+			return { lhsPath: incomingRename.originalPath, rhsPath: incomingRename.originalPath };
+		}
+	}
+
+	// Fallback: git's rename detection can fail when the diff is large or the content similarity is
+	// below the threshold. Look for the add+delete pattern that indicates an undetected rename.
+
+	// Check if my side has an undetected rename (filePath added on my side, original path deleted)
+	if (currentFiles != null) {
+		const originalPath = findUndetectedRename(currentFiles, incomingFiles, filePath);
+		if (originalPath != null) {
+			return { lhsPath: originalPath, rhsPath: filePath };
+		}
+	}
+
+	// Check if other side has an undetected rename (filePath added on other side, original path deleted)
+	if (incomingFiles != null && currentFiles != null) {
+		const originalPath = findUndetectedRename(incomingFiles, currentFiles, filePath);
+		if (originalPath != null) {
+			return { lhsPath: originalPath, rhsPath: originalPath };
+		}
+	}
+
+	// No rename detected
+	return { lhsPath: filePath, rhsPath: filePath };
+}
+
+/**
+ * Looks for an undetected rename in a diff: `filePath` was added on `sideFiles` and
+ * a corresponding path was deleted on `sideFiles` while being present in `otherSideFiles`.
+ *
+ * Git's `-M` rename detection can fail when there are many files (exceeding `diff.renameLimit`)
+ * or when content similarity is below the threshold. In those cases, git reports the rename as
+ * separate `A` (add) and `D` (delete) entries. This function matches those pairs.
+ *
+ * @returns The original (deleted) path, or undefined if no match.
+ */
+function findUndetectedRename(
+	sideFiles: GitFile[],
+	otherSideFiles: GitFile[] | undefined,
+	filePath: string,
+): string | undefined {
+	// Verify filePath was added on this side (not renamed — that was already checked)
+	if (!sideFiles.some(f => f.status === 'A' && f.path === filePath)) return undefined;
+
+	// Find a deleted file on this side that the other side also references.
+	// Use path-suffix matching to disambiguate: renames that add a directory prefix (e.g. monorepo
+	// migrations moving `src/x.ts` → `packages/utils/src/x.ts`) produce a pair where one path
+	// is a suffix of the other at a directory boundary.
+	const fileName = filePath.substring(filePath.lastIndexOf('/') + 1);
+	let fallbackMatch: string | undefined;
+	for (const deleted of sideFiles) {
+		if (deleted.status !== 'D') continue;
+
+		// The other side must have an entry for the deleted path (confirming it's a real file both sides know about)
+		if (otherSideFiles != null && !otherSideFiles.some(f => f.path === deleted.path)) continue;
+
+		// Prefer suffix match (strong signal): one path ends with the other at a directory boundary
+		if (filePath.endsWith(`/${deleted.path}`) || deleted.path.endsWith(`/${filePath}`)) {
+			return deleted.path;
+		}
+
+		// Only consider same-basename files as a weaker fallback (catches renames where directory
+		// structure changed significantly, e.g. `src/git/parsers/x.ts` → `packages/cli/src/parsers/x.ts`)
+		if (fallbackMatch == null && deleted.path.substring(deleted.path.lastIndexOf('/') + 1) === fileName) {
+			fallbackMatch = deleted.path;
+		}
+	}
+
+	return fallbackMatch;
+}

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

@@ -0,0 +1,149 @@
+import type {
+	PullRequest,
+	PullRequestComparisonRefs,
+	PullRequestRefs,
+	PullRequestRepositoryIdentityDescriptor,
+	PullRequestShape,
+} from '../models/pullRequest.js';
+import { shortenRevision } from './revision.utils.js';
+
+export interface PullRequestUrlIdentity<TProvider extends string = string> {
+	provider?: TProvider;
+
+	ownerAndRepo?: string;
+	prNumber: string;
+}
+
+export function getComparisonRefsForPullRequest(repoPath: string, prRefs: PullRequestRefs): PullRequestComparisonRefs {
+	const refs: PullRequestComparisonRefs = {
+		repoPath: repoPath,
+		base: { ref: prRefs.base.sha, label: `${prRefs.base.branch} (${shortenRevision(prRefs.base.sha)})` },
+		head: { ref: prRefs.head.sha, label: prRefs.head.branch },
+	};
+	return refs;
+}
+
+export function getPullRequestIdentityFromMaybeUrl(search: string): PullRequestUrlIdentity | undefined {
+	let prNumber: string | undefined = undefined;
+
+	let match = search.match(/(?:\/)(\d+)/); // any number starting with "/"
+	if (match != null) {
+		prNumber = match[1];
+	}
+
+	if (prNumber == null) {
+		match = search.match(/^#?(\d+)$/); // just a number or with a leading "#"
+		if (match != null) {
+			prNumber = match[1];
+		}
+	}
+
+	return prNumber == null ? undefined : { ownerAndRepo: undefined, prNumber: prNumber, provider: undefined };
+}
+
+export function getRepositoryIdentityForPullRequest(
+	pr: PullRequest,
+	headRepo: boolean = true,
+): PullRequestRepositoryIdentityDescriptor {
+	if (headRepo) {
+		return {
+			remote: {
+				url: pr.refs?.head?.url,
+				domain: pr.provider.domain,
+			},
+			name: `${pr.refs?.head?.owner ?? pr.repository.owner}/${pr.refs?.head?.repo ?? pr.repository.repo}`,
+			provider: {
+				id: pr.provider.id,
+				domain: pr.provider.domain,
+				repoDomain: pr.refs?.head?.owner ?? pr.repository.owner,
+				repoName: pr.refs?.head?.repo ?? pr.repository.repo,
+			},
+		};
+	}
+
+	return {
+		remote: {
+			url: pr.refs?.base?.url ?? pr.url,
+			domain: pr.provider.domain,
+		},
+		name: `${pr.refs?.base?.owner ?? pr.repository.owner}/${pr.refs?.base?.repo ?? pr.repository.repo}`,
+		provider: {
+			id: pr.provider.id,
+			domain: pr.provider.domain,
+			repoDomain: pr.refs?.base?.owner ?? pr.repository.owner,
+			repoName: pr.refs?.base?.repo ?? pr.repository.repo,
+			repoOwnerDomain: pr.refs?.base?.owner ?? pr.repository.owner,
+		},
+	};
+}
+
+export function isMaybeNonSpecificPullRequestSearchUrl(search: string): boolean {
+	return getPullRequestIdentityFromMaybeUrl(search) != null;
+}
+
+export function serializePullRequest(value: PullRequest): PullRequestShape {
+	const serialized: PullRequestShape = {
+		type: value.type,
+		provider: {
+			id: value.provider.id,
+			name: value.provider.name,
+			domain: value.provider.domain,
+			icon: value.provider.icon,
+		},
+		id: value.id,
+		nodeId: value.nodeId,
+		title: value.title,
+		url: value.url,
+		createdDate: value.createdDate,
+		updatedDate: value.updatedDate,
+		closedDate: value.closedDate,
+		closed: value.closed,
+		author: {
+			id: value.author.id,
+			name: value.author.name,
+			avatarUrl: value.author.avatarUrl,
+			url: value.author.url,
+		},
+		state: value.state,
+		mergedDate: value.mergedDate,
+		mergeableState: value.mergeableState,
+		refs: value.refs
+			? {
+					head: {
+						exists: value.refs.head.exists,
+						owner: value.refs.head.owner,
+						repo: value.refs.head.repo,
+						sha: value.refs.head.sha,
+						branch: value.refs.head.branch,
+						url: value.refs.head.url,
+					},
+					base: {
+						exists: value.refs.base.exists,
+						owner: value.refs.base.owner,
+						repo: value.refs.base.repo,
+						sha: value.refs.base.sha,
+						branch: value.refs.base.branch,
+						url: value.refs.base.url,
+					},
+					isCrossRepository: value.refs.isCrossRepository,
+				}
+			: undefined,
+		isDraft: value.isDraft,
+		additions: value.additions,
+		deletions: value.deletions,
+		commentsCount: value.commentsCount,
+		thumbsUpCount: value.thumbsUpCount,
+		reviewDecision: value.reviewDecision,
+		reviewRequests: value.reviewRequests,
+		assignees: value.assignees,
+		project: value.project
+			? {
+					id: value.project.id,
+					name: value.project.name,
+					resourceId: value.project.resourceId,
+					resourceName: value.project.resourceName,
+				}
+			: undefined,
+	};
+	return serialized;
+}

package/src/git/utils/rebase.utils.ts

@@ -0,0 +1,128 @@
+import type { Mutable } from '../../utils/types.js';
+import type {
+	ProcessedRebaseCommitEntry,
+	ProcessedRebaseEntry,
+	ProcessedRebaseTodo,
+	RebaseTodoCommandAction,
+	RebaseTodoCommitAction,
+	RebaseTodoEntry,
+	RebaseTodoMergesAction,
+} from '../models/rebase.js';
+
+/** Commit actions that have SHAs and are editable */
+export const commitRebaseActions = new Set<RebaseTodoCommitAction>([
+	'pick',
+	'reword',
+	'edit',
+	'squash',
+	'fixup',
+	'drop',
+]);
+
+/** Command actions that are movable but not editable */
+export const commandRebaseActions = new Set<RebaseTodoCommandAction>(['exec', 'break', 'noop']);
+
+/** Actions that indicate --rebase-merges mode */
+export const mergesRebaseActions = new Set<RebaseTodoMergesAction>(['label', 'reset', 'merge']);
+
+export function formatRebaseTodoEntryLine(entry: ProcessedRebaseEntry, overrideAction?: string): string {
+	const action = overrideAction ?? entry.action;
+	if (entry.type === 'commit') {
+		const flagPart = entry.flag ? ` ${entry.flag}` : '';
+		return `${action}${flagPart} ${entry.sha} # ${entry.message}`;
+	}
+
+	// Command entries (exec, break, noop)
+	if (entry.action === 'exec') {
+		return `exec${entry.command ? ` ${entry.command}` : ''}`;
+	}
+	return entry.action; // break, noop
+}
+
+/** Formats an update-ref line for output */
+export function formatUpdateRefLine(ref: string): string {
+	return `update-ref ${ref}`;
+}
+
+/** Checks if an entry is a commit-based action */
+type RebaseTodoCommitEntry = RebaseTodoEntry<RebaseTodoCommitAction> & { sha: string; message: string };
+function isCommitEntry(entry: RebaseTodoEntry): entry is RebaseTodoCommitEntry {
+	return (
+		entry.sha != null && entry.message != null && commitRebaseActions.has(entry.action as RebaseTodoCommitAction)
+	);
+}
+
+/** Checks if an entry is a command action (exec/break/noop) */
+type RebaseTodoCommandEntry = RebaseTodoEntry<RebaseTodoCommandAction> & { command: string };
+function isCommandEntry(entry: RebaseTodoEntry): entry is RebaseTodoCommandEntry {
+	return commandRebaseActions.has(entry.action as RebaseTodoCommandAction);
+}
+
+/**
+ * Checks if this is a --rebase-merges rebase that actually has merge commits
+ * Only actual 'merge' commands indicate a true DAG that cannot be safely reordered.
+ * If just label/reset are present (no merge), the history is linear and editable.
+ */
+function hasActualMergeCommands(entries: RebaseTodoEntry[]): boolean {
+	return entries.some(e => e.action === 'merge');
+}
+
+/** Checks if an entry is a structural label/reset command (filtered from UI) */
+function isStructuralEntry(entry: RebaseTodoEntry): boolean {
+	return entry.action === 'label' || entry.action === 'reset';
+}
+
+/** Checks if an entry is an update-ref action */
+type RebaseTodoUpdateRefEntry = RebaseTodoEntry<'update-ref'> & { ref: string };
+function isUpdateRefEntry(entry: RebaseTodoEntry): entry is RebaseTodoUpdateRefEntry {
+	return entry.action === 'update-ref' && entry.ref != null;
+}
+
+/**
+ * Processes parsed rebase entries into a flat list with type discriminators.
+ * - Adds `type: 'commit' | 'command'` to each entry
+ * - Attaches update-ref entries to their preceding commits
+ * - Filters out structural label/reset entries (they're preserved in the raw file)
+ * - Detects rebases with actual merge commits (reordering disabled but actions allowed)
+ */
+export function processRebaseEntries(entries: RebaseTodoEntry[], done?: boolean): ProcessedRebaseTodo {
+	// Only flag as preservesMerges if there are actual merge commands
+	// label/reset alone (no merge) means linear history that can be edited
+	const preservesMerges = hasActualMergeCommands(entries);
+
+	const result: ProcessedRebaseEntry[] = [];
+	const commits = new Map<string, ProcessedRebaseCommitEntry>();
+
+	// Track the last commit to attach update-refs to
+	let lastCommit: ProcessedRebaseCommitEntry | undefined;
+
+	for (const entry of entries) {
+		// Skip structural label/reset entries - they're preserved in the raw file
+		// but not shown in the UI (the UI only shows commits and command actions)
+		if (isStructuralEntry(entry)) continue;
+
+		if (isCommitEntry(entry)) {
+			const commitEntry: ProcessedRebaseCommitEntry = { ...entry, type: 'commit', id: entry.sha, done: done };
+			result.push(commitEntry);
+			commits.set(commitEntry.sha, commitEntry);
+			lastCommit = commitEntry;
+			continue;
+		}
+
+		if (isUpdateRefEntry(entry)) {
+			// Attach update-ref to the preceding commit (with line number for reordering)
+			if (lastCommit) {
+				(lastCommit as Mutable<ProcessedRebaseCommitEntry>).updateRefs ??= [];
+				lastCommit.updateRefs!.push({ ref: entry.ref, line: entry.line });
+			}
+			continue;
+		}
+
+		if (isCommandEntry(entry)) {
+			result.push({ ...entry, type: 'command', id: `${done ? 'done:' : ''}line:${entry.line}`, done: done });
+			continue;
+		}
+	}
+
+	return { entries: result, commits: commits, preservesMerges: preservesMerges };
+}