@gitkraken/core-gitlens 0.6.0 → 0.7.1

package/src/git/remotes/matcher.ts

@@ -1,215 +0,0 @@
-import { Logger } from '../../utils/logger.js';
-import type { RemoteProviderContext } from '../context.js';
-import type {
-	RemoteProvider,
-	RemoteProviderId,
-	RemoteProviderMatcher,
-	RemotesUrlsConfig,
-} from '../models/remoteProvider.js';
-import { AzureDevOpsRemoteProvider, isVsts } from './azure-devops.js';
-import { BitbucketServerRemoteProvider } from './bitbucket-server.js';
-import { BitbucketRemoteProvider } from './bitbucket.js';
-import { CustomRemoteProvider } from './custom.js';
-import { GerritRemoteProvider } from './gerrit.js';
-import { GiteaRemoteProvider } from './gitea.js';
-import { GitHubRemoteProvider } from './github.js';
-import { GitLabRemoteProvider } from './gitlab.js';
-import { GoogleSourceRemoteProvider } from './google-source.js';
-
-export type { RemoteProviderMatcher } from '../models/remoteProvider.js';
-
-/**
- * Configuration for a remote provider, provided by the host.
- * The library uses these to build a {@link RemoteProviderMatcher} internally.
- *
- * Each config describes either a user-configured custom remote (from settings)
- * or a cloud self-managed host (from integration descriptors).
- */
-export interface RemoteProviderConfig {
-	readonly type: RemoteProviderId;
-	/** Domain for exact string matching (mutually exclusive with `regex`) */
-	readonly domain?: string;
-	/** Regex pattern for flexible matching (mutually exclusive with `domain`) */
-	readonly regex?: string;
-	/** URL protocol override (e.g., `'https'`) */
-	readonly protocol?: string;
-	/** Display name override */
-	readonly name?: string;
-	/** Custom URL templates — required when `type` is `'Custom'` */
-	readonly urls?: RemotesUrlsConfig;
-}
-
-interface ProviderEntry {
-	custom: boolean;
-	/** When true, the regex is also tested against the full URL (not just the domain) */
-	matchUrl?: boolean;
-	matcher: string | RegExp;
-	type: RemoteProviderId;
-	protocol?: string;
-	name?: string;
-	urls?: RemotesUrlsConfig;
-}
-
-const builtInProviders: ProviderEntry[] = [
-	{ custom: false, matcher: 'bitbucket.org', type: 'bitbucket' },
-	{ custom: false, matcher: 'github.com', type: 'github' },
-	{ custom: false, matcher: 'gitlab.com', type: 'gitlab' },
-	{ custom: false, matcher: /\bdev\.azure\.com$/i, type: 'azure-devops' },
-	{ custom: false, matchUrl: true, matcher: /^(.+\/(?:bitbucket|stash))\/scm\/(.+)$/i, type: 'bitbucket-server' },
-	{ custom: false, matcher: /\bgitlab\b/i, type: 'gitlab' },
-	{ custom: false, matcher: /\bvisualstudio\.com$/i, type: 'azure-devops' },
-	{ custom: false, matcher: /\bgitea\b/i, type: 'gitea' },
-	{ custom: false, matcher: /\bgerrithub\.io$/i, type: 'gerrit' },
-	{ custom: false, matcher: /\bgooglesource\.com$/i, type: 'google-source' },
-];
-
-const protocolRegex = /(\w+)\W*/;
-function cleanProtocol(scheme: string | undefined): string | undefined {
-	const protocol = scheme?.match(protocolRegex)?.[1];
-	// Only preserve web protocols; non-web schemes (e.g. `ssh`, `git`) must fall back to the
-	// provider's default so web URLs (commit/issue/PR pages) don't inherit an unreachable scheme
-	return protocol === 'http' || protocol === 'https' ? protocol : undefined;
-}
-
-function createProvider(
-	entry: ProviderEntry,
-	domain: string,
-	path: string,
-	scheme: string | undefined,
-	context?: RemoteProviderContext,
-): RemoteProvider | undefined {
-	const protocol = cleanProtocol(entry.protocol ?? scheme);
-
-	if (entry.type === 'custom' && entry.urls != null) {
-		return new CustomRemoteProvider(domain, path, entry.urls, protocol, entry.name);
-	}
-
-	return createBuiltInProvider(entry.type, domain, path, protocol, entry.name, entry.custom, context);
-}
-
-function createBuiltInProvider(
-	type: RemoteProviderId,
-	domain: string,
-	path: string,
-	protocol?: string,
-	name?: string,
-	custom?: boolean,
-	context?: RemoteProviderContext,
-): RemoteProvider | undefined {
-	switch (type) {
-		case 'azure-devops':
-			return new AzureDevOpsRemoteProvider(domain, path, protocol, name, isVsts(domain), context);
-		case 'bitbucket':
-			return new BitbucketRemoteProvider(domain, path, protocol, name, custom, context);
-		case 'bitbucket-server':
-			return new BitbucketServerRemoteProvider(domain, path, protocol, name, custom, context);
-		case 'custom':
-			return undefined; // Custom requires urls — handled in config entries
-		case 'gerrit':
-			return new GerritRemoteProvider(domain, path, protocol, name, custom, undefined, context);
-		case 'google-source':
-			return new GoogleSourceRemoteProvider(domain, path, protocol, name, custom, context);
-		case 'gitea':
-			return new GiteaRemoteProvider(domain, path, protocol, name, custom, context);
-		case 'github':
-			return new GitHubRemoteProvider(domain, path, protocol, name, custom, context);
-		case 'gitlab':
-			return new GitLabRemoteProvider(domain, path, protocol, name, custom, context);
-		default:
-			return undefined;
-	}
-}
-
-function configsToEntries(configs: RemoteProviderConfig[]): ProviderEntry[] {
-	const entries: ProviderEntry[] = [];
-	for (const cfg of configs) {
-		let matcher: string | RegExp | undefined;
-		try {
-			matcher = cfg.regex ? new RegExp(cfg.regex, 'i') : cfg.domain?.toLowerCase();
-			if (matcher == null) {
-				Logger.error(undefined, `Remote provider config for '${cfg.name ?? cfg.type}' has no domain or regex`);
-				continue;
-			}
-		} catch (ex) {
-			Logger.error(ex, `Loading remote provider config '${cfg.name ?? cfg.type}' failed`);
-			continue;
-		}
-
-		entries.push({
-			custom: true,
-			matchUrl: true,
-			matcher: matcher,
-			type: cfg.type,
-			protocol: cfg.protocol,
-			name: cfg.name,
-			urls: cfg.urls,
-		});
-	}
-	return entries;
-}
-
-function matchEntries(
-	entries: ProviderEntry[],
-	url: string,
-	domain: string,
-	path: string,
-	scheme: string | undefined,
-	hooks?: RemoteProviderContext,
-): RemoteProvider | undefined {
-	const key = domain?.toLowerCase();
-	for (const entry of entries) {
-		if (typeof entry.matcher === 'string') {
-			if (entry.matcher === key) {
-				return createProvider(entry, domain, path, scheme, hooks);
-			}
-			continue;
-		}
-
-		if (entry.matcher.test(key)) {
-			return createProvider(entry, domain, path, scheme, hooks);
-		}
-		if (!entry.matchUrl) continue;
-
-		const match = entry.matcher.exec(url);
-		if (match != null) {
-			const matchDomain = match[1].replace(/^[a-zA-Z][\w+.-]*:\/\//, '');
-			return createProvider(entry, matchDomain, match[2], scheme, hooks);
-		}
-	}
-
-	return undefined;
-}
-
-/**
- * Creates a {@link RemoteProviderMatcher} from optional extra configs and built-in providers.
- *
- * Extra configs (from user settings or cloud integrations) are matched first, then built-ins.
- * The optional {@link RemoteProviderContext} is attached to each created provider so it can
- * call host-side providers (e.g., cross-fork PR URLs, autolink decoration).
- *
- * @param configs - Extra provider configs beyond built-ins (user custom remotes, cloud self-managed hosts)
- * @param context - Optional host-provided context to attach to created providers
- */
-export function createRemoteProviderMatcher(
-	configs?: RemoteProviderConfig[],
-	context?: RemoteProviderContext,
-): RemoteProviderMatcher {
-	const extraEntries = configs?.length ? configsToEntries(configs) : undefined;
-
-	return (url: string, domain: string, path: string, scheme: string | undefined): RemoteProvider | undefined => {
-		try {
-			// Try extra configs first (user-configured + cloud self-managed take priority)
-			if (extraEntries != null) {
-				const provider = matchEntries(extraEntries, url, domain, path, scheme, context);
-				if (provider != null) return provider;
-			}
-
-			// Fall back to built-in providers
-			return matchEntries(builtInProviders, url, domain, path, scheme, context);
-		} catch (ex) {
-			debugger;
-			Logger.error(ex, 'createRemoteProviderMatcher');
-			return undefined;
-		}
-	};
-}

package/src/git/repositoryService.ts

@@ -1,180 +0,0 @@
-import type { Uri } from '../utils/uri.js';
-import type { GitProvider, GitProviderDescriptor } from './providers/provider.js';
-
-/**
- * A repo-scoped view of a {@link GitProvider}'s sub-providers.
- *
- * Every sub-provider method has its `repoPath` parameter auto-injected,
- * so callers don't need to pass the repository path repeatedly.
- *
- * Created lazily by {@link GitService.forRepo} and cached
- * for proxy reuse. The service trusts the caller — if the path isn't
- * a real repository, git commands will fail naturally.
- *
- * @example
- * ```typescript
- * const repo = service.forRepo('/path/to/repo');
- * const branches = await repo.branches.getBranches(); // repoPath auto-injected
- * const status = await repo.status.getStatus();
- * ```
- */
-export interface RepositoryService {
-	/** Normalized path or URI-string identifying the repository root */
-	readonly path: string;
-	/** Descriptor of the provider that manages this repository */
-	readonly provider: GitProviderDescriptor;
-
-	/** Resolves a relative path within this repository to an absolute URI */
-	getAbsoluteUri(relativePath: string): Uri;
-
-	/**
-	 * Monotonic counter tracking working tree filesystem changes.
-	 * Used by `GitCommit.hasFullDetails()` for uncommitted commit staleness.
-	 * Returns `undefined` when no watch service is configured (headless/test).
-	 */
-	readonly etagWorkingTree: number | undefined;
-
-	// Required sub-providers (repoPath auto-injected)
-	readonly branches: SubProviderForRepo<GitProvider['branches']>;
-	readonly commits: SubProviderForRepo<GitProvider['commits']>;
-	readonly config: SubProviderForRepo<GitProvider['config']>;
-	readonly contributors: SubProviderForRepo<GitProvider['contributors']>;
-	readonly diff: SubProviderForRepo<GitProvider['diff']>;
-	readonly graph: SubProviderForRepo<GitProvider['graph']>;
-	readonly refs: SubProviderForRepo<GitProvider['refs']>;
-	readonly remotes: SubProviderForRepo<GitProvider['remotes']>;
-	readonly revision: SubProviderForRepo<GitProvider['revision']>;
-	readonly status: SubProviderForRepo<GitProvider['status']>;
-	readonly tags: SubProviderForRepo<GitProvider['tags']>;
-
-	// Optional sub-providers
-	readonly blame?: SubProviderForRepo<NonNullable<GitProvider['blame']>>;
-	readonly maintenance?: SubProviderForRepo<NonNullable<GitProvider['maintenance']>>;
-	readonly ops?: SubProviderForRepo<NonNullable<GitProvider['ops']>>;
-	readonly patch?: SubProviderForRepo<NonNullable<GitProvider['patch']>>;
-	readonly pausedOps?: SubProviderForRepo<NonNullable<GitProvider['pausedOps']>>;
-	readonly staging?: SubProviderForRepo<NonNullable<GitProvider['staging']>>;
-	readonly stash?: SubProviderForRepo<NonNullable<GitProvider['stash']>>;
-	readonly worktrees?: SubProviderForRepo<NonNullable<GitProvider['worktrees']>>;
-}
-
-let _repositoryServiceResolver: ((repoPath: string) => RepositoryService | undefined) | undefined;
-
-/** Clears the global repository resolver */
-export function clearGlobalRepositoryServiceResolver(): void {
-	_repositoryServiceResolver = undefined;
-}
-
-/**
- * Returns a repo-scoped {@link RepositoryService} for the given path.
- * Returns undefined if no resolver is configured or the path is unrecognized.
- *
- * @warning This function depends on {@link setGlobalRepositoryServiceResolver} being called at startup.
- * If called before configuration, it will return undefined. Ensure proper initialization order.
- */
-export function getRepositoryService(repoPath: string): RepositoryService | undefined {
-	return _repositoryServiceResolver?.(repoPath);
-}
-
-/**
- * Sets a global repository resolver for models
- * Call this at application startup to enable model-level
- * repository access (e.g., {@link GitWorktree.hasWorkingChanges}).
- * @internal Called by {@link GitService} constructor.
- */
-export function setGlobalRepositoryServiceResolver(
-	resolver: (repoPath: string) => RepositoryService | undefined,
-): void {
-	_repositoryServiceResolver = resolver;
-}
-
-/**
- * Utility for creating repo-scoped sub-provider wrappers.
- *
- * **Contract:** Every method on a sub-provider must accept `repoPath: string` as its
- * first parameter. The proxy auto-injects `repoPath` so callers don't have to pass it
- * repeatedly. Methods that don't take `repoPath` (e.g. `clone`) belong on `GitProvider`
- * directly, not on a sub-provider interface.
- *
- * @example
- * ```typescript
- * const branches = createSubProviderProxyForRepo(provider.branches, '/repo/path');
- * // Now: branches.getBranch('main') instead of provider.branches.getBranch('/repo/path', 'main')
- * ```
- */
-
-// Note: OmitFirstArg handles function overloads (up to 4 deep).
-// This is needed because some sub-provider methods have overloaded signatures.
-// The `First` type parameter constrains what the first argument must extend —
-// pass `string` to enforce that every method takes `repoPath: string` as its first parameter.
-type OmitFirstArg<F, First = any> = F extends {
-	(first: First, ...args: infer A1): infer R1;
-	(first: First, ...args: infer A2): infer R2;
-	(first: First, ...args: infer A3): infer R3;
-	(first: First, ...args: infer A4): infer R4;
-}
-	? ((...args: A1) => R1) & ((...args: A2) => R2) & ((...args: A3) => R3) & ((...args: A4) => R4)
-	: F extends {
-				(first: First, ...args: infer A1): infer R1;
-				(first: First, ...args: infer A2): infer R2;
-				(first: First, ...args: infer A3): infer R3;
-		  }
-		? ((...args: A1) => R1) & ((...args: A2) => R2) & ((...args: A3) => R3)
-		: F extends {
-					(first: First, ...args: infer A1): infer R1;
-					(first: First, ...args: infer A2): infer R2;
-			  }
-			? ((...args: A1) => R1) & ((...args: A2) => R2)
-			: F extends {
-						(first: First, ...args: infer A1): infer R1;
-				  }
-				? (...args: A1) => R1
-				: never;
-
-/**
- * Transforms a sub-provider type by removing the first `repoPath` parameter
- * from every method signature. Used to create repo-scoped views of sub-providers.
- *
- * Passes `string` as the `First` constraint to `OmitFirstArg`, which enforces that
- * every method on the sub-provider takes `string` (i.e. `repoPath`) as its first
- * parameter. Methods that don't will produce `never`, causing a compile error at call sites.
- *
- * Uses `NonNullable` before the conditional check so that optional methods
- * (whose type includes `| undefined`) are still matched and transformed.
- * Property optionality is preserved automatically by the mapped-type `[K in keyof T]`.
- */
-export type SubProviderForRepo<T> = {
-	[K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? OmitFirstArg<NonNullable<T[K]>, string> : T[K];
-};
-
-/**
- * Creates a repo-scoped wrapper for a sub-provider.
- * Returns a plain object where every method is pre-bound with `repoPath` as the first argument.
- *
- * Every method on the sub-provider must declare `repoPath: string` as its FIRST parameter.
- * The proxy automatically injects `repoPath` as the first argument to all method calls.
- * Operations that don't take `repoPath` (like `clone`) belong on `GitProvider` directly.
- *
- * @param target The sub-provider to wrap
- * @param repoPath The repository path to auto-inject
- * @returns A wrapped sub-provider where repoPath is pre-bound to all methods
- */
-export function createSubProviderProxyForRepo<T extends object>(target: T, repoPath: string): SubProviderForRepo<T> {
-	const bound: Record<string | symbol, unknown> = Object.create(null);
-
-	let proto: object | null = target;
-	while (proto != null && proto !== Object.prototype) {
-		for (const key of Reflect.ownKeys(proto)) {
-			if (key === 'constructor' || key in bound) continue;
-
-			const desc = Object.getOwnPropertyDescriptor(proto, key);
-			if (desc?.value != null && typeof desc.value === 'function') {
-				const fn = desc.value as (...args: unknown[]) => unknown;
-				bound[key] = (...args: unknown[]) => fn.call(target, repoPath, ...args);
-			}
-		}
-		proto = Object.getPrototypeOf(proto) as object | null;
-	}
-
-	return bound as unknown as SubProviderForRepo<T>;
-}

package/src/git/run.types.ts

@@ -1,156 +0,0 @@
-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> = {
-	/**
-	 * 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 completion: GitRunCompletion;
-};
-
-/**
- * Cache store interface for git command output caching.
- * Stores full GitResult to preserve exitCode/stderr.
- */
-export interface GitResultCache {
-	getOrCreate(
-		repoPath: string,
-		key: string,
-		// `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>>;
-}
-
-/**
- * Priority levels for git commands.
- * - `interactive`: User-initiated operations (blame, hover) - highest priority
- * - `normal`: Standard operations (status, config) - default priority
- * - `background`: Expensive operations (graph rendering, full history walks) - can be throttled
- */
-export type GitCommandPriority = 'interactive' | 'normal' | 'background';
-
-export interface GitRunOptions {
-	cancellation?: AbortSignal;
-	configs?: readonly string[];
-	readonly correlationKey?: string;
-	errors?: GitErrorHandling;
-	/** Priority level for queue ordering. If not specified, will be inferred from the command type. */
-	priority?: GitCommandPriority;
-	/** Specifies that this command should always be executed locally if possible (for live share sessions) */
-	runLocally?: boolean;
-	/**
-	 * Marks a command GitLens issues as its OWN maintenance work (the Git Health auto pass, the
-	 * commit-graph write, an explicit "Run Maintenance Now"). Such commands are legitimately slow by
-	 * design, so they are excluded from the `onSlowCommand` health signal — otherwise our own
-	 * optimization work becomes the evidence that recommends more of it. Matching on the git
-	 * subcommand can't express this: the same `update-index`/`status` also serve real user work.
-	 */
-	selfMaintenance?: boolean;
-
-	/**
-	 * If provided, cache the command's result (stdout, stderr, exitCode) in this store via an auto-generated cache key
-	 * Only use for commands with stable output (e.g., `git remote -v`)
-	 */
-	caching?: {
-		cache: GitResultCache;
-		/** The common repository path for worktree-shared caching. If not provided, defaults to cwd. */
-		commonPath?: string;
-		options?: { createTTL?: number; accessTTL?: number };
-	};
-
-	// Below options comes from RunOptions<BufferEncoding | 'buffer' | string>
-	cwd?: string;
-	readonly env?: Record<string, string | undefined>;
-	readonly encoding?: BufferEncoding | 'buffer' | string;
-	readonly maxBuffer?: number;
-	readonly stdin?: string | Buffer;
-	readonly stdinEncoding?: string;
-	// Set to 0 to disable
-	readonly timeout?: number;
-}
-
-/**
- * Untyped escape hatch for raw `git <args>` invocation, returned by
- * `GlGitProvider.createUnsafeGit`.
- *
- * "Unsafe" here means **bypasses the typed safety net** the rest of GitLens relies on
- * — sub-provider cancellation/caching/decorator behaviors and signing-awareness do
- * not apply when commands are issued through this object. It does NOT imply command
- * injection risk; the caller still controls the args.
- *
- * Hand instances to libraries that need to issue arbitrary git commands
- * (`@gitkraken/compose-tools`, `@gitkraken/shared-tools` undo). Inside GitLens
- * itself, prefer the typed sub-providers on `RepositoryService` (`branches`,
- * `commits`, `diff`, `staging`, `stash`, `status`, …). Holding an `UnsafeGit`
- * just to call `run(...)` for an ad-hoc command is almost always wrong — the
- * abstraction exists so it can be handed off, not used directly.
- */
-export interface UnsafeGit {
-	run(args: readonly string[], options?: GitRunOptions): Promise<GitResult>;
-}
-
-export interface GitSpawnOptions {
-	cancellation?: AbortSignal;
-	configs?: readonly string[];
-
-	// Below options comes from SpawnOptions
-	cwd?: string;
-	readonly env?: Record<string, string | undefined>;
-	readonly encoding?: BufferEncoding | 'buffer' | string;
-	readonly stdin?: string | Buffer;
-	readonly stdinEncoding?: string;
-	// Set to 0 to disable
-	readonly timeout?: number;
-}