@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git-cli/providers/stash.js

@@ -1,392 +1,293 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+import { skip } from "../../utils/iterable.js";
+import { countStringLength } from "../../utils/array.js";
+import { getSettledValue } from "../../utils/promise.js";
+import { debug } from "../../utils/decorators/log.js";
+import { fileUri, joinUriPath, toFsPath } from "../../utils/uri.js";
+import { normalizePath, splitPath } from "../../utils/path.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { StashApplyError, StashPushError } from "../../git/errors.js";
+import { gitFeaturesByVersion } from "../../git/features.js";
+import { GitError, GitErrors, getGitCommandError } from "../exec/git.js";
+import { GitFileWorkingTreeStatus } from "../../git/models/fileStatus.js";
+import { GitFileChange } from "../../git/models/fileChange.js";
+import { GitCommit, GitCommitIdentity } from "../../git/models/commit.js";
+import { getStashFilesOnlyLogParser, getStashLogParser } from "../parsers/logParser.js";
+import { createCommitFileset } from "./commitFilesetUtils.js";
+import { gate } from "../../utils/decorators/gate.js";
+import * as l10n from "@vscode/l10n";
+//#region ../git-cli/src/providers/stash.ts
+var StashGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+	}
+	async applyStash(repoPath, stashNameOrSha, options) {
+		if (!stashNameOrSha) return { conflicted: false };
+		const args = ["stash", options?.deleteAfter ? "pop" : "apply"];
+		if (options?.index) args.push("--index");
+		args.push(stashNameOrSha);
+		return this.applyStashCore(repoPath, args, options?.deleteAfter ? "stash-pop" : "stash-apply");
+	}
+	async applyStashCore(repoPath, args, conflictCommand) {
+		try {
+			await this.git.run({ cwd: repoPath }, ...args);
+			this.context.hooks?.cache?.onReset?.(repoPath, "stashes");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["stash"]);
+			return { conflicted: false };
+		} catch (ex) {
+			if (ex instanceof Error) {
+				const msg = ex.message ?? "";
+				if (msg.includes("Auto-merging") && msg.includes("CONFLICT") || ex instanceof GitError && (ex.stdout?.includes("Auto-merging") && ex.stdout.includes("CONFLICT") || ex.stdout?.includes("needs merge"))) {
+					this.context.hooks?.operations?.onConflicted?.(conflictCommand);
+					return { conflicted: true };
+				}
+			}
+			throw getGitCommandError("stash-apply", ex, (reason) => new StashApplyError({
+				reason: reason ?? "other",
+				gitCommand: {
+					repoPath,
+					args
+				}
+			}, ex));
+		}
+	}
+	async createStash(repoPath, message) {
+		const args = ["stash", "create"];
+		if (message) args.push(message);
+		return (await this.git.run({ cwd: repoPath }, ...args)).stdout.trim() || void 0;
+	}
+	async getStash(repoPath, options, cancellation) {
+		if (repoPath == null) return void 0;
+		const cfg = this.context.config;
+		const includeFiles = options?.includeFiles ?? cfg?.commits.includeFileDetails?.(repoPath) ?? true;
+		const similarityThreshold = includeFiles ? options?.similarityThreshold ?? cfg?.commits.similarityThreshold ?? null : null;
+		const reachableFrom = options?.reachableFrom;
+		const cacheKey = `f${includeFiles ? 1 : 0}|s${similarityThreshold ?? ""}`;
+		const stash = await this.cache.getStash(repoPath, cacheKey, async (commonPath, _cacheable, signal) => {
+			signal ??= cancellation;
+			const parser = getStashLogParser(includeFiles);
+			const args = [...parser.arguments];
+			if (includeFiles) args.push(`-M${similarityThreshold == null ? "" : `${similarityThreshold}%`}`);
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation: signal
+			}, "stash", "list", ...args);
+			const currentUser = await this.provider.config.getCurrentUser(repoPath);
+			const stashes = /* @__PURE__ */ new Map();
+			for (const s of parser.parse(result.stdout)) stashes.set(s.sha, createStash(s, commonPath, currentUser));
+			return {
+				repoPath: commonPath,
+				stashes
+			};
+		}, { cancellation });
+		if (stash == null || !reachableFrom || !stash.stashes.size) return stash;
+		const stashes = new Map(stash.stashes);
+		const reachableStashes = /* @__PURE__ */ new Set();
+		for (const [sha, s] of stash.stashes) if (s.stashOnRef === reachableFrom) reachableStashes.add(sha);
+		let changed;
+		do {
+			changed = false;
+			for (const [sha, s] of stash.stashes) if (!reachableStashes.has(sha) && s.parents.some((p) => reachableStashes.has(p))) {
+				reachableStashes.add(sha);
+				changed = true;
+			}
+		} while (changed);
+		for (const [sha] of stash.stashes) if (!reachableStashes.has(sha)) stashes.delete(sha);
+		return {
+			...stash,
+			stashes
+		};
+	}
+	async getStashCommitFiles(repoPath, ref, options, cancellation) {
+		const [stashFilesResult, stashUntrackedFilesResult] = await Promise.allSettled([this.getStashCommitFilesCore(repoPath, ref, {
+			untracked: false,
+			...options
+		}, cancellation), this.getStashCommitFilesCore(repoPath, ref, {
+			untracked: "only",
+			...options
+		}, cancellation)]);
+		let files = getSettledValue(stashFilesResult);
+		const untrackedFiles = getSettledValue(stashUntrackedFilesResult);
+		if (files?.length && untrackedFiles?.length) files.push(...untrackedFiles);
+		else files = files ?? untrackedFiles;
+		return files ?? [];
+	}
+	async getStashCommitFilesCore(repoPath, ref, options, cancellation) {
+		const args = [];
+		if (options?.untracked) args.push(options?.untracked === "only" ? "--only-untracked" : "--include-untracked");
+		const similarityThreshold = options?.similarityThreshold ?? this.context.config?.commits.similarityThreshold;
+		if (similarityThreshold != null) args.push(`-M${similarityThreshold}%`);
+		const parser = getStashFilesOnlyLogParser();
+		const result = await this.git.run({
+			cwd: repoPath,
+			cancellation
+		}, "stash", "show", ...args, ...parser.arguments, ref);
+		const repoUri = fileUri(normalizePath(repoPath));
+		for (const s of parser.parse(result.stdout)) return s.files?.map((f) => new GitFileChange(repoPath, f.path, options?.untracked === "only" ? GitFileWorkingTreeStatus.Untracked : f.status, joinUriPath(repoUri, normalizePath(f.path)), f.originalPath, f.originalPath != null ? joinUriPath(repoUri, normalizePath(f.originalPath)) : void 0, void 0, f.additions || f.deletions ? {
+			additions: f.additions ?? 0,
+			deletions: f.deletions ?? 0,
+			changes: 0
+		} : void 0, void 0, void 0, f.mode)) ?? [];
+	}
+	async deleteStash(repoPath, stashName, sha) {
+		await this.deleteStashCore(repoPath, stashName, sha);
+		this.context.hooks?.repository?.onChanged?.(repoPath, ["stash"]);
+		this.context.hooks?.cache?.onReset?.(repoPath, "stashes");
+	}
+	async deleteStashCore(repoPath, stashName, sha) {
+		if (!stashName) return void 0;
+		let result;
+		if (sha) {
+			result = await this.git.run({
+				cwd: repoPath,
+				errors: "ignore"
+			}, "show", "--format=%H", "--no-patch", stashName);
+			if (result.stdout.trim() !== sha) throw new Error(l10n.t("Unable to delete stash; mismatch with stash number"));
+		}
+		result = await this.git.run({ cwd: repoPath }, "stash", "drop", stashName);
+		return result.stdout;
+	}
+	async renameStash(repoPath, stashName, sha, message, stashOnRef) {
+		await this.deleteStashCore(repoPath, stashName, sha);
+		await this.git.run({ cwd: repoPath }, "stash", "store", "-m", stashOnRef ? `On ${stashOnRef}: ${message}` : message, sha);
+		this.context.hooks?.repository?.onChanged?.(repoPath, ["stash"]);
+		this.context.hooks?.cache?.onReset?.(repoPath, "stashes");
+	}
+	async saveStash(repoPath, message, pathsOrUris, options) {
+		const paths = pathsOrUris?.map(toFsPath);
+		if (!paths?.length) {
+			await this.stashPushCore(repoPath, message, options);
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["stash"]);
+			this.context.hooks?.cache?.onReset?.(repoPath, "stashes", "status");
+			return;
+		}
+		await this.git.ensureSupports("git:stash:push:pathspecs", (requiredVersion, installedVersion) => l10n.t("Stashing individual files requires a newer version of Git (>= {0}) than is currently installed ({1}). Please retry by stashing everything or install a more recent version of Git and try again.", requiredVersion, installedVersion));
+		const pathspecs = paths.map((p) => `./${splitPath(p, repoPath)[0]}`);
+		let stdin = await this.git.supports("git:stash:push:stdin");
+		if (stdin && options?.onlyStaged && paths.length) stdin = false;
+		if (!stdin && countStringLength(pathspecs) > 3e4) await this.git.ensureSupports("git:stash:push:stdin", (requiredVersion, installedVersion) => l10n.t("Stashing so many files ({0}) at once requires a newer version of Git (>= {1}) than is currently installed ({2}). Please retry by stashing fewer files or install a more recent version of Git and try again.", pathspecs.length, requiredVersion, installedVersion));
+		await this.stashPushCore(repoPath, message, {
+			...options,
+			pathspecs,
+			stdin
+		});
+		this.context.hooks?.cache?.onReset?.(repoPath, "stashes", "status");
+		this.context.hooks?.repository?.onChanged?.(repoPath, ["stash"]);
+	}
+	async stashPushCore(repoPath, message, options) {
+		const params = ["stash", "push"];
+		if ((options?.includeUntracked || options?.pathspecs?.length) && !options?.onlyStaged) params.push("--include-untracked");
+		if (options?.keepIndex && !(options?.includeUntracked && options?.pathspecs?.length)) params.push("--keep-index");
+		if (options?.onlyStaged) {
+			if (await this.git.supports("git:stash:push:staged")) params.push("--staged");
+			else throw new Error(l10n.t("Git version {0} or higher is required for --staged", String(gitFeaturesByVersion.get("git:stash:push:staged"))));
+		}
+		if (message) params.push("-m", message);
+		let stdin;
+		if (options?.pathspecs?.length) {
+			if (options.stdin) {
+				stdin = options.pathspecs.join("\0");
+				params.push("--pathspec-from-file=-", "--pathspec-file-nul", "--");
+			} else params.push("--", ...options.pathspecs);
+		} else params.push("--");
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				stdin
+			}, ...params);
+			if (GitErrors.stashNothingToSave.test(result.stdout)) throw new StashPushError({
+				reason: "nothingToSave",
+				gitCommand: {
+					repoPath,
+					args: params
+				}
+			});
+		} catch (ex) {
+			if (ex instanceof StashPushError) throw ex;
+			throw getGitCommandError("stash-push", ex, (reason) => new StashPushError({
+				reason: reason ?? "other",
+				gitCommand: {
+					repoPath,
+					args: params
+				}
+			}, ex));
+		}
+	}
+	async saveSnapshot(repoPath, message) {
+		const id = (await this.git.run({ cwd: repoPath }, "stash", "create")).stdout.trim() || void 0;
+		if (id == null) return;
+		const args = [];
+		if (message) args.push("-m", message);
+		await this.git.run({ cwd: repoPath }, "stash", "store", ...args, id);
+		this.context.hooks?.repository?.onChanged?.(repoPath, ["stash"]);
+		this.context.hooks?.cache?.onReset?.(repoPath, "stashes");
+	}
 };
