spidersan 0.20.1 → 0.20.2

package/dist/lib/git.js

@@ -0,0 +1,670 @@
+import { execFileSync } from 'child_process';
+import { basename } from 'path';
+import { validateFilePath, validateBranchName } from './security.js';
+export class GitError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'GitError';
+    }
+}
+function gitEnv() {
+    return { ...process.env };
+}
+export function execGit(args, options) {
+    return execFileSync('git', args, {
+        encoding: 'utf-8',
+        env: gitEnv(),
+        ...options,
+    });
+}
+function getErrorText(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const gitError = error;
+    const parts = [gitError.message];
+    if (typeof gitError.stderr === 'string') {
+        parts.push(gitError.stderr);
+    }
+    else if (Buffer.isBuffer(gitError.stderr)) {
+        parts.push(gitError.stderr.toString('utf-8'));
+    }
+    if (typeof gitError.stdout === 'string') {
+        parts.push(gitError.stdout);
+    }
+    else if (Buffer.isBuffer(gitError.stdout)) {
+        parts.push(gitError.stdout.toString('utf-8'));
+    }
+    return parts.filter(Boolean).join('\n');
+}
+function isNotRepoError(error) {
+    return /not a git repository/i.test(getErrorText(error));
+}
+function isInvalidRefError(error) {
+    return /(ambiguous argument|bad revision|invalid object name|Needed a single revision|unknown revision|unknown option `verify'|not a valid object name)/i.test(getErrorText(error));
+}
+function isMissingPathAtRefError(error) {
+    return /(does not exist in|exists on disk, but not in)/i.test(getErrorText(error));
+}
+function toGitError(error, message, fallbackCode) {
+    if (error instanceof GitError) {
+        return error;
+    }
+    if (isNotRepoError(error)) {
+        return new GitError('Not in a git repository', 'NOT_A_REPO');
+    }
+    if (fallbackCode === 'INVALID_REF' || isInvalidRefError(error)) {
+        return new GitError(message, 'INVALID_REF');
+    }
+    return new GitError(message, 'EXEC_FAILED');
+}
+export function getCurrentBranch() {
+    try {
+        return execGit(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    }
+    catch (error) {
+        throw toGitError(error, 'Failed to determine current branch', 'EXEC_FAILED');
+    }
+}
+/**
+ * Repo name as used for the `repo_name` column in spider_registries.
+ *
+ * Must stay identical across push and read paths: `registry-sync --push` stamps
+ * rows with this value and `conflicts`/`cross-conflicts` filter on it, so any
+ * divergence makes a pull silently return zero rows (tb-ly0b).
+ */
+export function getRepoName() {
+    try {
+        return basename(execGit(['rev-parse', '--show-toplevel']).trim());
+    }
+    catch {
+        return basename(process.cwd());
+    }
+}
+/**
+ * Every repo_name a read should match: the clone's directory name (what registry-sync
+ * writes) plus the lowercased GitHub repo name from `origin` (what the spidersan-webhook
+ * edge function writes for pushed branches — it never sees the local directory). They
+ * differ for spidersan-oss cloned as `spidersan`, or `toak` cloned as `Toak`.
+ */
+export function registryRepoNames() {
+    const names = [getRepoName()];
+    try {
+        const url = execGit(['remote', 'get-url', 'origin']).trim();
+        const m = url.match(/[/:]([^/]+?)(?:\.git)?$/);
+        if (m && !names.includes(m[1].toLowerCase()))
+            names.push(m[1].toLowerCase());
+    }
+    catch { /* no origin: directory name only */ }
+    return names;
+}
+export function getChangedFiles(options) {
+    const baseRef = options?.base ?? 'main';
+    const strategies = [`${baseRef}...HEAD`, 'HEAD~1', 'HEAD'];
+    for (const strategy of strategies) {
+        try {
+            const output = execGit(['-c', 'core.quotepath=off', 'diff', '--name-only', strategy], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            // A successful diff is authoritative — an empty result means no changes,
+            // not "try the next strategy" (HEAD~1 would report already-merged files).
+            return output.trim().split('\n').filter(Boolean);
+        }
+        catch (error) {
+            if (isNotRepoError(error)) {
+                throw new GitError('Not in a git repository', 'NOT_A_REPO');
+            }
+        }
+    }
+    return [];
+}
+export function getFileAtRef(ref, filePath) {
+    let safeFilePath = filePath;
+    try {
+        safeFilePath = validateFilePath(filePath);
+    }
+    catch {
+        // Historical registry entries may contain invalid file names. We still use argv-safe
+        // git execution here so callers can inspect those refs without shell interpolation.
+    }
+    try {
+        execGit(['rev-parse', '--verify', `${ref}^{commit}`], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+    }
+    catch (error) {
+        throw toGitError(error, `Invalid git ref: ${ref}`, 'INVALID_REF');
+    }
+    try {
+        return execGit(['show', `${ref}:${safeFilePath}`]);
+    }
+    catch (error) {
+        if (isNotRepoError(error)) {
+            throw new GitError('Not in a git repository', 'NOT_A_REPO');
+        }
+        if (isMissingPathAtRefError(error)) {
+            return null;
+        }
+        throw toGitError(error, `Failed to read ${safeFilePath} at ref ${ref}`, 'EXEC_FAILED');
+    }
+}
+export function getRemoteHead(remote, branch) {
+    const safeBranch = validateBranchName(branch);
+    try {
+        // ls-remote patterns match ref suffixes ("main" also matches "feature/main"),
+        // so query the full refname and match the exact line.
+        const refName = `refs/heads/${safeBranch}`;
+        const output = execGit(['ls-remote', '--heads', remote, refName], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        const line = output.split('\n').find((l) => l.endsWith(`\t${refName}`));
+        if (!line) {
+            return null;
+        }
+        const [sha] = line.split(/\s+/, 1);
+        return sha || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read stdout off a thrown execFileSync error (utf-8). */
+function getThrownStdout(error) {
+    const gitError = error;
+    if (typeof gitError?.stdout === 'string') {
+        return gitError.stdout;
+    }
+    if (Buffer.isBuffer(gitError?.stdout)) {
+        return gitError.stdout.toString('utf-8');
+    }
+    return '';
+}
+/** "unknown option" / usage failure → modern --write-tree unsupported, fall back to legacy. */
+function isUnknownOptionError(error) {
+    return /(unknown option|usage: git merge-tree|is not a git command)/i.test(getErrorText(error));
+}
+/**
+ * Resolve a ref leniently to a commit SHA.
+ * Accepts a local branch / SHA, and falls back to `origin/<ref>`.
+ * Returns null if the ref cannot be resolved (caller turns this into `error`).
+ */
+function resolveRefToSha(ref) {
+    const candidates = ref.startsWith('origin/') ? [ref] : [ref, `origin/${ref}`];
+    for (const candidate of candidates) {
+        try {
+            return execGit(['rev-parse', '--verify', `${candidate}^{commit}`], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            }).trim();
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+/** Probe once whether this git supports `git merge-tree --write-tree`. */
+let writeTreeSupportedCache = null;
+function supportsWriteTree() {
+    if (writeTreeSupportedCache !== null) {
+        return writeTreeSupportedCache;
+    }
+    try {
+        // Empty-tree against itself is a trivial, side-effect-free probe.
+        const empty = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+        execGit(['merge-tree', '--write-tree', empty, empty], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        writeTreeSupportedCache = true;
+    }
+    catch (error) {
+        // Exit-1 here would still mean the option IS supported (just "conflict"/no-op);
+        // only a usage/unknown-option failure means it's unsupported.
+        writeTreeSupportedCache = !isUnknownOptionError(error);
+    }
+    return writeTreeSupportedCache;
+}
+const KIND_FROM_LABEL = {
+    content: 'content',
+    'add/add': 'add/add',
+    'modify/delete': 'delete/modify',
+    'delete/modify': 'delete/modify',
+    distinct: 'rename',
+    rename: 'rename',
+    'rename/rename': 'rename',
+    'rename/add': 'rename',
+    'rename/delete': 'rename',
+};
+function mapKind(label) {
+    const normalized = label.trim().toLowerCase();
+    return KIND_FROM_LABEL[normalized] ?? 'content';
+}
+/**
+ * Parse modern `git merge-tree --write-tree <base> <branch>` output.
+ * Format: first line = written tree OID; then a blank line; then an info block
+ * with `CONFLICT (<kind>): ... in <path>` lines (and `Auto-merging <path>`).
+ * The CONFLICT lines carry BOTH the path and the kind, so we parse those.
+ */
+function parseWriteTreeConflicts(output) {
+    const conflicts = new Map();
+    const lines = output.split('\n');
+    for (const line of lines) {
+        // CONFLICT (content): Merge conflict in <path>
+        // CONFLICT (add/add): Merge conflict in <path>
+        const merge = line.match(/^CONFLICT \(([^)]+)\): Merge conflict in (.+)$/);
+        if (merge) {
+            const [, label, path] = merge;
+            conflicts.set(path, mapKind(label));
+            continue;
+        }
+        // CONFLICT (modify/delete): <path> deleted in X and modified in Y. ...
+        // CONFLICT (rename/delete): <path> renamed ... but deleted in ...
+        // Terminate on the multi-word PHRASE that follows the path (" deleted in ",
+        // " renamed to ", …), NOT a bare keyword — a path like "my added notes.txt"
+        // contains the word "added" but not the phrase " added in ", so phrases avoid
+        // truncating the captured path.
+        const other = line.match(/^CONFLICT \(([^)]+)\): (.+?)(?: deleted in | renamed to | added in | modified in | left in tree)/);
+        if (other) {
+            const [, label, path] = other;
+            conflicts.set(path, mapKind(label));
+        }
+    }
+    return Array.from(conflicts, ([file, kind]) => ({ file, kind }));
+}
+/**
+ * Parse legacy `git merge-tree <mergeBase> <base> <branch>` output.
+ * Output is a per-file record stream. Records begin with an unindented header
+ * (`changed in both`, `added in both`, `removed in remote`, `merged`, …) followed
+ * by indented `  base/our/their <mode> <oid> <path>` lines and a diff hunk.
+ *
+ * A `changed in both`/`added in both` header signals BOTH sides touched the path,
+ * but is only an actual CONFLICT when its hunk contains `<<<<<<<` markers
+ * (e.g. same-file/different-region merges cleanly yet still shows `changed in both`).
+ * We track the header record for the path (handling spaces) and require a marker.
+ *
+ * KNOWN LIMITATION (legacy/git<2.38 only — modern --write-tree path is preferred and
+ * always taken on git>=2.38): marker-less conflict classes (modify/delete, rename/*)
+ * emit no `<<<<<<<` and are under-reported here. Tracked in STATE.json known-issues;
+ * not fixed because legacy git is effectively absent in this fleet (CI/dev on 2.50).
+ */
+function parseLegacyConflicts(output) {
+    const conflicts = new Map();
+    const lines = output.split('\n');
+    let currentHeader = null;
+    let currentPath = null;
+    let currentKind = 'content';
+    let sawMarker = false;
+    const flush = () => {
+        if (currentHeader && currentPath && sawMarker) {
+            conflicts.set(currentPath, currentKind);
+        }
+        currentHeader = null;
+        currentPath = null;
+        currentKind = 'content';
+        sawMarker = false;
+    };
+    for (const line of lines) {
+        // Unindented record header (starts a new record).
+        const header = line.match(/^(changed in both|added in both|removed in (?:both|remote|local)|added in (?:remote|local)|merged|renamed)\b/);
+        if (header) {
+            flush();
+            currentHeader = header[1];
+            if (currentHeader === 'added in both') {
+                currentKind = 'add/add';
+            }
+            else if (currentHeader.startsWith('removed in')) {
+                currentKind = 'delete/modify';
+            }
+            else if (currentHeader === 'renamed') {
+                currentKind = 'rename';
+            }
+            else {
+                currentKind = 'content';
+            }
+            continue;
+        }
+        // Indented file record line: `  our   100644 <oid> <path>` — extract the path.
+        // Path may contain spaces; take everything after the oid token.
+        const fileLine = line.match(/^\s+(?:base|our|their)\s+\d{6}\s+[0-9a-f]{7,64}\s+(.+)$/);
+        if (fileLine && currentHeader && !currentPath) {
+            currentPath = fileLine[1];
+            continue;
+        }
+        if (line.includes('<<<<<<<')) {
+            sawMarker = true;
+        }
+    }
+    flush();
+    return Array.from(conflicts, ([file, kind]) => ({ file, kind }));
+}
+/**
+ * Real conflicts merging `branch` into `base`. Prefers `--write-tree` (git ≥2.38),
+ * falls back to the legacy 3-arg form. NEVER throws for "they conflict" — only sets
+ * `error` for environmental failures (bad ref / not a repo / unsupported tooling).
+ */
+export function getMergeConflicts(base, branch) {
+    const baseResult = {
+        base,
+        branch,
+        mergeBase: null,
+        conflicts: [],
+        clean: false,
+        method: 'write-tree',
+        error: undefined,
+    };
+    // Resolve both refs leniently first; a missing ref is an env error, not a throw.
+    let baseSha;
+    let branchSha;
+    try {
+        baseSha = resolveRefToSha(base);
+    }
+    catch (error) {
+        if (isNotRepoError(error)) {
+            return { ...baseResult, error: 'Not in a git repository' };
+        }
+        baseSha = null;
+    }
+    if (baseSha === null) {
+        return { ...baseResult, error: `ref not found: ${base}` };
+    }
+    try {
+        branchSha = resolveRefToSha(branch);
+    }
+    catch (error) {
+        if (isNotRepoError(error)) {
+            return { ...baseResult, error: 'Not in a git repository' };
+        }
+        branchSha = null;
+    }
+    if (branchSha === null) {
+        return { ...baseResult, error: `ref not found: ${branch}` };
+    }
+    // Compute merge-base (best-effort; not fatal if unrelated histories).
+    let mergeBase;
+    try {
+        mergeBase = execGit(['merge-base', baseSha, branchSha], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim() || null;
+    }
+    catch {
+        mergeBase = null;
+    }
+    // ── Modern path: git merge-tree --write-tree <base> <branch> ──
+    if (supportsWriteTree()) {
+        try {
+            const output = execGit(['merge-tree', '--write-tree', baseSha, branchSha], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            // Exit 0 → clean merge (first line is the tree OID, no conflict block).
+            return {
+                ...baseResult,
+                mergeBase,
+                conflicts: [],
+                clean: true,
+                method: 'write-tree',
+                rawOutput: output,
+            };
+        }
+        catch (error) {
+            if (isNotRepoError(error)) {
+                return { ...baseResult, mergeBase, error: 'Not in a git repository' };
+            }
+            if (isUnknownOptionError(error)) {
+                // Tooling regression mid-run — fall through to legacy.
+                writeTreeSupportedCache = false;
+            }
+            else {
+                // Exit non-zero WITH parseable conflict output = a valid conflict RESULT.
+                const stdout = getThrownStdout(error);
+                if (stdout) {
+                    const conflicts = parseWriteTreeConflicts(stdout);
+                    if (conflicts.length > 0) {
+                        return {
+                            ...baseResult,
+                            mergeBase,
+                            conflicts,
+                            clean: false,
+                            method: 'write-tree',
+                            rawOutput: stdout,
+                        };
+                    }
+                    // Non-zero but no parseable conflict (e.g. unrelated histories) → env error.
+                    return {
+                        ...baseResult,
+                        mergeBase,
+                        method: 'write-tree',
+                        rawOutput: stdout,
+                        error: getErrorText(error).split('\n')[0] || 'git merge-tree failed',
+                    };
+                }
+                return {
+                    ...baseResult,
+                    mergeBase,
+                    method: 'write-tree',
+                    error: getErrorText(error).split('\n')[0] || 'git merge-tree failed',
+                };
+            }
+        }
+    }
+    // ── Legacy path: git merge-tree <mergeBase> <base> <branch> ──
+    if (mergeBase === null) {
+        // Legacy form requires a merge-base; without one we cannot analyze.
+        return {
+            ...baseResult,
+            mergeBase,
+            method: 'legacy',
+            error: `no merge-base between ${base} and ${branch}`,
+        };
+    }
+    try {
+        const output = execGit(['merge-tree', mergeBase, baseSha, branchSha], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        const conflicts = parseLegacyConflicts(output);
+        return {
+            ...baseResult,
+            mergeBase,
+            conflicts,
+            clean: conflicts.length === 0,
+            method: 'legacy',
+            rawOutput: output,
+        };
+    }
+    catch (error) {
+        if (isNotRepoError(error)) {
+            return { ...baseResult, mergeBase, method: 'legacy', error: 'Not in a git repository' };
+        }
+        // Legacy form may still produce output on a thrown error in some gits.
+        const stdout = getThrownStdout(error);
+        if (stdout) {
+            const conflicts = parseLegacyConflicts(stdout);
+            return {
+                ...baseResult,
+                mergeBase,
+                conflicts,
+                clean: conflicts.length === 0,
+                method: 'legacy',
+                rawOutput: stdout,
+            };
+        }
+        return {
+            ...baseResult,
+            mergeBase,
+            method: 'legacy',
+            error: getErrorText(error).split('\n')[0] || 'git merge-tree failed',
+        };
+    }
+}
+export function getAheadBehind(remote, branch) {
+    let upstreamRef;
+    if (remote && branch) {
+        upstreamRef = `${remote}/${validateBranchName(branch)}`;
+    }
+    else {
+        try {
+            upstreamRef = execGit(['rev-parse', '--abbrev-ref', '@{u}'], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            }).trim();
+        }
+        catch (error) {
+            if (isNotRepoError(error)) {
+                throw new GitError('Not in a git repository', 'NOT_A_REPO');
+            }
+            return { ahead: 0, behind: 0 };
+        }
+    }
+    try {
+        const output = execGit(['rev-list', '--left-right', '--count', `HEAD...${upstreamRef}`], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        const [aheadRaw, behindRaw] = output.split(/\s+/);
+        const ahead = Number.parseInt(aheadRaw ?? '', 10);
+        const behind = Number.parseInt(behindRaw ?? '', 10);
+        if (!Number.isFinite(ahead) || !Number.isFinite(behind)) {
+            throw new GitError(`Failed to parse ahead/behind counts for ${upstreamRef}`, 'EXEC_FAILED');
+        }
+        return { ahead, behind };
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            throw error;
+        }
+        if (isNotRepoError(error)) {
+            throw new GitError('Not in a git repository', 'NOT_A_REPO');
+        }
+        if (!remote && !branch) {
+            return { ahead: 0, behind: 0 };
+        }
+        throw toGitError(error, `Failed to determine ahead/behind for ${upstreamRef}`, 'EXEC_FAILED');
+    }
+}
+/**
+ * Resolve a usable git ref for a branch name, preferring the remote-tracking
+ * ref (`refs/remotes/<remote>/<name>`) over the local ref (`refs/heads/<name>`).
+ *
+ * Returns the resolved ref string, or `null` if neither a remote nor a local
+ * ref exists — i.e. the branch is gone from this checkout AND the remote
+ * (an orphan). Preferring the remote ref means a stale local branch doesn't
+ * mask a delete, and vice-versa.
+ *
+ * Invalid branch names resolve to `null` rather than throwing, so a poisoned
+ * registry entry degrades to "orphan" instead of crashing reconcile-on-read.
+ */
+export function resolveBranchRef(name, remote = 'origin') {
+    let branch;
+    try {
+        branch = validateBranchName(name);
+    }
+    catch {
+        return null;
+    }
+    for (const ref of [`refs/remotes/${remote}/${branch}`, `refs/heads/${branch}`]) {
+        try {
+            execGit(['rev-parse', '--verify', '--quiet', ref], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            return ref;
+        }
+        catch {
+            // Ref doesn't exist — try the next candidate.
+        }
+    }
+    return null;
+}
+/**
+ * Branch names that exist on `remote` right now (`git ls-remote --heads`), or
+ * `null` when the remote can't be asked (offline, no remote, timeout). A missing
+ * local/tracking ref only proves "not fetched here"; this is the call that
+ * proves "deleted". One network round-trip for the whole registry.
+ */
+export function listRemoteHeads(remote = 'origin') {
+    try {
+        const out = execGit(['ls-remote', '--heads', remote], { stdio: ['pipe', 'pipe', 'ignore'], timeout: 15_000 });
+        return new Set(out.split('\n').map(l => l.split('\trefs/heads/')[1]).filter((b) => !!b));
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve only the LOCAL ref (`refs/heads/<name>`), or `null` if none. */
+export function resolveLocalBranchRef(name) {
+    let branch;
+    try {
+        branch = validateBranchName(name);
+    }
+    catch {
+        return null;
+    }
+    const ref = `refs/heads/${branch}`;
+    try {
+        execGit(['rev-parse', '--verify', '--quiet', ref], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return ref;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * True if `ref` is an ancestor of `ancestorOf` — i.e. `ref` is fully merged
+ * into it. Backed by `git merge-base --is-ancestor` (exit 0 = ancestor,
+ * exit 1 = not). Any failure (not-an-ancestor, bad ref, not a repo) returns
+ * `false`, so the caller treats "can't prove merged" as "still live" — the
+ * safe default for conflict detection.
+ *
+ * NOTE: detects merge-commit / fast-forward merges, where the branch tip is
+ * an ancestor of trunk. Squash merges rewrite history, so the tip is NOT an
+ * ancestor — use {@link isSquashMergedInto} for those.
+ */
+export function isMergedInto(ref, ancestorOf) {
+    try {
+        execGit(['merge-base', '--is-ancestor', ref, ancestorOf], {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True if `ref`'s content landed in `ancestorOf` via a SQUASH merge (tb-tr1z).
+ *
+ * Squash merges rewrite history, so `merge-base --is-ancestor` can never see
+ * them. Instead we ask whether trunk contains a patch-id-equivalent change:
+ * commit the branch's tree onto its merge-base as one synthetic commit (the
+ * exact diff a squash merge lands), then `git cherry` it against trunk — a
+ * leading `-` means an equivalent patch is already there.
+ *
+ * The synthetic commit is a dangling object git eventually gc's; author and
+ * dates are pinned so repeat probes reuse the identical object instead of
+ * accreting new ones. Any failure returns `false` — "can't prove merged"
+ * stays "live", same as {@link isMergedInto}.
+ */
+export function isSquashMergedInto(ref, ancestorOf) {
+    const quiet = { stdio: ['pipe', 'pipe', 'ignore'] };
+    try {
+        const base = execGit(['merge-base', ancestorOf, ref], quiet).trim();
+        const tree = execGit(['rev-parse', `${ref}^{tree}`], quiet).trim();
+        const probe = execGit(['commit-tree', tree, '-p', base, '-m', 'spidersan squash probe'], {
+            ...quiet,
+            env: {
+                ...gitEnv(),
+                GIT_AUTHOR_NAME: 'spidersan',
+                GIT_AUTHOR_EMAIL: 'probe@spidersan',
+                GIT_COMMITTER_NAME: 'spidersan',
+                GIT_COMMITTER_EMAIL: 'probe@spidersan',
+                GIT_AUTHOR_DATE: '2000-01-01T00:00:00Z',
+                GIT_COMMITTER_DATE: '2000-01-01T00:00:00Z',
+            },
+        }).trim();
+        const cherry = execGit(['cherry', ancestorOf, probe], quiet).trim();
+        return cherry !== '' && cherry.split('\n').every(line => line.startsWith('-'));
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=git.js.map