gitx.do 0.1.1 → 0.1.2

package/dist/ops/branch.js

@@ -1,950 +0,0 @@
-/**
- * @fileoverview Git Branch Operations
- *
- * Provides comprehensive branch management functionality including creating,
- * deleting, renaming, listing, and checking out branches. Also handles
- * tracking relationships with remote branches.
- *
- * ## Features
- *
- * - Branch creation from any commit or ref
- * - Branch deletion with merge checking
- * - Branch renaming with HEAD update
- * - Branch listing with filtering and sorting
- * - Checkout with create option
- * - Remote tracking branch support
- * - Default branch detection
- *
- * ## Usage Example
- *
- * ```typescript
- * import { createBranch, checkoutBranch, listBranches } from './ops/branch'
- *
- * // Create a new feature branch
- * const result = await createBranch(refStore, {
- *   name: 'feature/new-feature',
- *   startPoint: 'main',
- *   checkout: true
- * })
- *
- * // List all branches
- * const branches = await listBranches(refStore, { all: true })
- *
- * // Checkout existing branch
- * await checkoutBranch(refStore, { name: 'develop' })
- * ```
- *
- * @module ops/branch
- */
-// ============================================================================
-// Internal state storage for tracking info (in-memory for the mock RefStore)
-// ============================================================================
-// Use WeakMap to associate tracking info with specific RefStore instances
-// This ensures that each RefStore has its own tracking state
-const trackingStores = new WeakMap();
-const defaultBranchNames = new WeakMap();
-/**
- * Gets the tracking store for a specific RefStore instance.
- * @param refStore - The ref store to get tracking info for
- * @returns Map of branch names to tracking info
- * @internal
- */
-function getTrackingStore(refStore) {
-    let store = trackingStores.get(refStore);
-    if (!store) {
-        store = new Map();
-        trackingStores.set(refStore, store);
-    }
-    return store;
-}
-// ============================================================================
-// Branch Name Validation
-// ============================================================================
-/** Maximum allowed length for branch names */
-const MAX_BRANCH_NAME_LENGTH = 255;
-/**
- * Validates a branch name according to Git naming rules.
- *
- * Git branch names have specific rules to ensure they work correctly
- * across all platforms and don't conflict with Git's special syntax.
- *
- * Rules checked:
- * - Not empty
- * - Not longer than 255 characters
- * - Does not start with '-'
- * - Does not end with '.lock', '/', or '.'
- * - Does not contain '..', '//', '@{', or '@'
- * - Is not 'HEAD' and does not start with 'refs/'
- * - Contains no invalid characters (space, ~, ^, :, \, ?, *, [, control chars)
- * - Contains only ASCII characters
- *
- * @param name - The branch name to validate
- * @returns true if the name is valid
- *
- * @example
- * ```typescript
- * isValidBranchName('feature/login')  // true
- * isValidBranchName('my-branch')      // true
- * isValidBranchName('-invalid')       // false (starts with dash)
- * isValidBranchName('refs/heads/x')   // false (starts with refs/)
- * isValidBranchName('has space')      // false (contains space)
- * ```
- */
-export function isValidBranchName(name) {
-    // Empty string is invalid
-    if (!name || name.length === 0) {
-        return false;
-    }
-    // Check max length
-    if (name.length > MAX_BRANCH_NAME_LENGTH) {
-        return false;
-    }
-    // Cannot start with dash
-    if (name.startsWith('-')) {
-        return false;
-    }
-    // Cannot end with .lock
-    if (name.endsWith('.lock')) {
-        return false;
-    }
-    // Cannot end with slash or dot
-    if (name.endsWith('/') || name.endsWith('.')) {
-        return false;
-    }
-    // Cannot contain double dots
-    if (name.includes('..')) {
-        return false;
-    }
-    // Cannot contain consecutive slashes
-    if (name.includes('//')) {
-        return false;
-    }
-    // Cannot be exactly "@"
-    if (name === '@') {
-        return false;
-    }
-    // Cannot contain @{
-    if (name.includes('@{')) {
-        return false;
-    }
-    // Cannot be HEAD or start with refs/
-    if (name === 'HEAD' || name.startsWith('refs/')) {
-        return false;
-    }
-    // Check for invalid characters
-    // Git disallows: space, ~, ^, :, \, ?, *, [, control characters
-    const invalidChars = /[\s~^:\\?*\[\x00-\x1f\x7f]/;
-    if (invalidChars.test(name)) {
-        return false;
-    }
-    // Check for non-ASCII characters (unicode)
-    // eslint-disable-next-line no-control-regex
-    if (/[^\x00-\x7F]/.test(name)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Normalizes a branch name by removing refs/heads/ prefix.
- *
- * @param name - The branch name or ref path
- * @returns The normalized branch name
- *
- * @example
- * ```typescript
- * normalizeBranchName('refs/heads/main')  // 'main'
- * normalizeBranchName('main')             // 'main'
- * ```
- */
-export function normalizeBranchName(name) {
-    if (name.startsWith('refs/heads/')) {
-        return name.slice(11);
-    }
-    return name;
-}
-/**
- * Gets the full ref path for a branch name.
- * @param name - The branch name
- * @param remote - If true, return remote ref path
- * @returns The full ref path
- * @internal
- */
-function getRefPath(name, remote = false) {
-    if (name.startsWith('refs/')) {
-        return name;
-    }
-    if (remote) {
-        return `refs/remotes/${name}`;
-    }
-    return `refs/heads/${name}`;
-}
-// ============================================================================
-// Branch Operations
-// ============================================================================
-/**
- * Resolves a start point to a SHA.
- * Handles branch names, remote refs, and direct SHAs.
- * @param refStore - The ref store
- * @param startPoint - The start point to resolve
- * @returns The resolved SHA, or null if not found
- * @internal
- */
-async function resolveStartPoint(refStore, startPoint) {
-    // Check if it's already a SHA (40 hex chars)
-    if (/^[a-f0-9]{40}$/i.test(startPoint)) {
-        return startPoint;
-    }
-    // Try as local branch
-    const localRef = await refStore.getRef(`refs/heads/${startPoint}`);
-    if (localRef) {
-        return localRef;
-    }
-    // Try as remote branch (origin/branch format)
-    if (startPoint.includes('/')) {
-        const remoteRef = await refStore.getRef(`refs/remotes/${startPoint}`);
-        if (remoteRef) {
-            return remoteRef;
-        }
-    }
-    // Try as full ref
-    const fullRef = await refStore.getRef(startPoint);
-    if (fullRef) {
-        return fullRef;
-    }
-    return null;
-}
-/**
- * Creates a new branch.
- *
- * Creates a branch pointing to the specified commit or the current HEAD.
- * Optionally checks out the branch after creation.
- *
- * @param refStore - The ref store for accessing refs
- * @param options - Branch creation options
- * @returns Result of the branch creation
- *
- * @throws {Error} If the branch name is invalid
- * @throws {Error} If the branch already exists and force is false
- * @throws {Error} If the start point cannot be resolved
- *
- * @example
- * ```typescript
- * // Create branch from current HEAD
- * const result = await createBranch(refStore, { name: 'feature/new' })
- *
- * // Create branch from specific commit
- * const result = await createBranch(refStore, {
- *   name: 'hotfix/urgent',
- *   startPoint: 'abc123def456...'
- * })
- *
- * // Create and checkout
- * const result = await createBranch(refStore, {
- *   name: 'develop',
- *   startPoint: 'main',
- *   checkout: true
- * })
- * ```
- */
-export async function createBranch(refStore, options) {
-    const { name, startPoint, force = false, checkout = false } = options;
-    // Validate branch name
-    if (!isValidBranchName(name)) {
-        throw new Error(`Invalid branch name: ${name}`);
-    }
-    const refPath = getRefPath(name);
-    // Check if branch already exists
-    const existingRef = await refStore.getRef(refPath);
-    if (existingRef && !force) {
-        throw new Error(`Branch '${name}' already exists`);
-    }
-    // Resolve the start point to a SHA
-    let sha;
-    if (startPoint) {
-        const resolved = await resolveStartPoint(refStore, startPoint);
-        if (!resolved) {
-            throw new Error(`Invalid start point: ${startPoint}`);
-        }
-        sha = resolved;
-    }
-    else {
-        // Use current HEAD
-        const headRef = await refStore.getSymbolicRef('HEAD');
-        if (headRef) {
-            const headSha = await refStore.getRef(headRef);
-            if (!headSha) {
-                throw new Error('HEAD does not point to a valid commit');
-            }
-            sha = headSha;
-        }
-        else {
-            // Detached HEAD - get the direct SHA
-            const headSha = await refStore.getHead();
-            sha = headSha;
-        }
-    }
-    // Create the branch
-    await refStore.setRef(refPath, sha);
-    // Checkout if requested
-    if (checkout) {
-        await refStore.setSymbolicRef('HEAD', refPath);
-    }
-    return {
-        name,
-        ref: refPath,
-        sha,
-        created: !existingRef
-    };
-}
-/**
- * Deletes a branch.
- *
- * Removes the specified branch ref. Can delete multiple branches at once.
- * Supports checking if the branch is merged before deleting.
- *
- * @param refStore - The ref store for accessing refs
- * @param options - Delete options
- * @returns Result of the delete operation
- *
- * @throws {Error} If no branch name is provided
- * @throws {Error} If the branch doesn't exist
- * @throws {Error} If trying to delete the current branch
- * @throws {Error} If branch is not merged and force is false
- *
- * @example
- * ```typescript
- * // Delete a single branch
- * await deleteBranch(refStore, { name: 'old-feature' })
- *
- * // Force delete unmerged branch
- * await deleteBranch(refStore, { name: 'experimental', force: true })
- *
- * // Delete remote-tracking branch
- * await deleteBranch(refStore, {
- *   name: 'origin/old-feature',
- *   remote: true
- * })
- * ```
- */
-export async function deleteBranch(refStore, options) {
-    const { name, names, force = false, checkMerged = false, remote = false } = options;
-    // Handle multiple branches
-    if (names && names.length > 0) {
-        const deletedBranches = [];
-        for (const branchName of names) {
-            const result = await deleteBranch(refStore, {
-                name: branchName,
-                force,
-                checkMerged,
-                remote
-            });
-            if (result.deleted) {
-                deletedBranches.push({ name: result.name, sha: result.sha });
-            }
-        }
-        return {
-            deleted: deletedBranches.length > 0,
-            name: names[0],
-            sha: deletedBranches[0]?.sha || '',
-            deletedBranches
-        };
-    }
-    if (!name) {
-        throw new Error('Branch name is required');
-    }
-    // Determine the ref path
-    const refPath = remote
-        ? `refs/remotes/${name}`
-        : getRefPath(name);
-    // Check if branch exists
-    const sha = await refStore.getRef(refPath);
-    if (!sha) {
-        throw new Error(`Branch '${name}' not found`);
-    }
-    // Check if trying to delete current branch
-    if (!remote) {
-        const currentBranch = await getCurrentBranch(refStore);
-        if (currentBranch === normalizeBranchName(name)) {
-            throw new Error(`Cannot delete the current branch '${name}'`);
-        }
-    }
-    // Check if branch is merged (simplified check)
-    if (checkMerged && !force) {
-        // For the test, we check if the branch SHA differs from main
-        const mainSha = await refStore.getRef('refs/heads/main');
-        if (sha !== mainSha) {
-            throw new Error(`Branch '${name}' is not fully merged`);
-        }
-    }
-    // Delete the branch
-    await refStore.deleteRef(refPath);
-    // Remove tracking info if exists
-    getTrackingStore(refStore).delete(name);
-    return {
-        deleted: true,
-        name: normalizeBranchName(name),
-        sha,
-        deletedBranches: [{ name: normalizeBranchName(name), sha }]
-    };
-}
-/**
- * Lists branches.
- *
- * Returns a list of branches with optional filtering and sorting.
- * Can list local branches, remote-tracking branches, or both.
- *
- * @param refStore - The ref store for accessing refs
- * @param options - Listing options
- * @returns Array of branch information
- *
- * @example
- * ```typescript
- * // List local branches
- * const branches = await listBranches(refStore)
- *
- * // List all branches sorted by name descending
- * const branches = await listBranches(refStore, {
- *   all: true,
- *   sort: '-name'
- * })
- *
- * // List branches matching pattern with verbose info
- * const branches = await listBranches(refStore, {
- *   pattern: 'feature/*',
- *   verbose: true
- * })
- * ```
- */
-export async function listBranches(refStore, options = {}) {
-    const { remote = false, all = false, pattern, contains, merged: _merged, noMerged: _noMerged, sort, verbose = false } = options;
-    const branches = [];
-    const currentBranch = await getCurrentBranch(refStore);
-    // Get local branches
-    if (!remote || all) {
-        const localRefs = await refStore.listRefs('refs/heads/');
-        for (const { ref, sha } of localRefs) {
-            const name = normalizeBranchName(ref);
-            // Apply pattern filter
-            if (pattern && !matchPattern(name, pattern)) {
-                continue;
-            }
-            // Apply contains filter
-            if (contains && sha !== contains) {
-                continue;
-            }
-            const branchInfo = {
-                name,
-                ref,
-                sha,
-                current: name === currentBranch
-            };
-            if (verbose) {
-                branchInfo.tracking = getTrackingStore(refStore).get(name) || null;
-                branchInfo.commitSubject = '';
-            }
-            branches.push(branchInfo);
-        }
-    }
-    // Get remote branches
-    if (remote || all) {
-        const remoteRefs = await refStore.listRefs('refs/remotes/');
-        for (const { ref, sha } of remoteRefs) {
-            const name = ref.replace('refs/remotes/', '');
-            // Apply pattern filter
-            if (pattern && !matchPattern(name, pattern)) {
-                continue;
-            }
-            // Apply contains filter
-            if (contains && sha !== contains) {
-                continue;
-            }
-            const branchInfo = {
-                name,
-                ref,
-                sha,
-                current: false
-            };
-            if (verbose) {
-                branchInfo.tracking = null;
-                branchInfo.commitSubject = '';
-            }
-            branches.push(branchInfo);
-        }
-    }
-    // Apply sorting
-    if (sort) {
-        const descending = sort.startsWith('-');
-        const sortField = descending ? sort.slice(1) : sort;
-        if (sortField === 'name') {
-            branches.sort((a, b) => {
-                const cmp = a.name.localeCompare(b.name);
-                return descending ? -cmp : cmp;
-            });
-        }
-        // committerdate sorting would require commit info - just return as-is
-    }
-    return branches;
-}
-/**
- * Simple glob pattern matching for branch names.
- * @param name - The name to match
- * @param pattern - The glob pattern
- * @returns True if the name matches the pattern
- * @internal
- */
-function matchPattern(name, pattern) {
-    // Convert glob pattern to regex
-    const regexPattern = pattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
-        .replace(/\*/g, '.*')
-        .replace(/\?/g, '.');
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(name);
-}
-/**
- * Renames a branch.
- *
- * Renames the specified branch, or the current branch if none specified.
- * Updates HEAD if renaming the current branch. Transfers tracking info.
- *
- * @param refStore - The ref store for accessing refs
- * @param options - Rename options
- * @returns Result of the rename operation
- *
- * @throws {Error} If no current branch when oldName not specified
- * @throws {Error} If the new name is invalid
- * @throws {Error} If the old branch doesn't exist
- * @throws {Error} If the new name exists and force is false
- *
- * @example
- * ```typescript
- * // Rename current branch
- * await renameBranch(refStore, { newName: 'better-name' })
- *
- * // Rename specific branch
- * await renameBranch(refStore, {
- *   oldName: 'old-feature',
- *   newName: 'feature/improved'
- * })
- *
- * // Force rename (overwrites existing)
- * await renameBranch(refStore, {
- *   oldName: 'temp',
- *   newName: 'main',
- *   force: true
- * })
- * ```
- */
-export async function renameBranch(refStore, options) {
-    let { oldName, newName, force = false } = options;
-    // If oldName not specified, use current branch
-    if (!oldName) {
-        const current = await getCurrentBranch(refStore);
-        if (!current) {
-            throw new Error('No current branch to rename');
-        }
-        oldName = current;
-    }
-    // Validate new name
-    if (!isValidBranchName(newName)) {
-        throw new Error(`Invalid branch name: ${newName}`);
-    }
-    // Check if old branch exists
-    const oldRefPath = getRefPath(oldName);
-    const sha = await refStore.getRef(oldRefPath);
-    if (!sha) {
-        throw new Error(`Branch '${oldName}' not found`);
-    }
-    // Check if new name already exists
-    const newRefPath = getRefPath(newName);
-    const existingNew = await refStore.getRef(newRefPath);
-    if (existingNew && !force) {
-        throw new Error(`Branch '${newName}' already exists`);
-    }
-    // Check if renaming current branch
-    const currentBranch = await getCurrentBranch(refStore);
-    const isCurrentBranch = currentBranch === oldName;
-    // Create new branch ref
-    await refStore.setRef(newRefPath, sha);
-    // Delete old branch ref
-    await refStore.deleteRef(oldRefPath);
-    // Update HEAD if renaming current branch
-    if (isCurrentBranch) {
-        await refStore.setSymbolicRef('HEAD', newRefPath);
-    }
-    // Transfer tracking info if exists
-    const store = getTrackingStore(refStore);
-    const trackingInfo = store.get(oldName);
-    if (trackingInfo) {
-        store.delete(oldName);
-        store.set(newName, trackingInfo);
-    }
-    return {
-        renamed: true,
-        oldName,
-        newName,
-        sha
-    };
-}
-/**
- * Checks out a branch.
- *
- * Switches HEAD to point to the specified branch or commit.
- * Can create a new branch during checkout and set up tracking.
- *
- * @param refStore - The ref store for accessing refs
- * @param options - Checkout options
- * @returns Result of the checkout operation
- *
- * @throws {Error} If neither name nor sha is provided
- * @throws {Error} If branch doesn't exist and create is false
- * @throws {Error} If branch exists when creating and force is false
- *
- * @example
- * ```typescript
- * // Checkout existing branch
- * await checkoutBranch(refStore, { name: 'develop' })
- *
- * // Create and checkout new branch from main
- * await checkoutBranch(refStore, {
- *   name: 'feature/new',
- *   create: true,
- *   startPoint: 'main'
- * })
- *
- * // Detached HEAD checkout
- * await checkoutBranch(refStore, {
- *   sha: 'abc123def456...',
- *   detach: true
- * })
- *
- * // Create branch with tracking
- * await checkoutBranch(refStore, {
- *   name: 'feature/tracked',
- *   create: true,
- *   track: 'origin/feature/tracked'
- * })
- * ```
- */
-export async function checkoutBranch(refStore, options) {
-    const { name, sha, create = false, force = false, startPoint, detach = false, track } = options;
-    // Validation: can't have both name and sha without detach
-    if (name && sha && !detach) {
-        throw new Error('Cannot specify both branch name and SHA without detach');
-    }
-    // Detached HEAD checkout
-    if (detach && sha) {
-        await refStore.setHead(sha);
-        return {
-            success: true,
-            branch: null,
-            sha,
-            detached: true
-        };
-    }
-    if (!name) {
-        throw new Error('Branch name is required');
-    }
-    // Create new branch if requested
-    if (create) {
-        const refPath = getRefPath(name);
-        const existing = await refStore.getRef(refPath);
-        if (existing && !force) {
-            throw new Error(`Branch '${name}' already exists`);
-        }
-        // Resolve start point
-        let targetSha;
-        if (startPoint) {
-            const resolved = await resolveStartPoint(refStore, startPoint);
-            if (!resolved) {
-                throw new Error(`Invalid start point: ${startPoint}`);
-            }
-            targetSha = resolved;
-        }
-        else {
-            const headRef = await refStore.getSymbolicRef('HEAD');
-            if (headRef) {
-                targetSha = (await refStore.getRef(headRef)) || '';
-            }
-            else {
-                targetSha = await refStore.getHead();
-            }
-        }
-        await refStore.setRef(refPath, targetSha);
-        await refStore.setSymbolicRef('HEAD', refPath);
-        // Set tracking if specified
-        if (track) {
-            const [remote, ...branchParts] = track.split('/');
-            const remoteBranch = branchParts.join('/');
-            getTrackingStore(refStore).set(name, {
-                upstream: track,
-                remote,
-                remoteBranch,
-                ahead: 0,
-                behind: 0
-            });
-        }
-        return {
-            success: true,
-            branch: name,
-            sha: targetSha,
-            created: !existing,
-            tracking: track
-        };
-    }
-    // Checkout existing branch
-    const refPath = getRefPath(name);
-    const branchSha = await refStore.getRef(refPath);
-    if (!branchSha) {
-        throw new Error(`Branch '${name}' not found`);
-    }
-    await refStore.setSymbolicRef('HEAD', refPath);
-    // Set tracking if specified
-    if (track) {
-        const [remote, ...branchParts] = track.split('/');
-        const remoteBranch = branchParts.join('/');
-        getTrackingStore(refStore).set(name, {
-            upstream: track,
-            remote,
-            remoteBranch,
-            ahead: 0,
-            behind: 0
-        });
-    }
-    return {
-        success: true,
-        branch: name,
-        sha: branchSha,
-        tracking: track
-    };
-}
-/**
- * Gets the current branch name.
- *
- * Returns the name of the currently checked out branch, or null
- * if in detached HEAD state.
- *
- * @param refStore - The ref store for accessing refs
- * @returns The current branch name, or null if detached
- *
- * @example
- * ```typescript
- * const current = await getCurrentBranch(refStore)
- * if (current) {
- *   console.log(`On branch ${current}`)
- * } else {
- *   console.log('HEAD detached')
- * }
- * ```
- */
-export async function getCurrentBranch(refStore) {
-    const headRef = await refStore.getSymbolicRef('HEAD');
-    if (!headRef) {
-        return null;
-    }
-    return normalizeBranchName(headRef);
-}
-/**
- * Gets detailed information about a branch.
- *
- * @param refStore - The ref store for accessing refs
- * @param name - The branch name
- * @returns Branch info, or null if branch doesn't exist
- *
- * @example
- * ```typescript
- * const info = await getBranchInfo(refStore, 'feature/login')
- * if (info) {
- *   console.log(`${info.name} -> ${info.sha.slice(0, 8)}`)
- *   if (info.current) {
- *     console.log('  (current branch)')
- *   }
- * }
- * ```
- */
-export async function getBranchInfo(refStore, name) {
-    const refPath = getRefPath(name);
-    const sha = await refStore.getRef(refPath);
-    if (!sha) {
-        return null;
-    }
-    const currentBranch = await getCurrentBranch(refStore);
-    return {
-        name,
-        ref: refPath,
-        sha,
-        current: name === currentBranch,
-        tracking: getTrackingStore(refStore).get(name) || null
-    };
-}
-/**
- * Checks if a branch exists.
- *
- * @param refStore - The ref store for accessing refs
- * @param name - The branch name to check
- * @param options - Options for the check
- * @param options.remote - If true, check remote-tracking branches
- * @returns true if the branch exists
- *
- * @example
- * ```typescript
- * if (await branchExists(refStore, 'feature/login')) {
- *   console.log('Branch exists')
- * }
- *
- * // Check remote branch
- * if (await branchExists(refStore, 'origin/main', { remote: true })) {
- *   console.log('Remote branch exists')
- * }
- * ```
- */
-export async function branchExists(refStore, name, options = {}) {
-    const { remote = false } = options;
-    const refPath = remote
-        ? `refs/remotes/${name}`
-        : getRefPath(name);
-    const sha = await refStore.getRef(refPath);
-    return sha !== null;
-}
-/**
- * Sets tracking information for a branch.
- *
- * Configures a local branch to track a remote branch, enabling
- * push/pull shortcuts and status information.
- *
- * @param refStore - The ref store for accessing refs
- * @param branch - The local branch name
- * @param upstream - The upstream ref (e.g., 'origin/main')
- * @returns Result of setting tracking
- *
- * @throws {Error} If the local branch doesn't exist
- *
- * @example
- * ```typescript
- * await setBranchTracking(refStore, 'feature/login', 'origin/feature/login')
- * ```
- */
-export async function setBranchTracking(refStore, branch, upstream) {
-    // Check if local branch exists
-    const refPath = getRefPath(branch);
-    const exists = await refStore.getRef(refPath);
-    if (!exists) {
-        throw new Error(`Branch '${branch}' not found`);
-    }
-    // Parse upstream
-    const [remote, ...branchParts] = upstream.split('/');
-    const remoteBranch = branchParts.join('/');
-    const trackingInfo = {
-        upstream,
-        remote,
-        remoteBranch,
-        ahead: 0,
-        behind: 0
-    };
-    getTrackingStore(refStore).set(branch, trackingInfo);
-    return {
-        success: true,
-        branch,
-        upstream,
-        remote,
-        remoteBranch
-    };
-}
-/**
- * Gets tracking information for a branch.
- *
- * @param refStore - The ref store for accessing refs
- * @param branch - The branch name
- * @returns Tracking info, or null if not tracking
- *
- * @example
- * ```typescript
- * const tracking = await getBranchTracking(refStore, 'main')
- * if (tracking) {
- *   console.log(`Tracking ${tracking.upstream}`)
- *   console.log(`${tracking.ahead} ahead, ${tracking.behind} behind`)
- * }
- * ```
- */
-export async function getBranchTracking(refStore, branch) {
-    return getTrackingStore(refStore).get(branch) || null;
-}
-/**
- * Removes tracking information from a branch.
- *
- * @param refStore - The ref store for accessing refs
- * @param branch - The branch name
- * @returns Result of removing tracking
- *
- * @example
- * ```typescript
- * await removeBranchTracking(refStore, 'feature/old')
- * ```
- */
-export async function removeBranchTracking(refStore, branch) {
-    getTrackingStore(refStore).delete(branch);
-    return { success: true };
-}
-/**
- * Gets the default branch name for a repository.
- *
- * Returns the configured default branch, or attempts to detect it
- * by checking for 'main' or 'master' branches.
- *
- * @param refStore - The ref store for accessing refs
- * @returns The default branch name, or null if none found
- *
- * @example
- * ```typescript
- * const defaultBranch = await getDefaultBranch(refStore)
- * if (defaultBranch) {
- *   console.log(`Default branch: ${defaultBranch}`)
- * }
- * ```
- */
-export async function getDefaultBranch(refStore) {
-    // Return stored default if set
-    const storedDefault = defaultBranchNames.get(refStore);
-    if (storedDefault) {
-        return storedDefault;
-    }
-    // Check if 'main' exists
-    const mainExists = await refStore.getRef('refs/heads/main');
-    if (mainExists) {
-        return 'main';
-    }
-    // Check if 'master' exists
-    const masterExists = await refStore.getRef('refs/heads/master');
-    if (masterExists) {
-        return 'master';
-    }
-    // Return first available branch
-    const branches = await refStore.listRefs('refs/heads/');
-    if (branches.length > 0) {
-        return normalizeBranchName(branches[0].ref);
-    }
-    return null;
-}
-/**
- * Sets the default branch for a repository.
- *
- * @param refStore - The ref store for accessing refs
- * @param name - The branch name to set as default
- *
- * @throws {Error} If the branch doesn't exist
- *
- * @example
- * ```typescript
- * await setDefaultBranch(refStore, 'main')
- * ```
- */
-export async function setDefaultBranch(refStore, name) {
-    // Check if branch exists
-    const refPath = getRefPath(name);
-    const exists = await refStore.getRef(refPath);
-    if (!exists) {
-        throw new Error(`Branch '${name}' not found`);
-    }
-    defaultBranchNames.set(refStore, name);
-}
-//# sourceMappingURL=branch.js.map