@gitkraken/core-gitlens 0.1.0

package/src/git-cli/providers/worktrees.ts

@@ -0,0 +1,229 @@
+import { exec } from 'child_process';
+import { promises as fs } from 'fs';
+import type { Cache } from '../../git/cache.js';
+import type { GitServiceContext } from '../../git/context.js';
+import { WorktreeCreateError, WorktreeDeleteError } from '../../git/errors.js';
+import type { GitWorktree, WorkspaceFolderResolver } from '../../git/models/worktree.js';
+import type { GitWorktreesSubProvider } from '../../git/providers/worktrees.js';
+import { debug } from '../../utils/decorators/log.js';
+import { isWindows } from '../../utils/env/node/platform.js';
+import { getScopedLogger } from '../../utils/logger.scoped.js';
+import { basename, normalizePath } from '../../utils/path.js';
+import { getSettledValue } from '../../utils/promise.js';
+import type { Uri } from '../../utils/uri.js';
+import { fileUri, toFsPath } from '../../utils/uri.js';
+import type { CliGitProviderInternal } from '../cliGitProvider.js';
+import type { Git, GitError } from '../exec/git.js';
+import { getGitCommandError } from '../exec/git.js';
+import { parseGitWorktrees } from '../parsers/worktreeParser.js';
+
+export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
+	constructor(
+		private readonly context: GitServiceContext,
+		private readonly git: Git,
+		private readonly cache: Cache,
+		private readonly provider: CliGitProviderInternal,
+	) {}
+
+	@debug()
+	async createWorktree(
+		repoPath: string,
+		path: string,
+		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+	): Promise<void> {
+		const scope = getScopedLogger();
+
+		const args = ['worktree', 'add'];
+		if (options?.force) {
+			args.push('--force');
+		}
+		if (options?.createBranch) {
+			args.push('-b', options.createBranch);
+		}
+		if (options?.detach) {
+			args.push('--detach');
+		}
+		args.push(path);
+		if (options?.commitish) {
+			args.push(options.commitish);
+		}
+
+		try {
+			await this.git.exec({ cwd: repoPath }, ...args);
+
+			this.context.hooks?.cache?.onReset?.(
+				repoPath,
+				...(options?.createBranch ? (['branches', 'worktrees'] as const) : (['worktrees'] as const)),
+			);
+			this.context.hooks?.repository?.onChanged?.(
+				repoPath,
+				options?.createBranch ? ['worktrees', 'heads'] : ['worktrees'],
+			);
+		} catch (ex) {
+			scope?.error(ex);
+			throw getGitCommandError(
+				'worktree-create',
+				ex as GitError,
+				reason =>
+					new WorktreeCreateError(
+						{ reason: reason, gitCommand: { repoPath: repoPath, args: args } },
+						ex as GitError,
+					),
+			);
+		}
+	}
+
+	async createWorktreeWithResult(
+		repoPath: string,
+		path: string,
+		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+	): Promise<GitWorktree | undefined> {
+		await this.createWorktree(repoPath, path, options);
+		const normalized = normalizePath(path);
+		return this.getWorktree(repoPath, w => normalizePath(w.path) === normalized);
+	}
+
+	@debug()
+	async getWorktree(
+		repoPath: string,
+		predicate: (w: GitWorktree) => boolean,
+		cancellation?: AbortSignal,
+	): Promise<GitWorktree | undefined> {
+		return (await this.getWorktrees(repoPath, cancellation)).find(predicate);
+	}
+
+	@debug()
+	async getWorktrees(repoPath: string, cancellation?: AbortSignal): Promise<GitWorktree[]> {
+		await this.git.ensureSupports(
+			'git:worktrees',
+			'Displaying worktrees',
+			' Please install a more recent version of Git and try again.',
+		);
+
+		return this.cache.getWorktrees(
+			repoPath,
+			async (commonPath, _cacheable, signal) => {
+				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
+				signal ??= cancellation;
+				const [dataResult, branchesResult] = await Promise.allSettled([
+					this.git.exec({ cwd: commonPath, cancellation: signal }, 'worktree', 'list', '--porcelain'),
+					this.provider.branches.getBranches(commonPath, undefined, signal),
+				]);
+
+				const getWorkspaceFolder: WorkspaceFolderResolver | undefined = this.context.workspace
+					? uri => {
+							const folder = this.context.workspace!.getFolder(uri.fsPath);
+							if (folder == null) return undefined;
+							return { uri: fileUri(folder.path), name: basename(folder.path) };
+						}
+					: undefined;
+
+				return parseGitWorktrees(
+					getSettledValue(dataResult)?.stdout,
+					commonPath,
+					getSettledValue(branchesResult)?.values ?? [],
+					getWorkspaceFolder,
+				);
+			},
+			cancellation,
+		);
+	}
+
+	@debug()
+	getWorktreesDefaultUri(repoPath: string): Uri | undefined {
+		return this.context.workspace?.getWorktreeDefaultUri?.(repoPath);
+	}
+
+	@debug()
+	async deleteWorktree(repoPath: string, path: string | Uri, options?: { force?: boolean }): Promise<void> {
+		const scope = getScopedLogger();
+
+		await this.git.ensureSupports(
+			'git:worktrees',
+			'Deleting worktrees',
+			' Please install a more recent version of Git and try again.',
+		);
+
+		const args = ['worktree', 'remove'];
+		if (options?.force) {
+			args.push('--force');
+		}
+
+		const pathStr = normalizePath(toFsPath(path));
+		args.push(pathStr);
+
+		let deleted = false;
+		try {
+			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			deleted = true;
+		} catch (ex) {
+			scope?.error(ex);
+			const gitError = getGitCommandError(
+				'worktree-delete',
+				ex as GitError,
+				reason =>
+					new WorktreeDeleteError(
+						{ reason: reason, gitCommand: { repoPath: repoPath, args: args } },
+						ex as GitError,
+					),
+			);
+
+			if (gitError.details.reason === 'directoryNotEmpty') {
+				scope?.warn(
+					`Failed to fully delete worktree '${pathStr}' because it is not empty. Attempting to delete it manually.`,
+				);
+				try {
+					await fs.rm(pathStr, { force: true, recursive: true });
+					deleted = true;
+					return;
+				} catch (ex) {
+					if (isWindows) {
+						const match = /EPERM: operation not permitted, unlink '(.*?)'/i.exec((ex as GitError).message);
+						if (match != null) {
+							scope?.warn(
+								`Failed to manually delete '${pathStr}' because it is in use. Attempting to forcefully delete it.`,
+							);
+
+							// Windows-specific: `del` via cmd.exe to force-remove a locked symlink.
+							// Node's fs.rm/unlink fails with EPERM when the symlink target is in use.
+							function deleteInUseSymlink(symlink: string) {
+								return new Promise((resolve, reject) => {
+									exec(`del "${symlink}"`, (ex, stdout, stderr) => {
+										if (ex) {
+											reject(ex instanceof Error ? ex : new Error(String(ex)));
+										} else if (stderr) {
+											reject(new Error(stderr));
+										} else {
+											resolve(stdout);
+										}
+									});
+								});
+							}
+
+							const [, file] = match;
+							try {
+								await deleteInUseSymlink(file);
+								await fs.rm(pathStr, { force: true, recursive: true, maxRetries: 1, retryDelay: 1 });
+								deleted = true;
+								return;
+							} catch (ex) {
+								scope?.error(ex, `Failed to forcefully delete '${pathStr}' because it is in use.`);
+							}
+						}
+					}
+				}
+			}
+
+			throw gitError;
+		} finally {
+			if (deleted) {
+				// Clean up Cache registry + per-worktree cache entries for the deleted worktree.
+				// Order matters: unregister before emitting the repo-level change so any listener
+				// that re-queries worktree-aware state sees the registry already updated.
+				this.cache.unregisterRepoPath(pathStr);
+				this.context.hooks?.cache?.onReset?.(repoPath, 'worktrees');
+				this.context.hooks?.repository?.onChanged?.(repoPath, ['worktrees']);
+			}
+		}
+	}
+}