-import { StashApplyError, StashPushError } from '../../git/errors.js';
-import { GitCommit, GitCommitIdentity } from '../../git/models/commit.js';
-import { GitFileChange } from '../../git/models/fileChange.js';
-import { GitFileWorkingTreeStatus } from '../../git/models/fileStatus.js';
-import { countStringLength } from '../../utils/array.js';
-import { gate } from '../../utils/decorators/gate.js';
-import { debug } from '../../utils/decorators/log.js';
-import { skip } from '../../utils/iterable.js';
-import { normalizePath, splitPath } from '../../utils/path.js';
-import { getSettledValue } from '../../utils/promise.js';
-import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
-import { gitFeaturesByVersion } from '../exec/features.js';
-import { getGitCommandError, GitError, GitErrors, maxGitCliLength } from '../exec/git.js';
-import { getStashFilesOnlyLogParser, getStashLogParser } from '../parsers/logParser.js';
-import { createCommitFileset } from './commitFilesetUtils.js';
-export class StashGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-    }
-    async applyStash(repoPath, stashNameOrSha, options) {
-        if (!stashNameOrSha)
-            return { conflicted: false };
-        const args = ['stash', options?.deleteAfter ? 'pop' : 'apply'];
-        if (options?.index) {
-            args.push('--index');
-        }
-        args.push(stashNameOrSha);
-        return this.applyStashCore(repoPath, args, options?.deleteAfter ? 'stash-pop' : 'stash-apply');
-    }
-    async applyStashCore(repoPath, args, conflictCommand) {
-        try {
-            await this.git.run({ cwd: repoPath }, ...args);
-            this.context.hooks?.cache?.onReset?.(repoPath, 'stashes');
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
-            return { conflicted: false };
-        }
-        catch (ex) {
-            if (ex instanceof Error) {
-                const msg = ex.message ?? '';
-                if ((msg.includes('Auto-merging') && msg.includes('CONFLICT')) ||
-                    (ex instanceof GitError &&
-                        ((ex.stdout?.includes('Auto-merging') && ex.stdout.includes('CONFLICT')) ||
-                            ex.stdout?.includes('needs merge')))) {
-                    this.context.hooks?.operations?.onConflicted?.(conflictCommand);
-                    return { conflicted: true };
-                }
-            }
-            throw getGitCommandError('stash-apply', ex, reason => new StashApplyError({ reason: reason ?? 'other', gitCommand: { repoPath: repoPath, args: args } }, ex));
-        }
-    }
-    async createStash(repoPath, message) {
-        const args = ['stash', 'create'];
-        if (message) {
-            args.push(message);
-        }
-        const result = await this.git.run({ cwd: repoPath }, ...args);
-        return result.stdout.trim() || undefined;
-    }
-    async getStash(repoPath, options, cancellation) {
-        if (repoPath == null)
-            return undefined;
-        // Resolve options against config up front so the cache key reflects the actual values used
-        // to produce the cached payload — undefined inputs aren't conflated across config changes.
-        const cfg = this.context.config;
-        const includeFiles = options?.includeFiles ?? cfg?.commits.includeFileDetails ?? true;
-        const similarityThreshold = includeFiles
-            ? (options?.similarityThreshold ?? cfg?.commits.similarityThreshold ?? null)
-            : null;
-        const reachableFrom = options?.reachableFrom;
-        // Cache only the unfiltered stash list; reachability projection runs below by testing each
-        // distinct stash parent against `reachableFrom` directly, so re-projecting is cheap
-        const cacheKey = `f${includeFiles ? 1 : 0}|s${similarityThreshold ?? ''}`;
-        const stash = await this.cache.getStash(repoPath, cacheKey, async (commonPath, _cacheable, signal) => {
-            // Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
-            signal ??= cancellation;
-            const parser = getStashLogParser(includeFiles);
-            const args = [...parser.arguments];
-            if (includeFiles) {
-                args.push(`-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`);
-            }
-            const result = await this.git.run({ cwd: repoPath, cancellation: signal }, 'stash', 'list', ...args);
-            const currentUser = await this.provider.config.getCurrentUser(repoPath);
-            const stashes = new Map();
-            for (const s of parser.parse(result.stdout)) {
-                stashes.set(s.sha, createStash(s, commonPath, currentUser));
-            }
-            return { repoPath: commonPath, stashes: stashes };
-        }, { cancellation: cancellation });
-        if (stash == null || !reachableFrom || !stash.stashes.size)
-            return stash;
-        // Copy because the cached `stash.stashes` map is shared and must not be mutated.
-        const stashes = new Map(stash.stashes);
-        const reachableStashes = new Set();
-        // Metadata pass: a stash belongs on `reachableFrom` iff git's auto-prepended
-        // `On <branch>: …` (or `WIP on <branch>: …`) prefix in the stash commit subject names
-        // this branch. `stashOnRef` is parsed from %s in createStash, so this covers autostashes
-        // and custom-reflog stashes too.
-        for (const [sha, s] of stash.stashes) {
-            if (s.stashOnRef === reachableFrom) {
-                reachableStashes.add(sha);
-            }
-        }
-        // Transitive pass for the rare detached-HEAD-on-stash chain (stash B created while HEAD
-        // pointed at stash A). Such stashes have no `stashOnRef`, but if their parent is a stash
-        // already marked reachable they should follow.
-        let changed;
-        do {
-            changed = false;
-            for (const [sha, s] of stash.stashes) {
-                if (!reachableStashes.has(sha) && s.parents.some(p => reachableStashes.has(p))) {
-                    reachableStashes.add(sha);
-                    changed = true;
-                }
-            }
-        } while (changed);
-        for (const [sha] of stash.stashes) {
-            if (!reachableStashes.has(sha)) {
-                stashes.delete(sha);
-            }
-        }
-        return { ...stash, stashes: stashes };
-    }
-    async getStashCommitFiles(repoPath, ref, options, cancellation) {
-        const [stashFilesResult, stashUntrackedFilesResult] = await Promise.allSettled([
-            // Don't include untracked files here, because we won't be able to tell them apart from added (and we need the untracked status)
-            this.getStashCommitFilesCore(repoPath, ref, { untracked: false, ...options }, cancellation),
-            // Check for any untracked files -- since git doesn't return them via `git stash list` :(
-            // See https://stackoverflow.com/questions/12681529/
-            this.getStashCommitFilesCore(repoPath, ref, { untracked: 'only', ...options }, cancellation),
-        ]);
-        let files = getSettledValue(stashFilesResult);
-        const untrackedFiles = getSettledValue(stashUntrackedFilesResult);
-        if (files?.length && untrackedFiles?.length) {
-            files.push(...untrackedFiles);
-        }
-        else {
-            files = files ?? untrackedFiles;
-        }
-        return files ?? [];
-    }
-    async getStashCommitFilesCore(repoPath, ref, options, cancellation) {
-        const args = [];
-        if (options?.untracked) {
-            args.push(options?.untracked === 'only' ? '--only-untracked' : '--include-untracked');
-        }
-        const similarityThreshold = options?.similarityThreshold ?? this.context.config?.commits.similarityThreshold;
-        if (similarityThreshold != null) {
-            args.push(`-M${similarityThreshold}%`);
-        }
-        const parser = getStashFilesOnlyLogParser();
-        const result = await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'stash', 'show', ...args, ...parser.arguments, ref);
-        const repoUri = fileUri(normalizePath(repoPath));
-        for (const s of parser.parse(result.stdout)) {
-            return (s.files?.map(f => new GitFileChange(repoPath, f.path, (options?.untracked === 'only'
-                ? GitFileWorkingTreeStatus.Untracked
-                : f.status), joinUriPath(repoUri, normalizePath(f.path)), f.originalPath, f.originalPath != null ? joinUriPath(repoUri, normalizePath(f.originalPath)) : undefined, undefined, f.additions || f.deletions
-                ? {
-                    additions: f.additions ?? 0,
-                    deletions: f.deletions ?? 0,
-                    changes: 0,
-                }
-                : undefined, undefined, undefined, f.mode)) ?? []);
-        }
-        return undefined;
-    }
-    async deleteStash(repoPath, stashName, sha) {
-        await this.deleteStashCore(repoPath, stashName, sha);
-        this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
-        this.context.hooks?.cache?.onReset?.(repoPath, 'stashes');
-    }
-    async deleteStashCore(repoPath, stashName, sha) {
-        if (!stashName)
-            return undefined;
-        let result;
-        if (sha) {
-            result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, 'show', '--format=%H', '--no-patch', stashName);
-            if (result.stdout.trim() !== sha) {
-                throw new Error('Unable to delete stash; mismatch with stash number');
-            }
-        }
-        result = await this.git.run({ cwd: repoPath }, 'stash', 'drop', stashName);
-        return result.stdout;
-    }
-    async renameStash(repoPath, stashName, sha, message, stashOnRef) {
-        await this.deleteStashCore(repoPath, stashName, sha);
-        await this.git.run({ cwd: repoPath }, 'stash', 'store', '-m', stashOnRef ? `On ${stashOnRef}: ${message}` : message, sha);
-        this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
-        this.context.hooks?.cache?.onReset?.(repoPath, 'stashes');
-    }
-    async saveStash(repoPath, message, pathsOrUris, options) {
-        const paths = pathsOrUris?.map(toFsPath);
-        if (!paths?.length) {
-            await this.stashPushCore(repoPath, message, options);
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
-            this.context.hooks?.cache?.onReset?.(repoPath, 'stashes', 'status');
-            return;
-        }
-        await this.git.ensureSupports('git:stash:push:pathspecs', 'Stashing individual files', ' Please retry by stashing everything or install a more recent version of Git and try again.');
-        const pathspecs = paths.map(p => `./${splitPath(p, repoPath)[0]}`);
-        let stdin = await this.git.supports('git:stash:push:stdin');
-        if (stdin && options?.onlyStaged && paths.length) {
-            // Since Git doesn't support --staged with --pathspec-from-file try to pass them in directly
-            stdin = false;
-        }
-        // If we don't support stdin, then error out if we are over the maximum allowed git cli length
-        if (!stdin && countStringLength(pathspecs) > maxGitCliLength) {
-            await this.git.ensureSupports('git:stash:push:stdin', `Stashing so many files (${pathspecs.length}) at once`, ' Please retry by stashing fewer files or install a more recent version of Git and try again.');
-        }
-        await this.stashPushCore(repoPath, message, {
-            ...options,
-            pathspecs: pathspecs,
-            stdin: stdin,
-        });
-        this.context.hooks?.cache?.onReset?.(repoPath, 'stashes', 'status');
-        this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
-    }
-    async stashPushCore(repoPath, message, options) {
-        const params = ['stash', 'push'];
-        if ((options?.includeUntracked || options?.pathspecs?.length) && !options?.onlyStaged) {
-            params.push('--include-untracked');
-        }
-        // `git stash push --keep-index --include-untracked -- <pathspec>` hits a bug in git when the
-        // pathspec names an untracked file: the restoring checkout can't match an untracked path in the
-        // index tree, so it fails and the staged changes are lost.
-        //
-        // $ mkdir stash-test && cd stash-test && git init
-        // $ echo a > a.txt
-        // $ git add a.txt
-        // $ git commit -m init
-        // $ echo b > b.txt
-        // $ git stash push --keep-index --include-untracked -- b.txt
-        // Saved working directory and index state WIP on main: 8a280fe init
-        // error: pathspec ':(prefix:0)b.txt' did not match any file(s) known to git
-        //
-        // Only suppress --keep-index for that case — when the selection actually includes untracked
-        // files (`includeUntracked`) AND we're stashing by pathspec. Keying off `includeUntracked` (the
-        // caller's intent) rather than the `--include-untracked` flag is deliberate: we add
-        // `--include-untracked` to every pathspec push above as a safety net, but a tracked-only
-        // selection can — and must — still keep the index intact.
-        if (options?.keepIndex && !(options?.includeUntracked && options?.pathspecs?.length)) {
-            params.push('--keep-index');
-        }
-        if (options?.onlyStaged) {
-            if (await this.git.supports('git:stash:push:staged')) {
-                params.push('--staged');
-            }
-            else {
-                throw new Error(`Git version ${gitFeaturesByVersion.get('git:stash:push:staged')} or higher is required for --staged`);
-            }
-        }
-        if (message) {
-            params.push('-m', message);
-        }
-        let stdin;
-        if (options?.pathspecs?.length) {
-            if (options.stdin) {
-                stdin = options.pathspecs.join('\0');
-                params.push('--pathspec-from-file=-', '--pathspec-file-nul', '--');
-            }
-            else {
-                params.push('--', ...options.pathspecs);
-            }
-        }
-        else {
-            params.push('--');
-        }
-        try {
-            const result = await this.git.run({ cwd: repoPath, stdin: stdin }, ...params);
-            if (GitErrors.stashNothingToSave.test(result.stdout)) {
-                throw new StashPushError({
-                    reason: 'nothingToSave',
-                    gitCommand: { repoPath: repoPath, args: params },
-                });
-            }
-        }
-        catch (ex) {
-            if (ex instanceof StashPushError)
-                throw ex;
-            throw getGitCommandError('stash-push', ex, reason => new StashPushError({ reason: reason ?? 'other', gitCommand: { repoPath: repoPath, args: params } }, ex));
-        }
-    }
-    async saveSnapshot(repoPath, message) {
-        const result = await this.git.run({ cwd: repoPath }, 'stash', 'create');
-        const id = result.stdout.trim() || undefined;
-        if (id == null)
-            return;
-        const args = [];
-        if (message) {
-            args.push('-m', message);
-        }
-        await this.git.run({ cwd: repoPath }, 'stash', 'store', ...args, id);
-        this.context.hooks?.repository?.onChanged?.(repoPath, ['stash']);
-        this.context.hooks?.cache?.onReset?.(repoPath, 'stashes');
-    }
+__decorate([gate(), debug()], StashGitSubProvider.prototype, "applyStash", null);
+__decorate([debug()], StashGitSubProvider.prototype, "createStash", null);
+__decorate([debug()], StashGitSubProvider.prototype, "getStash", null);
+__decorate([debug()], StashGitSubProvider.prototype, "getStashCommitFiles", null);
+__decorate([debug()], StashGitSubProvider.prototype, "deleteStash", null);
+__decorate([gate()], StashGitSubProvider.prototype, "deleteStashCore", null);
+__decorate([debug()], StashGitSubProvider.prototype, "renameStash", null);
+__decorate([debug({ args: (repoPath, message, paths) => ({
+	repoPath,
+	message,
+	paths: paths?.length
+}) })], StashGitSubProvider.prototype, "saveStash", null);
+__decorate([debug()], StashGitSubProvider.prototype, "saveSnapshot", null);
+function convertStashesToStdin(stashOrStashes) {
+	const remappedIds = /* @__PURE__ */ new Map();
+	if (stashOrStashes == null) return {
+		stdin: void 0,
+		stashes: /* @__PURE__ */ new Map(),
+		remappedIds
+	};
+	let stdin;
+	const original = "stashes" in stashOrStashes ? stashOrStashes.stashes : stashOrStashes;
+	const stashes = new Map(original);
+	if (original.size) {
+		stdin = "";
+		for (const stash of original.values()) {
+			stdin += `${stash.sha.substring(0, 9)}\n`;
+			for (const p of skip(stash.parents, 1)) {
+				remappedIds.set(p, stash.sha);
+				if (!stashes.has(p)) {
+					stashes.set(p, stash);
+					stdin += `${p.substring(0, 9)}\n`;
+				}
+			}
+		}
+	}
+	return {
+		stdin: stdin || void 0,
+		stashes,
+		remappedIds
+	};
 }
