@straiffi/archon 1.0.0

package/dist/server/lib/git.js

@@ -0,0 +1,1284 @@
+import { execFile, execFileSync } from 'child_process';
+import { cpSync, existsSync, lstatSync, mkdirSync, statSync, symlinkSync } from 'fs';
+import { cp as cpAsync, lstat as lstatAsync, mkdir as mkdirAsync, symlink as symlinkAsync } from 'fs/promises';
+import { dirname, isAbsolute, join, relative, resolve } from 'path';
+import db from '../db.js';
+import { getProjectWorktreeSync } from './projects.js';
+const PROJECT_BRANCH_REMOTE_REFRESH_TTL_MS = 30_000;
+const lastProjectBranchRemoteRefreshAt = new Map();
+const resolveCurrentBranchName = (cwd) => {
+    try {
+        const branch = runGitText(['branch', '--show-current'], cwd).trim();
+        return branch && branch !== 'HEAD' ? branch : null;
+    }
+    catch {
+        return null;
+    }
+};
+const getProjectBranchRefreshCacheKey = (cwd, branch) => `${cwd}:${branch ?? ''}`;
+const toText = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return value ? value.toString('utf8') : '';
+};
+const createTextSignature = (value) => {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = ((hash << 5) + hash) ^ value.charCodeAt(index);
+    }
+    return `${value.length}:${hash >>> 0}`;
+};
+const getRepoPath = (project) => {
+    if (!project?.repo_path) {
+        throw new Error('Project repo path is required');
+    }
+    return resolve(project.repo_path);
+};
+const resolveRepoKey = (project) => getRepoPath(project);
+const runGitText = (args, cwd) => {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+};
+const runGitDiffText = (args, cwd) => {
+    try {
+        return runGitText(args, cwd);
+    }
+    catch (error) {
+        const failed = error;
+        if (failed.status === 1) {
+            const stdout = failed.stdout;
+            if (typeof stdout === 'string') {
+                return stdout;
+            }
+            return stdout?.toString('utf8') ?? '';
+        }
+        throw error;
+    }
+};
+const runGitTextAsync = (args, cwd) => new Promise((resolvePromise, reject) => {
+    execFile('git', args, {
+        cwd,
+        encoding: 'utf8',
+    }, (error, stdout, stderr) => {
+        if (error) {
+            const failed = error;
+            const nextError = new Error(toText(failed.stderr).trim()
+                || stderr.trim()
+                || failed.message);
+            nextError.stdout = failed.stdout ?? stdout;
+            nextError.stderr = failed.stderr ?? stderr;
+            nextError.status = failed.status ?? (typeof failed.code === 'number' ? failed.code : undefined);
+            reject(nextError);
+            return;
+        }
+        resolvePromise({
+            stdout,
+            stderr,
+        });
+    });
+});
+const runGitDiffTextAsync = async (args, cwd) => {
+    try {
+        return (await runGitTextAsync(args, cwd)).stdout;
+    }
+    catch (error) {
+        const failed = error;
+        const exitCode = failed.status ?? (typeof failed.code === 'number' ? failed.code : null);
+        if (exitCode === 1) {
+            const stdout = failed.stdout;
+            if (typeof stdout === 'string') {
+                return stdout;
+            }
+            return stdout?.toString('utf8') ?? '';
+        }
+        throw error;
+    }
+};
+const getWorktreeBase = (project) => join(getRepoPath(project), '..', 'worktrees');
+const parseWorktreeRecords = (output) => {
+    const records = [];
+    const lines = output.split('\n');
+    let currentPath = null;
+    let currentBranch = null;
+    const pushCurrent = () => {
+        if (!currentPath) {
+            return;
+        }
+        records.push({ path: currentPath, branch: currentBranch });
+        currentPath = null;
+        currentBranch = null;
+    };
+    for (const line of lines) {
+        if (line === '') {
+            pushCurrent();
+            continue;
+        }
+        if (line.startsWith('worktree ')) {
+            pushCurrent();
+            currentPath = line.slice('worktree '.length);
+            continue;
+        }
+        if (line.startsWith('branch ')) {
+            currentBranch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+        }
+    }
+    pushCurrent();
+    return records;
+};
+const listWorktreeRecords = (project, worktreeRecordsCache) => {
+    const repoPath = getRepoPath(project);
+    if (worktreeRecordsCache?.has(repoPath)) {
+        return worktreeRecordsCache.get(repoPath) ?? [];
+    }
+    const output = runGitText(['worktree', 'list', '--porcelain'], repoPath);
+    const records = parseWorktreeRecords(output);
+    worktreeRecordsCache?.set(repoPath, records);
+    return records;
+};
+const parseNumstatOutput = (output) => {
+    const lines = output
+        .split('\n')
+        .map(line => line.trimEnd())
+        .filter(Boolean);
+    return lines.flatMap(line => {
+        const firstTabIndex = line.indexOf('\t');
+        const secondTabIndex = firstTabIndex === -1 ? -1 : line.indexOf('\t', firstTabIndex + 1);
+        if (firstTabIndex === -1 || secondTabIndex === -1) {
+            return [];
+        }
+        const additionsToken = line.slice(0, firstTabIndex);
+        const deletionsToken = line.slice(firstTabIndex + 1, secondTabIndex);
+        const path = line.slice(secondTabIndex + 1);
+        const additions = additionsToken === '-' ? 0 : Number.parseInt(additionsToken, 10);
+        const deletions = deletionsToken === '-' ? 0 : Number.parseInt(deletionsToken, 10);
+        if (!path) {
+            return [];
+        }
+        return [{
+                path,
+                additions: Number.isFinite(additions) ? additions : 0,
+                deletions: Number.isFinite(deletions) ? deletions : 0,
+            }];
+    });
+};
+const normalizeNoIndexPath = (path) => {
+    const renamedPrefix = '/dev/null => ';
+    if (path.startsWith(renamedPrefix)) {
+        return path.slice(renamedPrefix.length);
+    }
+    return path;
+};
+const parseBranchHeader = (line, current) => {
+    if (line.startsWith('# branch.head ')) {
+        const branch = line.slice('# branch.head '.length);
+        return {
+            ...current,
+            branch: branch === '(detached)' ? null : branch,
+        };
+    }
+    if (!line.startsWith('# branch.ab ')) {
+        return current;
+    }
+    const aheadMatch = line.match(/\+(\d+)/);
+    const behindMatch = line.match(/-(\d+)/);
+    return {
+        ...current,
+        ahead: aheadMatch ? Number.parseInt(aheadMatch[1] ?? '0', 10) : 0,
+        behind: behindMatch ? Number.parseInt(behindMatch[1] ?? '0', 10) : 0,
+    };
+};
+const getRecordedWorktreeBase = (branch, project) => {
+    const row = db.prepare('SELECT repo_path, branch, base_branch, base_commit FROM worktree_bases WHERE repo_path = ? AND branch = ?').get(resolveRepoKey(project), branch);
+    if (!row) {
+        return null;
+    }
+    return {
+        baseBranch: row.base_branch,
+        baseCommit: row.base_commit,
+    };
+};
+const saveWorktreeBase = (branch, project, base) => {
+    db.prepare(`
+    INSERT INTO worktree_bases (repo_path, branch, base_branch, base_commit, created_at, updated_at)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    ON CONFLICT(repo_path, branch) DO UPDATE SET
+      base_branch = excluded.base_branch,
+      base_commit = excluded.base_commit,
+      updated_at = CURRENT_TIMESTAMP
+  `).run(resolveRepoKey(project), branch, base.baseBranch, base.baseCommit);
+};
+const deleteWorktreeBase = (branch, project) => {
+    db.prepare('DELETE FROM worktree_bases WHERE repo_path = ? AND branch = ?').run(resolveRepoKey(project), branch);
+};
+const resolveHeadCommit = (cwd) => {
+    const output = runGitText(['rev-parse', 'HEAD'], cwd).trim();
+    return output || null;
+};
+const countCommitRange = (range, cwd) => {
+    const output = runGitText(['rev-list', '--count', range], cwd).trim();
+    const count = Number.parseInt(output || '0', 10);
+    return Number.isFinite(count) ? count : 0;
+};
+const resolveRecordedBaseAhead = (cwd, baseBranch, baseCommit) => {
+    const range = resolveRecordedBaseRange(cwd, baseBranch, baseCommit);
+    if (!range) {
+        return null;
+    }
+    try {
+        return countCommitRange(range, cwd);
+    }
+    catch {
+        return null;
+    }
+};
+const resolveFallbackBase = (branch, project) => {
+    const repoPath = getRepoPath(project);
+    const rootBranch = resolveCurrentBranchName(repoPath);
+    if (!rootBranch || rootBranch === branch) {
+        return null;
+    }
+    return {
+        baseBranch: rootBranch,
+        baseCommit: resolveBranchMergeBase(rootBranch, branch, repoPath),
+    };
+};
+const resolveBranchMergeBase = (baseBranch, branch, cwd) => {
+    if (!baseBranch || baseBranch === branch) {
+        return null;
+    }
+    try {
+        const mergeBase = runGitText(['merge-base', baseBranch, branch], cwd).trim();
+        return mergeBase || null;
+    }
+    catch {
+        return null;
+    }
+};
+const resolveBranchUpstreamRef = (branch, cwd) => {
+    try {
+        const upstreamRef = runGitText(['rev-parse', '--symbolic-full-name', `${branch}@{upstream}`], cwd).trim();
+        return upstreamRef || null;
+    }
+    catch {
+        return null;
+    }
+};
+const getBranchTrackingState = (branch, cwd) => {
+    if (!resolveBranchUpstreamRef(branch, cwd)) {
+        try {
+            const aheadOutput = runGitText(['rev-list', '--count', 'HEAD', '--not', '--remotes'], cwd).trim();
+            const ahead = Number.parseInt(aheadOutput || '0', 10);
+            return {
+                hasUpstream: false,
+                ahead: Number.isFinite(ahead) ? ahead : 0,
+                behind: 0,
+            };
+        }
+        catch {
+            return {
+                hasUpstream: false,
+                ahead: 0,
+                behind: 0,
+            };
+        }
+    }
+    return {
+        hasUpstream: true,
+        ahead: 0,
+        behind: 0,
+    };
+};
+const getBranchSyncState = (entries, cwd, recordedBase = null) => {
+    const branchState = entries
+        .filter(entry => entry.startsWith('# '))
+        .reduce((current, entry) => parseBranchHeader(entry, current), {
+        branch: null,
+        ahead: 0,
+        behind: 0,
+    });
+    const trackingState = branchState.branch ? getBranchTrackingState(branchState.branch, cwd) : null;
+    const recordedAhead = trackingState?.hasUpstream === false
+        ? resolveRecordedBaseAhead(cwd, recordedBase?.baseBranch ?? null, recordedBase?.baseCommit ?? null)
+        : null;
+    const ahead = branchState.ahead > 0 || branchState.behind > 0
+        ? branchState.ahead
+        : (recordedAhead ?? trackingState?.ahead ?? 0);
+    const behind = branchState.ahead > 0 || branchState.behind > 0
+        ? branchState.behind
+        : (trackingState?.behind ?? 0);
+    return {
+        branch: branchState.branch,
+        ahead,
+        behind,
+        hasUpstream: trackingState?.hasUpstream ?? false,
+        canPush: Boolean(branchState.branch) && ((trackingState?.hasUpstream ?? true) || ahead > 0),
+    };
+};
+const getEmptyProjectBranchResponse = (status = 'unknown') => ({
+    branch: null,
+    status,
+    ahead: 0,
+    behind: 0,
+    has_upstream: false,
+    can_pull: false,
+    diff_stats: null,
+});
+const refreshProjectBranchTracking = (repoPath, branch) => {
+    if (!branch) {
+        return;
+    }
+    try {
+        runGitText(['fetch', '--quiet', 'origin', branch], repoPath);
+    }
+    catch {
+        // Keep the last known tracking state when fetch is unavailable.
+    }
+};
+const shouldRefreshProjectBranchTracking = (cacheKey, force) => {
+    if (force) {
+        lastProjectBranchRemoteRefreshAt.set(cacheKey, Date.now());
+        return true;
+    }
+    const lastRefreshedAt = lastProjectBranchRemoteRefreshAt.get(cacheKey) ?? 0;
+    if (Date.now() - lastRefreshedAt < PROJECT_BRANCH_REMOTE_REFRESH_TTL_MS) {
+        return false;
+    }
+    lastProjectBranchRemoteRefreshAt.set(cacheKey, Date.now());
+    return true;
+};
+const parseUnpushedCommitsOutput = (output) => {
+    const entries = output.split('\0').filter(Boolean);
+    const commits = [];
+    for (let index = 0; index + 3 < entries.length; index += 4) {
+        commits.push({
+            hash: entries[index] ?? '',
+            short_hash: entries[index + 1] ?? '',
+            subject: entries[index + 2] ?? '',
+            committed_at: entries[index + 3] ?? '',
+        });
+    }
+    return commits.filter(commit => commit.hash && commit.short_hash && commit.subject);
+};
+const resolveDefaultBranchRef = (cwd) => {
+    const candidates = ['refs/remotes/origin/HEAD', 'refs/remotes/origin/main', 'refs/remotes/origin/master', 'refs/heads/main', 'refs/heads/master'];
+    for (const candidate of candidates) {
+        try {
+            const resolved = runGitText(['rev-parse', '--symbolic-full-name', candidate], cwd).trim();
+            if (resolved) {
+                return resolved;
+            }
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+};
+const resolveNamedBranchRef = (branch, cwd) => {
+    if (!branch) {
+        return null;
+    }
+    const candidates = [`refs/heads/${branch}`, `refs/remotes/origin/${branch}`];
+    for (const candidate of candidates) {
+        try {
+            const resolved = runGitText(['rev-parse', '--symbolic-full-name', '--verify', candidate], cwd).trim();
+            if (resolved) {
+                return resolved;
+            }
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+};
+const resolveCommitBaseFromBaseRef = (baseRef, cwd) => {
+    if (!baseRef) {
+        return null;
+    }
+    try {
+        const forkPoint = runGitText(['merge-base', '--fork-point', baseRef, 'HEAD'], cwd).trim();
+        if (forkPoint) {
+            return forkPoint;
+        }
+    }
+    catch {
+        // Fall back to a plain merge-base below.
+    }
+    try {
+        const mergeBase = runGitText(['merge-base', baseRef, 'HEAD'], cwd).trim();
+        if (mergeBase) {
+            return mergeBase;
+        }
+    }
+    catch {
+        // Fall back to the broader local-only query below.
+    }
+    return null;
+};
+const resolveCommitRangeFromBaseRef = (baseRef, cwd) => {
+    const baseCommit = resolveCommitBaseFromBaseRef(baseRef, cwd);
+    return baseCommit ? `${baseCommit}..HEAD` : null;
+};
+const resolveBranchUniqueRange = (cwd) => {
+    return resolveCommitRangeFromBaseRef(resolveDefaultBranchRef(cwd), cwd);
+};
+const resolveRecordedBaseRange = (cwd, baseBranch = null, baseCommit = null) => {
+    const baseBranchRange = resolveCommitRangeFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
+    if (baseBranchRange) {
+        return baseBranchRange;
+    }
+    if (baseCommit) {
+        return `${baseCommit}..HEAD`;
+    }
+    return null;
+};
+const resolveUnpushedCommitRange = (cwd, branch, baseBranch = null, baseCommit = null) => {
+    const upstreamRef = resolveBranchUpstreamRef(branch, cwd);
+    if (upstreamRef) {
+        return `${upstreamRef}..HEAD`;
+    }
+    const recordedBaseRange = resolveRecordedBaseRange(cwd, baseBranch, baseCommit);
+    if (recordedBaseRange) {
+        return recordedBaseRange;
+    }
+    return resolveBranchUniqueRange(cwd);
+};
+export const resolveBundleReviewBase = ({ cwd, branch, project, pullRequestBaseBranch = null, }) => {
+    const normalizedPullRequestBaseBranch = pullRequestBaseBranch?.trim() || null;
+    if (normalizedPullRequestBaseBranch) {
+        const baseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(normalizedPullRequestBaseBranch, cwd), cwd);
+        if (baseCommit) {
+            return {
+                baseBranch: normalizedPullRequestBaseBranch,
+                baseCommit,
+                source: 'pull_request',
+            };
+        }
+    }
+    const recordedBase = project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
+    if (!recordedBase) {
+        return null;
+    }
+    const baseBranch = recordedBase.baseBranch?.trim() || null;
+    if (baseBranch) {
+        const baseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(baseBranch, cwd), cwd);
+        if (baseCommit) {
+            return {
+                baseBranch,
+                baseCommit,
+                source: 'worktree_base',
+            };
+        }
+    }
+    const baseCommit = recordedBase.baseCommit?.trim() || null;
+    if (!baseCommit) {
+        return null;
+    }
+    return {
+        baseBranch,
+        baseCommit,
+        source: 'worktree_base',
+    };
+};
+const getDiffDataForBaseRef = (cwd, baseRef) => {
+    try {
+        const trackedNumstat = parseNumstatOutput(runGitText(['diff', '--numstat', '--find-renames', '--no-ext-diff', baseRef], cwd));
+        const untrackedPaths = listUntrackedFiles(cwd);
+        const untrackedNumstat = untrackedPaths
+            .map(path => getUntrackedNumstatEntry(path, cwd))
+            .filter((entry) => entry !== null);
+        return {
+            files: [...trackedNumstat, ...untrackedNumstat].map(entry => ({
+                path: entry.path,
+                additions: entry.additions,
+                deletions: entry.deletions,
+            })),
+            diff: [
+                runGitText(['diff', '-U3', '--find-renames', '--no-ext-diff', baseRef], cwd),
+                ...untrackedPaths.map(path => getUntrackedUnifiedDiff(path, cwd)),
+            ].join(''),
+        };
+    }
+    catch {
+        return {
+            files: [],
+            diff: '',
+        };
+    }
+};
+const listUnpushedCommitRecords = (cwd, branch, baseBranch = null, baseCommit = null) => {
+    try {
+        const branchUniqueRange = resolveUnpushedCommitRange(cwd, branch, baseBranch, baseCommit);
+        const output = runGitText([
+            'log',
+            '--format=%H%x00%h%x00%s%x00%cI%x00',
+            '--no-show-signature',
+            '-n',
+            '20',
+            ...(branchUniqueRange ? [branchUniqueRange] : ['HEAD', '--not', '--remotes']),
+        ], cwd);
+        return parseUnpushedCommitsOutput(output);
+    }
+    catch {
+        return [];
+    }
+};
+const isConflictCode = (code) => code.includes('U') || code === 'AA' || code === 'DD';
+const toFileStatus = (code) => {
+    if (code.includes('R')) {
+        return 'renamed';
+    }
+    if (code.includes('A') || code === '??') {
+        return 'added';
+    }
+    if (code.includes('D')) {
+        return 'deleted';
+    }
+    if (code.includes('T')) {
+        return 'typechanged';
+    }
+    if (code === '??') {
+        return 'untracked';
+    }
+    return 'modified';
+};
+const parsePorcelainEntry = (entry, originalPath = null) => {
+    if (!entry) {
+        return null;
+    }
+    if (entry.startsWith('? ')) {
+        const path = entry.slice(2);
+        return path
+            ? {
+                path,
+                originalPath: null,
+                status: 'untracked',
+                staged: false,
+                unstaged: true,
+                conflicted: false,
+            }
+            : null;
+    }
+    if (entry.startsWith('! ')) {
+        return null;
+    }
+    const kind = entry[0];
+    if (kind !== '1' && kind !== '2' && kind !== 'u') {
+        return null;
+    }
+    const parts = entry.split(' ');
+    if (parts.length < 9) {
+        return null;
+    }
+    const xy = parts[1] ?? '..';
+    const path = kind === '2' ? (parts[9] ?? '') : (parts[8] ?? '');
+    if (!path) {
+        return null;
+    }
+    const stagedCode = xy[0] ?? '.';
+    const unstagedCode = xy[1] ?? '.';
+    const conflicted = kind === 'u' || isConflictCode(xy);
+    return {
+        path,
+        originalPath,
+        status: conflicted ? 'modified' : toFileStatus(kind === '2' ? `R${xy}` : xy),
+        staged: conflicted ? false : stagedCode !== '.',
+        unstaged: conflicted ? false : unstagedCode !== '.',
+        conflicted,
+    };
+};
+const getCommitBlockedReason = (files) => {
+    if (files.some(file => file.conflicted)) {
+        return 'Resolve conflicted files in the terminal before committing from the UI.';
+    }
+    if (files.some(file => file.staged && file.unstaged)) {
+        return 'Files with both staged and unstaged changes must be committed from the terminal.';
+    }
+    return null;
+};
+const getStatusSelectionBlockedReason = (files, selectedPaths) => {
+    for (const file of files) {
+        if (!selectedPaths.has(file.path) && file.staged) {
+            return `"${file.path}" already has staged changes. Use the terminal to finish that commit first.`;
+        }
+    }
+    return null;
+};
+const getWorkspaceEntryFingerprint = (cwd, entry) => {
+    try {
+        const entryPath = resolve(cwd, entry.path);
+        const stat = statSync(entryPath);
+        const kind = stat.isDirectory() ? 'dir' : 'file';
+        return `${entry.path}:${kind}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+    }
+    catch {
+        return `${entry.path}:missing`;
+    }
+};
+const getWorkspaceSignature = (output, cwd, entries) => {
+    const fileFingerprints = [...entries]
+        .sort((left, right) => left.path.localeCompare(right.path) || (left.originalPath ?? '').localeCompare(right.originalPath ?? ''))
+        .map(entry => {
+        return [
+            entry.path,
+            entry.originalPath ?? '',
+            entry.status,
+            entry.staged ? '1' : '0',
+            entry.unstaged ? '1' : '0',
+            entry.conflicted ? '1' : '0',
+            getWorkspaceEntryFingerprint(cwd, entry),
+        ].join('\u0001');
+    })
+        .join('\0');
+    return createTextSignature(`${output}\0${fileFingerprints}`);
+};
+const parseGitStatusOutput = (output) => {
+    const entries = output.split('\0').filter(Boolean);
+    const parsedEntries = [];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry.startsWith('# ')) {
+            continue;
+        }
+        const kind = entry[0];
+        const nextOriginalPath = kind === '2' ? (entries[index + 1] ?? null) : null;
+        const parsed = parsePorcelainEntry(entry, nextOriginalPath);
+        if (parsed) {
+            parsedEntries.push(parsed);
+        }
+        if (kind === '2') {
+            index += 1;
+        }
+    }
+    return {
+        entries,
+        parsedEntries,
+    };
+};
+const buildTicketGitStatus = (output, cwd, { entries, parsedEntries }, recordedBase = null, options = {}) => {
+    const includeFiles = options.includeFiles ?? true;
+    const includeWorkspaceSignature = options.includeWorkspaceSignature ?? true;
+    const files = includeFiles
+        ? parsedEntries.map(entry => ({
+            path: entry.path,
+            original_path: entry.originalPath,
+            status: entry.status,
+            staged: entry.staged,
+            unstaged: entry.unstaged,
+            conflicted: entry.conflicted,
+        }))
+        : [];
+    const blockedReason = includeFiles ? getCommitBlockedReason(files) : null;
+    const hasStagedChanges = parsedEntries.some(entry => entry.staged);
+    const hasUnstagedChanges = parsedEntries.some(entry => entry.unstaged || entry.status === 'untracked');
+    const branchSyncState = getBranchSyncState(entries, cwd, recordedBase);
+    const workspaceSignature = includeWorkspaceSignature
+        ? getWorkspaceSignature(output, cwd, parsedEntries)
+        : null;
+    return {
+        branch: branchSyncState.branch,
+        ahead: branchSyncState.ahead,
+        behind: branchSyncState.behind,
+        has_upstream: branchSyncState.hasUpstream,
+        workspace_signature: workspaceSignature,
+        is_dirty: parsedEntries.length > 0,
+        has_staged_changes: hasStagedChanges,
+        has_unstaged_changes: hasUnstagedChanges,
+        files,
+        can_commit: includeFiles && files.length > 0 && blockedReason === null,
+        can_push: branchSyncState.canPush,
+        blocked_reason: blockedReason,
+    };
+};
+const listUntrackedFiles = (cwd) => {
+    return runGitText(['ls-files', '--others', '--exclude-standard'], cwd)
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+};
+const listUntrackedFilesAsync = async (cwd) => {
+    return (await runGitTextAsync(['ls-files', '--others', '--exclude-standard'], cwd)).stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+};
+const getUntrackedNumstatEntry = (path, cwd) => {
+    const output = runGitDiffText(['diff', '--no-index', '--numstat', '--', '/dev/null', path], cwd);
+    const entry = parseNumstatOutput(output)[0];
+    if (!entry) {
+        return null;
+    }
+    return {
+        ...entry,
+        path: normalizeNoIndexPath(entry.path),
+    };
+};
+const getUntrackedNumstatEntryAsync = async (path, cwd) => {
+    const output = await runGitDiffTextAsync(['diff', '--no-index', '--numstat', '--', '/dev/null', path], cwd);
+    const entry = parseNumstatOutput(output)[0];
+    if (!entry) {
+        return null;
+    }
+    return {
+        ...entry,
+        path: normalizeNoIndexPath(entry.path),
+    };
+};
+const getUntrackedUnifiedDiff = (path, cwd) => {
+    return runGitDiffText(['diff', '--no-index', '-U3', '--', '/dev/null', path], cwd);
+};
+const getUntrackedUnifiedDiffAsync = (path, cwd) => {
+    return runGitDiffTextAsync(['diff', '--no-index', '-U3', '--', '/dev/null', path], cwd);
+};
+const getSelectedDiffDataForCwd = (cwd, selectedPaths) => {
+    const normalizedPaths = [...new Set(selectedPaths.map(path => path.trim()).filter(Boolean))];
+    if (normalizedPaths.length === 0) {
+        return {
+            files: [],
+            diff: '',
+        };
+    }
+    try {
+        const untrackedPathSet = new Set(listUntrackedFiles(cwd));
+        const trackedPaths = normalizedPaths.filter(path => !untrackedPathSet.has(path));
+        const untrackedPaths = normalizedPaths.filter(path => untrackedPathSet.has(path));
+        const trackedNumstat = trackedPaths.length > 0
+            ? parseNumstatOutput(runGitText(['diff', '--numstat', '--find-renames', '--no-ext-diff', 'HEAD', '--', ...trackedPaths], cwd))
+            : [];
+        const untrackedNumstat = untrackedPaths
+            .map(path => getUntrackedNumstatEntry(path, cwd))
+            .filter((entry) => entry !== null);
+        return {
+            files: [...trackedNumstat, ...untrackedNumstat].map(entry => ({
+                path: entry.path,
+                additions: entry.additions,
+                deletions: entry.deletions,
+            })),
+            diff: [
+                trackedPaths.length > 0
+                    ? runGitText(['diff', '-U3', '--find-renames', '--no-ext-diff', 'HEAD', '--', ...trackedPaths], cwd)
+                    : '',
+                ...untrackedPaths.map(path => getUntrackedUnifiedDiff(path, cwd)),
+            ].join(''),
+        };
+    }
+    catch {
+        return {
+            files: [],
+            diff: '',
+        };
+    }
+};
+const getWorktreeDiffData = (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    return getDiffDataForCwd(cwd);
+};
+const buildDiffFilesForCwd = (cwd, untrackedPaths) => {
+    const trackedNumstat = parseNumstatOutput(runGitText(['diff', '--numstat', '--find-renames', '--no-ext-diff', 'HEAD'], cwd));
+    const untrackedNumstat = untrackedPaths
+        .map(path => getUntrackedNumstatEntry(path, cwd))
+        .filter((entry) => entry !== null);
+    return [...trackedNumstat, ...untrackedNumstat].map(entry => ({
+        path: entry.path,
+        additions: entry.additions,
+        deletions: entry.deletions,
+    }));
+};
+const getDiffFilesForCwd = (cwd) => {
+    return buildDiffFilesForCwd(cwd, listUntrackedFiles(cwd));
+};
+const getDiffDataForCwd = (cwd) => {
+    try {
+        const untrackedPaths = listUntrackedFiles(cwd);
+        const files = buildDiffFilesForCwd(cwd, untrackedPaths);
+        return {
+            files,
+            diff: [
+                runGitText(['diff', '-U3', '--find-renames', '--no-ext-diff', 'HEAD'], cwd),
+                ...untrackedPaths.map(path => getUntrackedUnifiedDiff(path, cwd)),
+            ].join(''),
+        };
+    }
+    catch {
+        return {
+            files: [],
+            diff: '',
+        };
+    }
+};
+const getDiffDataForCwdAsync = async (cwd) => {
+    try {
+        const trackedNumstat = parseNumstatOutput((await runGitTextAsync(['diff', '--numstat', '--find-renames', '--no-ext-diff', 'HEAD'], cwd)).stdout);
+        const untrackedPaths = await listUntrackedFilesAsync(cwd);
+        const untrackedNumstat = (await Promise.all(untrackedPaths.map(path => getUntrackedNumstatEntryAsync(path, cwd))))
+            .filter((entry) => entry !== null);
+        const trackedDiff = (await runGitTextAsync(['diff', '-U3', '--find-renames', '--no-ext-diff', 'HEAD'], cwd)).stdout;
+        const untrackedDiffs = await Promise.all(untrackedPaths.map(path => getUntrackedUnifiedDiffAsync(path, cwd)));
+        return {
+            files: [...trackedNumstat, ...untrackedNumstat].map(entry => ({
+                path: entry.path,
+                additions: entry.additions,
+                deletions: entry.deletions,
+            })),
+            diff: [trackedDiff, ...untrackedDiffs].join(''),
+        };
+    }
+    catch {
+        return {
+            files: [],
+            diff: '',
+        };
+    }
+};
+export const summarizeTicketDiffFiles = (files) => {
+    const additions = files.reduce((sum, entry) => sum + entry.additions, 0);
+    const deletions = files.reduce((sum, entry) => sum + entry.deletions, 0);
+    return {
+        files_changed: files.length,
+        additions,
+        deletions,
+        is_dirty: files.length > 0,
+    };
+};
+const getRegisteredWorktreePath = (branch, project, worktreeRecordsCache) => {
+    const record = listWorktreeRecords(project, worktreeRecordsCache).find(worktree => worktree.branch === branch);
+    return record?.path ?? null;
+};
+export const branchExistsLocally = (branch, project) => {
+    const repoPath = getRepoPath(project);
+    try {
+        execFileSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+            cwd: repoPath,
+            stdio: 'ignore',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const listLocalBranches = (project = null) => {
+    const repoPath = getRepoPath(project);
+    const currentBranch = getProjectBranch(project, { includeDiffStats: false }).branch;
+    const output = runGitText(['for-each-ref', '--format=%(refname:short)', 'refs/heads'], repoPath);
+    const branches = output
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+    const deduped = [...new Set(branches)];
+    deduped.sort((left, right) => {
+        if (currentBranch && left === currentBranch) {
+            return -1;
+        }
+        if (currentBranch && right === currentBranch) {
+            return 1;
+        }
+        return left.localeCompare(right);
+    });
+    return deduped;
+};
+const readOptionalGitText = (args, cwd) => {
+    try {
+        return runGitText(args, cwd).trim() || null;
+    }
+    catch {
+        return null;
+    }
+};
+export const getProjectBranchSuggestions = (project = null) => {
+    const repoPath = getRepoPath(project);
+    const currentBranch = getProjectBranch(project, { includeDiffStats: false }).branch;
+    const defaultRemoteHead = readOptionalGitText(['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'], repoPath);
+    const defaultBranchFromRemote = defaultRemoteHead?.startsWith('origin/')
+        ? defaultRemoteHead.slice('origin/'.length)
+        : defaultRemoteHead;
+    const defaultBranch = defaultBranchFromRemote
+        ?? (branchExistsLocally('main', project) ? 'main' : null)
+        ?? (branchExistsLocally('master', project) ? 'master' : null)
+        ?? currentBranch
+        ?? null;
+    const previousBranch = readOptionalGitText(['rev-parse', '--abbrev-ref', '@{-1}'], repoPath);
+    return {
+        currentBranch,
+        defaultBranch,
+        previousBranch: previousBranch === 'HEAD' ? null : previousBranch,
+    };
+};
+export const switchProjectBranch = (branch, project = null, options = {}) => {
+    const trimmedBranch = branch.trim();
+    if (!trimmedBranch) {
+        throw new Error('Branch name is required');
+    }
+    const repoPath = getRepoPath(project);
+    const currentBranch = resolveCurrentBranchName(repoPath);
+    if (currentBranch === trimmedBranch) {
+        return;
+    }
+    const status = getGitStatus(repoPath, null, project);
+    if (status.is_dirty && !options.allowDirty) {
+        throw new Error('Project root has uncommitted changes. Confirm branch switch to continue.');
+    }
+    const branchExists = branchExistsLocally(trimmedBranch, project);
+    if (!branchExists && !options.create) {
+        throw new Error(`Branch "${trimmedBranch}" does not exist locally.`);
+    }
+    const args = branchExists
+        ? ['checkout', trimmedBranch]
+        : ['checkout', '-b', trimmedBranch];
+    runGitText(args, repoPath);
+};
+const isPathInsideRoot = (rootPath, candidatePath) => {
+    const relativePath = relative(rootPath, candidatePath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
+};
+const resolvePathInsideRoot = (rootPath, relativePath, label) => {
+    const resolvedPath = resolve(rootPath, relativePath);
+    if (!isPathInsideRoot(rootPath, resolvedPath)) {
+        throw new Error(`${label} must stay inside ${rootPath}`);
+    }
+    return resolvedPath;
+};
+export const worktreePath = (branch, project = null) => join(getWorktreeBase(project), branch);
+export const resolveExistingWorktreePath = (branch, project = null, options = {}) => {
+    const registeredPath = getRegisteredWorktreePath(branch, project, options.worktreeRecordsCache);
+    if (registeredPath) {
+        return registeredPath;
+    }
+    const candidatePath = worktreePath(branch, project);
+    return existsSync(candidatePath) ? candidatePath : null;
+};
+export const worktreeExists = (branch, project = null) => {
+    return resolveExistingWorktreePath(branch, project) !== null;
+};
+export const resolveWorktreePath = (branch, project = null) => {
+    return resolveExistingWorktreePath(branch, project) ?? worktreePath(branch, project);
+};
+export const createWorktree = (branch, project = null, options = {}) => {
+    const repoPath = getRepoPath(project);
+    const baseBranch = resolveCurrentBranchName(repoPath);
+    const requestedBaseBranch = options.baseBranch?.trim() || null;
+    const sourceBranch = requestedBaseBranch ?? baseBranch;
+    const targetPath = worktreePath(branch, project);
+    const branchAlreadyExists = branchExistsLocally(branch, project);
+    const args = branchAlreadyExists
+        ? ['worktree', 'add', targetPath, branch]
+        : sourceBranch
+            ? ['worktree', 'add', targetPath, '-b', branch, sourceBranch]
+            : ['worktree', 'add', targetPath, '-b', branch];
+    execFileSync('git', args, { cwd: repoPath });
+    const existingBase = branchAlreadyExists ? getRecordedWorktreeBase(branch, project) : null;
+    const baseCommit = branchAlreadyExists
+        ? (existingBase?.baseCommit ?? resolveBranchMergeBase(baseBranch, branch, repoPath))
+        : resolveHeadCommit(repoPath);
+    saveWorktreeBase(branch, project, {
+        baseBranch: existingBase?.baseBranch ?? sourceBranch,
+        baseCommit,
+    });
+};
+export const createWorktreeAsync = async (branch, project = null, options = {}) => {
+    const repoPath = getRepoPath(project);
+    const baseBranch = resolveCurrentBranchName(repoPath);
+    const requestedBaseBranch = options.baseBranch?.trim() || null;
+    const sourceBranch = requestedBaseBranch ?? baseBranch;
+    const targetPath = worktreePath(branch, project);
+    const branchAlreadyExists = branchExistsLocally(branch, project);
+    const args = branchAlreadyExists
+        ? ['worktree', 'add', targetPath, branch]
+        : sourceBranch
+            ? ['worktree', 'add', targetPath, '-b', branch, sourceBranch]
+            : ['worktree', 'add', targetPath, '-b', branch];
+    await runGitTextAsync(args, repoPath);
+    const existingBase = branchAlreadyExists ? getRecordedWorktreeBase(branch, project) : null;
+    const baseCommit = branchAlreadyExists
+        ? (existingBase?.baseCommit ?? resolveBranchMergeBase(baseBranch, branch, repoPath))
+        : resolveHeadCommit(repoPath);
+    saveWorktreeBase(branch, project, {
+        baseBranch: existingBase?.baseBranch ?? sourceBranch,
+        baseCommit,
+    });
+};
+export const deleteWorktree = (branch, project = null) => {
+    const repoPath = getRepoPath(project);
+    const registeredPath = getRegisteredWorktreePath(branch, project);
+    const targetPath = registeredPath ?? worktreePath(branch, project);
+    if (!registeredPath && !existsSync(targetPath)) {
+        return false;
+    }
+    execFileSync('git', ['worktree', 'remove', '--force', targetPath], {
+        cwd: repoPath,
+    });
+    deleteWorktreeBase(branch, project);
+    return true;
+};
+export const getProjectBranch = (project = null, options = {}) => {
+    const repoPath = getRepoPath(project);
+    const includeDiffStats = options.includeDiffStats ?? true;
+    let output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
+    let entries = output.split('\0').filter(Boolean);
+    let branchState = getBranchSyncState(entries, repoPath);
+    if (branchState.branch && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(repoPath, branchState.branch), options.refreshRemote ?? false)) {
+        refreshProjectBranchTracking(repoPath, branchState.branch);
+        output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
+        entries = output.split('\0').filter(Boolean);
+        branchState = getBranchSyncState(entries, repoPath);
+    }
+    if (!branchState.branch) {
+        const statusLine = output.split('\0').find(entry => entry.startsWith('# branch.head ')) ?? '';
+        if (statusLine.endsWith('(detached)')) {
+            return getEmptyProjectBranchResponse('detached');
+        }
+        return getEmptyProjectBranchResponse('unknown');
+    }
+    return {
+        branch: branchState.branch,
+        status: 'ready',
+        ahead: branchState.ahead,
+        behind: branchState.behind,
+        has_upstream: branchState.hasUpstream,
+        can_pull: branchState.behind > 0,
+        diff_stats: includeDiffStats ? summarizeTicketDiffFiles(getGitDiffFiles(repoPath)) : null,
+    };
+};
+export const pullGitBranch = async (cwd, branch = null, project = null) => {
+    const gitStatus = getGitStatus(cwd, branch, project, { refreshRemote: true });
+    if (!gitStatus.branch || gitStatus.behind === 0) {
+        throw new Error('This branch is already up to date.');
+    }
+    await runGitTextAsync(['pull', '--ff-only'], cwd);
+};
+export const pullProjectBranch = async (project = null) => {
+    const repoPath = getRepoPath(project);
+    const branchState = getProjectBranch(project, { refreshRemote: true });
+    await pullGitBranch(repoPath, branchState.branch, project);
+};
+export const getWorktreeDiffFiles = (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    try {
+        return getDiffFilesForCwd(cwd);
+    }
+    catch {
+        return [];
+    }
+};
+export const getGitDiffFiles = (cwd) => {
+    return getDiffDataForCwd(cwd).files;
+};
+export const getGitDiffData = (cwd) => {
+    return getDiffDataForCwd(cwd);
+};
+export const getGitDiffFilesAsync = async (cwd) => {
+    return (await getDiffDataForCwdAsync(cwd)).files;
+};
+export const getWorktreeDiffStats = (branch, project = null) => {
+    return summarizeTicketDiffFiles(getWorktreeDiffFiles(branch, project));
+};
+export const getWorktreeUnifiedDiff = (branch, project = null) => {
+    return getWorktreeDiffData(branch, project).diff;
+};
+export const getGitUnifiedDiff = (cwd) => {
+    return getDiffDataForCwd(cwd).diff;
+};
+export const getGitUnifiedDiffAsync = async (cwd) => {
+    return (await getDiffDataForCwdAsync(cwd)).diff;
+};
+export const getSelectedGitUnifiedDiff = (cwd, selectedPaths) => {
+    return getSelectedDiffDataForCwd(cwd, selectedPaths).diff;
+};
+export const getBundleReviewDiffForCwd = ({ cwd, branch, project, pullRequestBaseBranch = null, }) => {
+    const reviewBase = resolveBundleReviewBase({
+        cwd,
+        branch,
+        project,
+        pullRequestBaseBranch,
+    });
+    if (!reviewBase?.baseCommit) {
+        return null;
+    }
+    const diffData = getDiffDataForBaseRef(cwd, reviewBase.baseCommit);
+    const worktreeStatus = getGitStatus(cwd, branch, project);
+    return {
+        stats: {
+            ...summarizeTicketDiffFiles(diffData.files),
+            is_dirty: worktreeStatus.is_dirty,
+        },
+        files: diffData.files,
+        diff: diffData.diff,
+        head_branch: branch,
+        base_branch: reviewBase.baseBranch,
+        base_commit: reviewBase.baseCommit,
+        source: reviewBase.source,
+    };
+};
+const resolveRecordedBaseForCwd = (cwd, branch, project) => {
+    const repoPath = getRepoPath(project);
+    return resolve(cwd) === repoPath ? null : getRecordedWorktreeBase(branch, project);
+};
+export const getGitStatus = (cwd, branch = null, project = null, options = {}) => {
+    const recordedBase = branch && project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
+    const branchName = branch ?? resolveCurrentBranchName(cwd);
+    if (branchName && (options.refreshRemote ?? true) && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(cwd, branchName), options.refreshRemote ?? false)) {
+        refreshProjectBranchTracking(cwd, branchName);
+    }
+    try {
+        const output = runGitText(['status', '--porcelain=v2', '--branch', '--untracked-files=all', '-z'], cwd);
+        const parsedOutput = parseGitStatusOutput(output);
+        const status = buildTicketGitStatus(output, cwd, parsedOutput, recordedBase, options);
+        const resolvedBranchName = status.branch ?? branchName;
+        if (!recordedBase && resolvedBranchName && project) {
+            const fallbackBase = resolveFallbackBase(resolvedBranchName, project);
+            if (fallbackBase) {
+                return buildTicketGitStatus(output, cwd, parsedOutput, fallbackBase, options);
+            }
+        }
+        return status;
+    }
+    catch {
+        return {
+            branch: null,
+            ahead: 0,
+            behind: 0,
+            has_upstream: false,
+            workspace_signature: null,
+            is_dirty: false,
+            has_staged_changes: false,
+            has_unstaged_changes: false,
+            files: [],
+            can_commit: false,
+            can_push: false,
+            blocked_reason: 'Unable to read git status for this worktree.',
+        };
+    }
+};
+export const getWorktreeGitStatus = (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    return getGitStatus(cwd, branch, project);
+};
+export const getBoardGitStatus = (cwd, branch = null, project = null) => {
+    return getGitStatus(cwd, branch, project, {
+        refreshRemote: false,
+        includeFiles: false,
+        includeWorkspaceSignature: false,
+    });
+};
+export const getBoardWorktreeGitStatus = (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    return getBoardGitStatus(cwd, branch, project);
+};
+export const commitGitChanges = async (cwd, branch, project, message, selectedPaths) => {
+    const normalizedMessage = message.trim();
+    if (!normalizedMessage) {
+        throw new Error('Commit message is required.');
+    }
+    if (selectedPaths.length === 0) {
+        throw new Error('Select at least one file to commit.');
+    }
+    const status = getGitStatus(cwd, branch, project);
+    const selectedPathSet = new Set(selectedPaths);
+    const blockedReason = getStatusSelectionBlockedReason(status.files, selectedPathSet) ?? status.blocked_reason;
+    if (blockedReason) {
+        throw new Error(blockedReason);
+    }
+    const availablePaths = new Set(status.files.map(file => file.path));
+    for (const path of selectedPaths) {
+        if (!availablePaths.has(path)) {
+            throw new Error(`"${path}" is no longer available to commit.`);
+        }
+    }
+    await runGitTextAsync(['add', '-A', '--', ...selectedPaths], cwd);
+    await runGitTextAsync(['commit', '-m', normalizedMessage], cwd);
+};
+export const commitWorktreeChanges = async (branch, project, message, selectedPaths) => {
+    const cwd = resolveWorktreePath(branch, project);
+    await commitGitChanges(cwd, branch, project, message, selectedPaths);
+};
+export const pushCurrentBranch = async (cwd, branch) => {
+    await runGitTextAsync(['push', '-u', 'origin', branch], cwd);
+};
+export const pushWorktreeBranch = async (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    await pushCurrentBranch(cwd, branch);
+};
+export const listUnpushedCommitsForCwd = (cwd, branch, project = null) => {
+    const recordedBase = project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
+    const fallbackBase = recordedBase ?? (project ? resolveFallbackBase(branch, project) : null);
+    return listUnpushedCommitRecords(cwd, branch, fallbackBase?.baseBranch ?? null, fallbackBase?.baseCommit ?? null);
+};
+export const listUnpushedCommits = (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    return listUnpushedCommitsForCwd(cwd, branch, project);
+};
+export const undoLatestUnpushedCommitForCwd = async (cwd, branch, project = null) => {
+    const commits = listUnpushedCommitsForCwd(cwd, branch, project);
+    if (commits.length === 0) {
+        throw new Error('There are no local commits to undo.');
+    }
+    await runGitTextAsync(['reset', '--mixed', 'HEAD~1'], cwd);
+};
+export const undoLatestUnpushedCommit = async (branch, project = null) => {
+    const cwd = resolveWorktreePath(branch, project);
+    await undoLatestUnpushedCommitForCwd(cwd, branch, project);
+};
+export const syncWorktreeFiles = (branch, project = null) => {
+    if (!project) {
+        return;
+    }
+    const syncItems = getProjectWorktreeSync(project);
+    if (syncItems.length === 0) {
+        return;
+    }
+    const repoPath = getRepoPath(project);
+    const targetRoot = resolveWorktreePath(branch, project);
+    for (const item of syncItems) {
+        const sourcePath = resolvePathInsideRoot(repoPath, item.source, 'Worktree sync source');
+        if (!existsSync(sourcePath)) {
+            throw new Error(`Worktree sync source does not exist: ${item.source}`);
+        }
+        const targetRelativePath = item.target ?? item.source;
+        const targetPath = resolvePathInsideRoot(targetRoot, targetRelativePath, 'Worktree sync target');
+        if (existsSync(targetPath)) {
+            continue;
+        }
+        mkdirSync(dirname(targetPath), { recursive: true });
+        if (item.mode === 'copy') {
+            cpSync(sourcePath, targetPath, { recursive: true, force: false, errorOnExist: false });
+            continue;
+        }
+        const sourceStat = lstatSync(sourcePath);
+        symlinkSync(sourcePath, targetPath, sourceStat.isDirectory() ? 'dir' : 'file');
+    }
+};
+export const syncWorktreeFilesAsync = async (branch, project = null) => {
+    if (!project) {
+        return;
+    }
+    const syncItems = getProjectWorktreeSync(project);
+    if (syncItems.length === 0) {
+        return;
+    }
+    const repoPath = getRepoPath(project);
+    const targetRoot = resolveWorktreePath(branch, project);
+    for (const item of syncItems) {
+        const sourcePath = resolvePathInsideRoot(repoPath, item.source, 'Worktree sync source');
+        if (!existsSync(sourcePath)) {
+            throw new Error(`Worktree sync source does not exist: ${item.source}`);
+        }
+        const targetRelativePath = item.target ?? item.source;
+        const targetPath = resolvePathInsideRoot(targetRoot, targetRelativePath, 'Worktree sync target');
+        if (existsSync(targetPath)) {
+            continue;
+        }
+        await mkdirAsync(dirname(targetPath), { recursive: true });
+        if (item.mode === 'copy') {
+            await cpAsync(sourcePath, targetPath, { recursive: true, force: false, errorOnExist: false });
+            continue;
+        }
+        const sourceStat = await lstatAsync(sourcePath);
+        await symlinkAsync(sourcePath, targetPath, sourceStat.isDirectory() ? 'dir' : 'file');
+    }
+};
+//# sourceMappingURL=git.js.map