package/src/git-cli/service.ts

@@ -0,0 +1,74 @@
+import { GitService } from '../git/service.js';
+import type { FileWatchingProvider } from '../git/watching/provider.js';
+import type { CliGitProviderOptions } from './cliGitProvider.js';
+import { CliGitProvider } from './cliGitProvider.js';
+import type { GitLocation } from './exec/locator.js';
+import { findGitPath } from './exec/locator.js';
+
+/**
+ * Options for {@link createCliGitService}.
+ */
+export interface CliGitServiceOptions {
+	/**
+	 * Path(s) to the git binary.
+	 * Auto-detected if omitted (searches PATH, platform-specific locations).
+	 * Ignored when {@link locator} is provided.
+	 */
+	gitPath?: string | string[];
+
+	/**
+	 * Custom git binary resolver. When provided, used instead of the
+	 * default `findGitPath(gitPath)` lookup.
+	 */
+	locator?: () => Promise<GitLocation>;
+
+	/** Host-provided context hooks (cache events, workspace, integrations, telemetry, fs) */
+	context: CliGitProviderOptions['context'];
+
+	/** Git execution options passed through to the underlying Git executor */
+	gitOptions?: CliGitProviderOptions['gitOptions'];
+
+	/** Use an existing Cache instance, or one will be created */
+	cache?: CliGitProviderOptions['cache'];
+
+	/**
+	 * Filesystem watching provider. When provided, the {@link GitService}
+	 * will watch repositories for changes (file creates, edits, deletes).
+	 */
+	watchingProvider?: FileWatchingProvider;
+}
+
+/**
+ * Creates a ready-to-use {@link GitService} backed by the CLI git provider.
+ *
+ * This is the primary entry point for standalone (non-VS Code) consumers
+ * of the `@gitkraken/core-gitlens/git-cli` library. It creates a singleton {@link GitService},
+ * wires up a {@link CliGitProvider}, and registers it for all repository paths.
+ *
+ * @example
+ * ```typescript
+ * const git = createCliGitService({ context: {} });
+ *
+ * const repo = git.forRepo('/path/to/repo')!;
+ * const branches = await repo.branches.getBranches();
+ * const status = await repo.status.getStatus();
+ * await repo.ops!.fetch({ remote: 'origin' });
+ *
+ * git.dispose(); // cleans up provider, cache, and module-level state
+ * ```
+ */
+export function createCliGitService(options: CliGitServiceOptions): GitService {
+	const service = GitService.createSingleton(options.watchingProvider);
+
+	const locator = options.locator ?? (() => findGitPath(options.gitPath ?? null));
+	const provider = new CliGitProvider({
+		context: options.context,
+		locator: locator,
+		gitOptions: options.gitOptions,
+		cache: options.cache,
+	});
+
+	service.register(provider, () => true);
+
+	return service;
+}