-__decorate([
-    gate(),
-    debug()
-], StashGitSubProvider.prototype, "applyStash", null);
-__decorate([
-    debug()
-], StashGitSubProvider.prototype, "createStash", null);
-__decorate([
-    debug()
-], StashGitSubProvider.prototype, "getStash", null);
-__decorate([
-    debug()
-], StashGitSubProvider.prototype, "getStashCommitFiles", null);
-__decorate([
-    debug()
-], StashGitSubProvider.prototype, "deleteStash", null);
-__decorate([
-    gate()
-], StashGitSubProvider.prototype, "deleteStashCore", null);
-__decorate([
-    debug()
-], StashGitSubProvider.prototype, "renameStash", null);
-__decorate([
-    debug({ args: (repoPath, message, paths) => ({ repoPath: repoPath, message: message, paths: paths?.length }) })
-], StashGitSubProvider.prototype, "saveStash", null);
-__decorate([
-    debug()
-], StashGitSubProvider.prototype, "saveSnapshot", null);
-export function convertStashesToStdin(stashOrStashes) {
-    const remappedIds = new Map();
-    if (stashOrStashes == null)
-        return { stdin: undefined, stashes: new Map(), remappedIds: remappedIds };
-    let stdin;
-    const original = 'stashes' in stashOrStashes ? stashOrStashes.stashes : stashOrStashes;
-    const stashes = new Map(original);
-    if (original.size) {
-        stdin = '';
-        for (const stash of original.values()) {
-            stdin += `${stash.sha.substring(0, 9)}\n`;
-            // Include the stash's 2nd (index files) and 3rd (untracked files) parents (if they aren't already in the map)
-            for (const p of skip(stash.parents, 1)) {
-                remappedIds.set(p, stash.sha);
-                if (!stashes.has(p)) {
-                    stashes.set(p, stash);
-                    stdin += `${p.substring(0, 9)}\n`;
-                }
-            }
-        }
-    }
-    return { stdin: stdin || undefined, stashes: stashes, remappedIds: remappedIds };
-}
-const stashSummaryRegex = 
-// oxlint-disable-next-line no-control-regex
-/(?:(?:(?<wip>WIP) on|On) (?<onref>[^/](?!.*\/\.)(?!.*\.\.)(?!.*\/\/)(?!.*@\{)[^\x00-\x1F\x7F ~^:?*[\\]+[^./]):\s*)?(?<summary>.*)$/s;
+const stashSummaryRegex = /(?:(?:(?<wip>WIP) on|On) (?<onref>[^/](?!.*\/\.)(?!.*\.\.)(?!.*\/\/)(?!.*@\{)[^\x00-\x1F\x7F ~^:?*[\\]+[^./]):\s*)?(?<summary>.*)$/s;
 function createStash(s, repoPath, currentUser) {
-    // `onRef` comes from the commit subject (%s), which git always prefixes with `On <branch>: …`
-    // or `WIP on <branch>: …`. This holds even when the reflog message was customized
-    // (autostash, `git stash store -m "…"`), so it's a reliable source
-    let onRef;
-    const subjectMatch = stashSummaryRegex.exec((s.commitSubject ?? '').trim());
-    if (subjectMatch?.groups?.onref) {
-        onRef = subjectMatch.groups.onref;
-    }
-    // The user-visible display message is derived from the reflog subject (%gs) so that short
-    // custom messages like "wip", "q", or "show args" stay as the user wrote them instead of
-    // being replaced by the verbose git-auto subject
-    let message = s.summary.trim();
-    const reflogMatch = stashSummaryRegex.exec(message);
-    if (reflogMatch?.groups != null) {
-        const summary = reflogMatch.groups.summary.trim();
-        if (summary.length === 0) {
-            message = 'WIP';
-        }
-        else if (reflogMatch.groups.wip) {
-            message = `WIP: ${summary}`;
-        }
-        else {
-            message = summary;
-        }
-    }
-    const index = message.indexOf('\n');
-    return new GitCommit(repoPath, s.sha, new GitCommitIdentity(currentUser?.name ?? '', currentUser?.email, new Date(Number(s.authorDate) * 1000), undefined, true), new GitCommitIdentity(currentUser?.name ?? '', currentUser?.email, new Date(Number(s.committedDate) * 1000), undefined, true), index !== -1 ? message.substring(0, index) : message, s.parents.split(' ') ?? [], message, createCommitFileset(s, repoPath, undefined), s.stats, undefined, undefined, s.stashName, onRef);
+	let onRef;
+	const subjectMatch = stashSummaryRegex.exec((s.commitSubject ?? "").trim());
+	if (subjectMatch?.groups?.onref) onRef = subjectMatch.groups.onref;
+	let message = s.summary.trim();
+	const reflogMatch = stashSummaryRegex.exec(message);
+	if (reflogMatch?.groups != null) {
+		const summary = reflogMatch.groups.summary.trim();
+		if (summary.length === 0) message = "WIP";
+		else if (reflogMatch.groups.wip) message = `WIP: ${summary}`;
+		else message = summary;
+	}
+	const index = message.indexOf("\n");
+	return new GitCommit(repoPath, s.sha, new GitCommitIdentity(currentUser?.name ?? "", currentUser?.email, /* @__PURE__ */ new Date(Number(s.authorDate) * 1e3), void 0, true), new GitCommitIdentity(currentUser?.name ?? "", currentUser?.email, /* @__PURE__ */ new Date(Number(s.committedDate) * 1e3), void 0, true), index !== -1 ? message.substring(0, index) : message, s.parents.split(" ") ?? [], message, createCommitFileset(s, repoPath, void 0), s.stats, void 0, void 0, s.stashName, onRef);
 }
+//#endregion
+export { StashGitSubProvider, convertStashesToStdin };
+
 //# sourceMappingURL=stash.js.map