package/src/plus/ai/constants.ts

@@ -0,0 +1,121 @@
+import type { AIProviderDescriptor } from './models/model.js';
+
+export type AIProviders =
+	| 'anthropic'
+	| 'azure'
+	| 'deepseek'
+	| 'gemini'
+	| 'github'
+	| 'gitkraken'
+	| 'huggingface'
+	| 'mistral'
+	| 'ollama'
+	| 'openai'
+	| 'openaicompatible'
+	| 'openrouter'
+	| 'vscode'
+	| 'xai';
+export type AIPrimaryProviders = Extract<AIProviders, 'gitkraken' | 'vscode'>;
+export type OpenAIProviders = 'azure' | 'openai' | 'openaicompatible';
+
+export type AIProviderAndModel = `${string}:${string}`;
+export type SupportedAIModels = `${Exclude<AIProviders, AIPrimaryProviders>}:${string}` | AIPrimaryProviders;
+
+export const gitKrakenProviderDescriptor: AIProviderDescriptor<'gitkraken'> = {
+	id: 'gitkraken',
+	name: 'GitKraken AI',
+	primary: true,
+	requiresAccount: true,
+	requiresUserKey: false,
+} as const;
+export const vscodeProviderDescriptor: AIProviderDescriptor<'vscode'> = {
+	id: 'vscode',
+	name: 'Copilot',
+	primary: true,
+	requiresAccount: false,
+	requiresUserKey: false,
+} as const;
+export const openAIProviderDescriptor: AIProviderDescriptor<'openai'> = {
+	id: 'openai',
+	name: 'OpenAI',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const azureProviderDescriptor: AIProviderDescriptor<'azure'> = {
+	id: 'azure',
+	name: 'Azure (Preview)',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const openAICompatibleProviderDescriptor: AIProviderDescriptor<'openaicompatible'> = {
+	id: 'openaicompatible',
+	name: 'OpenAI-Compatible Provider',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const anthropicProviderDescriptor: AIProviderDescriptor<'anthropic'> = {
+	id: 'anthropic',
+	name: 'Anthropic',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const geminiProviderDescriptor: AIProviderDescriptor<'gemini'> = {
+	id: 'gemini',
+	name: 'Google',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const mistralProviderDescriptor: AIProviderDescriptor<'mistral'> = {
+	id: 'mistral',
+	name: 'Mistral',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const deepSeekProviderDescriptor: AIProviderDescriptor<'deepseek'> = {
+	id: 'deepseek',
+	name: 'DeepSeek',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const xAIProviderDescriptor: AIProviderDescriptor<'xai'> = {
+	id: 'xai',
+	name: 'xAI',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const githubProviderDescriptor: AIProviderDescriptor<'github'> = {
+	id: 'github',
+	name: 'GitHub Models',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const huggingFaceProviderDescriptor: AIProviderDescriptor<'huggingface'> = {
+	id: 'huggingface',
+	name: 'Hugging Face',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const openRouterProviderDescriptor: AIProviderDescriptor<'openrouter'> = {
+	id: 'openrouter',
+	name: 'OpenRouter',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: true,
+} as const;
+export const ollamaProviderDescriptor: AIProviderDescriptor<'ollama'> = {
+	id: 'ollama',
+	name: 'Ollama',
+	primary: false,
+	requiresAccount: true,
+	requiresUserKey: false,
+} as const;

package/src/plus/ai/errors.ts

@@ -0,0 +1,82 @@
+export const enum AIErrorReason {
+	DeniedByOrganization,
+	DeniedByUser,
+	NoEntitlement,
+	NoRequestData,
+	RateLimitExceeded,
+	RateLimitOrFundsExceeded,
+	RequestTooLarge,
+	ModelNotSupported,
+	ServiceCapacityExceeded,
+	Unauthorized,
+	UserQuotaExceeded,
+}
+
+export class AIError extends Error {
+	readonly original?: Error;
+	readonly reason: AIErrorReason | undefined;
+
+	constructor(reason: AIErrorReason, original?: Error) {
+		let message;
+		switch (reason) {
+			case AIErrorReason.NoEntitlement:
+				message = 'You do not have the required entitlement to use this feature';
+				break;
+			case AIErrorReason.RequestTooLarge:
+				message = 'The request is too large';
+				break;
+			case AIErrorReason.UserQuotaExceeded:
+				message = 'You have exceeded your user token limit';
+				break;
+			case AIErrorReason.RateLimitExceeded:
+				message = 'Rate limit exceeded';
+				break;
+			case AIErrorReason.RateLimitOrFundsExceeded:
+				message = 'Rate limit exceeded or your account is out of funds';
+				break;
+			case AIErrorReason.ServiceCapacityExceeded:
+				message = 'Service capacity exceeded';
+				break;
+			case AIErrorReason.NoRequestData:
+				message = original?.message ?? 'No data was provided for the request';
+				break;
+			case AIErrorReason.ModelNotSupported:
+				message = 'Model not supported for this request';
+				break;
+			case AIErrorReason.Unauthorized:
+				message = 'You are not authorized to use the specified provider or model';
+				break;
+			case AIErrorReason.DeniedByOrganization:
+				message = 'Your organization has denied access to the specified provider or model';
+				break;
+			case AIErrorReason.DeniedByUser:
+				message = 'You have denied access to the specified provider or model';
+				break;
+			default:
+				message = original?.message ?? 'An unknown error occurred';
+				break;
+		}
+
+		super(message);
+
+		this.original = original;
+		this.reason = reason;
+		Error.captureStackTrace?.(this, new.target);
+	}
+}
+
+export class AuthenticationRequiredError extends Error {
+	constructor() {
+		super('Authentication required');
+
+		Error.captureStackTrace?.(this, new.target);
+	}
+}
+
+export class AINoRequestDataError extends AIError {
+	constructor(message?: string) {
+		super(AIErrorReason.NoRequestData, message ? new Error(message) : undefined);
+
+		Error.captureStackTrace?.(this, new.target);
+	}
+}

package/src/plus/ai/models/conversation.ts

@@ -0,0 +1,35 @@
+import type { AIChatMessage } from './provider.js';
+
+export class AIConversation {
+	private _messages: AIChatMessage[] = [];
+
+	get messages(): readonly AIChatMessage[] {
+		return this._messages;
+	}
+
+	get length(): number {
+		return this._messages.length;
+	}
+
+	get isEmpty(): boolean {
+		return this._messages.length === 0;
+	}
+
+	addMessage(message: AIChatMessage): void {
+		this._messages.push(message);
+	}
+
+	addMessages(messages: AIChatMessage[]): void {
+		this._messages.push(...messages);
+	}
+
+	clear(): void {
+		this._messages = [];
+	}
+
+	clone(): AIConversation {
+		const conversation = new AIConversation();
+		conversation._messages = [...this._messages];
+		return conversation;
+	}
+}