gitx.do 0.0.3 → 0.1.1

package/dist/refs/branch.js

@@ -28,6 +28,9 @@
  * const branches = await listBranches(refStorage)
  * ```
  */
+import { isValidSha } from './storage';
+import { isValidRefName as _isValidRefName } from './storage';
+void _isValidRefName;
 /**
  * Error thrown when a branch operation fails.
  *
@@ -65,45 +68,21 @@ export class BranchError extends Error {
         this.name = 'BranchError';
     }
 }
-// ============================================================================
-// BranchManager Class
-// ============================================================================
-/**
- * Branch manager for performing Git branch operations.
- *
- * @description
- * Provides a comprehensive API for branch management. Uses RefStorage
- * internally for ref manipulation.
- *
- * Note: Many methods are currently stubs (TODO) and will throw 'Not implemented'.
- * These will be implemented in the GREEN phase of TDD development.
- *
- * @example
- * ```typescript
- * const manager = new BranchManager(refStorage)
- *
- * // Create a feature branch
- * const branch = await manager.createBranch('feature/auth', {
- *   startPoint: 'main',
- *   track: true
- * })
- *
- * // List all branches
- * const branches = await manager.listBranches({ includeRemotes: true })
- *
- * // Delete a merged branch
- * await manager.deleteBranch('feature/auth')
- * ```
- */
 export class BranchManager {
+    storage;
+    /** Storage for tracking information (simulated config) */
+    trackingInfo = new Map();
+    /** Optional callback to check if commits exist */
+    commitExists;
     /**
      * Create a new BranchManager.
      *
      * @param storage - RefStorage instance for ref operations
+     * @param options - Optional configuration
      */
-    constructor(storage) {
-        void storage; // Suppress unused variable warning until implementation
-        // TODO: Implement in GREEN phase
+    constructor(storage, options) {
+        this.storage = storage;
+        this.commitExists = options?.commitExists;
     }
     /**
      * Create a new branch.
@@ -131,9 +110,101 @@ export class BranchManager {
      * const branch = await manager.createBranch('main', { force: true, startPoint: 'HEAD' })
      * ```
      */
-    async createBranch(_name, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async createBranch(name, options) {
+        // Validate branch name
+        const validation = validateBranchName(name);
+        if (!validation.valid) {
+            throw new BranchError(validation.error, 'INVALID_NAME', name);
+        }
+        const branchRef = getBranchRefName(name);
+        const normalizedName = normalizeBranchName(name);
+        // Check if branch already exists
+        if (!options?.force) {
+            const existing = await this.storage.getRef(branchRef);
+            if (existing) {
+                throw new BranchError(`Branch '${name}' already exists`, 'ALREADY_EXISTS', name);
+            }
+        }
+        // Resolve start point to SHA
+        const startPoint = options?.startPoint ?? 'HEAD';
+        // Check for empty start point
+        if (startPoint === '') {
+            throw new BranchError('Start point cannot be empty', 'INVALID_START_POINT', name);
+        }
+        let sha;
+        // If startPoint is a valid SHA, use it directly
+        if (isValidSha(startPoint)) {
+            // If we have a commitExists validator, verify the commit exists
+            if (this.commitExists) {
+                const exists = await this.commitExists(startPoint);
+                if (!exists) {
+                    throw new BranchError(`Invalid start point: ${startPoint}`, 'INVALID_START_POINT', name);
+                }
+            }
+            sha = startPoint;
+        }
+        else {
+            // Try to resolve as ref
+            try {
+                // First try as branch name
+                let resolved;
+                try {
+                    resolved = await this.storage.resolveRef(getBranchRefName(startPoint));
+                }
+                catch {
+                    // Try as full ref path
+                    try {
+                        resolved = await this.storage.resolveRef(startPoint);
+                    }
+                    catch {
+                        throw new BranchError(`Invalid start point: ${startPoint}`, 'INVALID_START_POINT', name);
+                    }
+                }
+                sha = resolved.sha;
+            }
+            catch (e) {
+                if (e instanceof BranchError)
+                    throw e;
+                throw new BranchError(`Invalid start point: ${startPoint}`, 'INVALID_START_POINT', name);
+            }
+        }
+        // Get current branch to check if new branch is current
+        void await this.getCurrentBranch(); // Available for future use
+        const isCurrent = false; // New branch is never current
+        // Create tracking info if requested
+        let tracking;
+        if (options?.track) {
+            const remoteBranch = typeof options.track === 'string'
+                ? options.track
+                : (startPoint.startsWith('refs/remotes/') ? startPoint : undefined);
+            if (remoteBranch) {
+                tracking = {
+                    remote: remoteBranch.split('/')[2] || 'origin',
+                    remoteBranch,
+                    ahead: 0,
+                    behind: 0,
+                    gone: false
+                };
+                // Store tracking info
+                this.trackingInfo.set(normalizedName, tracking);
+            }
+        }
+        // Build the branch object first (for dryRun)
+        const branch = {
+            name: normalizedName,
+            ref: branchRef,
+            sha,
+            isCurrent,
+            isRemote: false,
+            tracking
+        };
+        // If dryRun, return without actually creating
+        if (options?.dryRun) {
+            return branch;
+        }
+        // Create the ref
+        await this.storage.updateRef(branchRef, sha, { create: true, force: options?.force });
+        return branch;
     }
     /**
      * Delete a branch.
@@ -156,9 +227,45 @@ export class BranchManager {
      * await manager.deleteBranch('experiment', { force: true })
      * ```
      */
-    async deleteBranch(_name, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async deleteBranch(name, options) {
+        const normalizedName = normalizeBranchName(name);
+        // Handle remote branch deletion
+        if (options?.remote) {
+            const remoteRef = `refs/remotes/${options.remote}/${normalizedName}`;
+            const remoteExists = await this.storage.getRef(remoteRef);
+            if (remoteExists) {
+                if (!options?.dryRun) {
+                    await this.storage.deleteRef(remoteRef);
+                }
+            }
+            return;
+        }
+        const branchRef = getBranchRefName(normalizedName);
+        // Check if branch exists
+        const existing = await this.storage.getRef(branchRef);
+        if (!existing) {
+            throw new BranchError(`Branch '${name}' not found`, 'NOT_FOUND', name);
+        }
+        // Check if this is the current branch
+        const currentBranch = await this.getCurrentBranch();
+        if (currentBranch && currentBranch.name === normalizedName) {
+            throw new BranchError(`Cannot delete the checked out branch '${name}'`, 'CANNOT_DELETE_CURRENT', name);
+        }
+        // Check if branch is fully merged (unless force is true)
+        if (!options?.force) {
+            const isMerged = await this.isMerged(normalizedName);
+            if (!isMerged) {
+                throw new BranchError(`Branch '${name}' is not fully merged. Use force to delete anyway.`, 'NOT_FULLY_MERGED', name);
+            }
+        }
+        // If dryRun, return without actually deleting
+        if (options?.dryRun) {
+            return;
+        }
+        // Delete the ref
+        await this.storage.deleteRef(branchRef);
+        // Remove tracking info
+        this.trackingInfo.delete(normalizedName);
     }
     /**
      * Rename a branch.
@@ -180,9 +287,62 @@ export class BranchManager {
      * const branch = await manager.renameBranch('old-name', 'new-name')
      * ```
      */
-    async renameBranch(_oldName, _newName, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async renameBranch(oldName, newName, options) {
+        // Validate new branch name
+        const validation = validateBranchName(newName);
+        if (!validation.valid) {
+            throw new BranchError(validation.error, 'INVALID_NAME', newName);
+        }
+        const oldNormalized = normalizeBranchName(oldName);
+        const newNormalized = normalizeBranchName(newName);
+        const oldRef = getBranchRefName(oldNormalized);
+        const newRef = getBranchRefName(newNormalized);
+        // Check if old branch exists
+        const oldBranch = await this.storage.getRef(oldRef);
+        if (!oldBranch) {
+            throw new BranchError(`Branch '${oldName}' not found`, 'NOT_FOUND', oldName);
+        }
+        // Check if new branch already exists (unless force)
+        if (!options?.force) {
+            const existingNew = await this.storage.getRef(newRef);
+            if (existingNew) {
+                throw new BranchError(`Branch '${newName}' already exists`, 'ALREADY_EXISTS', newName);
+            }
+        }
+        // Get the SHA from old branch
+        const sha = oldBranch.target;
+        // Check if this is the current branch
+        const currentBranch = await this.getCurrentBranch();
+        const wasCurrent = currentBranch && currentBranch.name === oldNormalized;
+        // Get tracking info from old branch
+        const oldTracking = this.trackingInfo.get(oldNormalized);
+        // Build result branch object
+        const branch = {
+            name: newNormalized,
+            ref: newRef,
+            sha,
+            isCurrent: wasCurrent ?? false,
+            isRemote: false,
+            tracking: oldTracking
+        };
+        // If dryRun, return without actually renaming
+        if (options?.dryRun) {
+            return branch;
+        }
+        // Create new ref with the same SHA
+        await this.storage.updateRef(newRef, sha, { create: true, force: options?.force });
+        // Delete old ref
+        await this.storage.deleteRef(oldRef);
+        // If this was the current branch, update HEAD to point to new branch
+        if (wasCurrent) {
+            await this.storage.updateHead(newRef, true);
+        }
+        // Transfer tracking info
+        if (oldTracking) {
+            this.trackingInfo.delete(oldNormalized);
+            this.trackingInfo.set(newNormalized, oldTracking);
+        }
+        return branch;
     }
     /**
      * List all branches.
@@ -206,9 +366,46 @@ export class BranchManager {
      * const merged = await manager.listBranches({ mergedInto: 'main' })
      * ```
      */
-    async listBranches(_options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async listBranches(options) {
+        const branches = [];
+        // Get current branch for isCurrent flag
+        const currentBranch = await this.getCurrentBranch();
+        // List local branches
+        if (!options?.remotesOnly) {
+            const localRefs = await this.storage.listRefs({ pattern: 'refs/heads/*' });
+            for (const ref of localRefs) {
+                const name = normalizeBranchName(ref.name);
+                // Apply pattern filter if specified
+                if (options?.pattern) {
+                    const regex = new RegExp('^' + options.pattern.replace(/\*/g, '.*') + '$');
+                    if (!regex.test(name))
+                        continue;
+                }
+                branches.push({
+                    name,
+                    ref: ref.name,
+                    sha: ref.target,
+                    isCurrent: currentBranch?.name === name,
+                    isRemote: false,
+                    tracking: options?.includeTracking ? this.trackingInfo.get(name) : undefined
+                });
+            }
+        }
+        // List remote branches if requested
+        if (options?.includeRemotes || options?.remotesOnly) {
+            const remoteRefs = await this.storage.listRefs({ pattern: 'refs/remotes/*' });
+            for (const ref of remoteRefs) {
+                const name = ref.name.replace(/^refs\/remotes\//, '');
+                branches.push({
+                    name,
+                    ref: ref.name,
+                    sha: ref.target,
+                    isCurrent: false,
+                    isRemote: true
+                });
+            }
+        }
+        return branches;
     }
     /**
      * Get the current branch.
@@ -229,8 +426,30 @@ export class BranchManager {
      * ```
      */
     async getCurrentBranch() {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+        const head = await this.storage.getRef('HEAD');
+        if (!head)
+            return null;
+        // If HEAD is direct (detached), there is no current branch
+        if (head.type === 'direct') {
+            return null;
+        }
+        // HEAD is symbolic, pointing to a branch
+        const branchRef = head.target;
+        if (!branchRef.startsWith('refs/heads/')) {
+            return null;
+        }
+        const ref = await this.storage.getRef(branchRef);
+        if (!ref)
+            return null;
+        const name = normalizeBranchName(branchRef);
+        return {
+            name,
+            ref: branchRef,
+            sha: ref.target,
+            isCurrent: true,
+            isRemote: false,
+            tracking: this.trackingInfo.get(name)
+        };
     }
     /**
      * Get a specific branch by name.
@@ -249,9 +468,21 @@ export class BranchManager {
      * }
      * ```
      */
-    async getBranch(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async getBranch(name) {
+        const normalizedName = normalizeBranchName(name);
+        const branchRef = getBranchRefName(normalizedName);
+        const ref = await this.storage.getRef(branchRef);
+        if (!ref)
+            return null;
+        const currentBranch = await this.getCurrentBranch();
+        return {
+            name: normalizedName,
+            ref: branchRef,
+            sha: ref.target,
+            isCurrent: currentBranch?.name === normalizedName,
+            isRemote: false,
+            tracking: this.trackingInfo.get(normalizedName)
+        };
     }
     /**
      * Check if a branch exists.
@@ -269,9 +500,22 @@ export class BranchManager {
      * }
      * ```
      */
-    async branchExists(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async branchExists(name) {
+        // Handle remote branch names like 'origin/main'
+        if (name.includes('/') && !name.startsWith('refs/')) {
+            const parts = name.split('/');
+            if (parts.length >= 2) {
+                // Check if it's a remote reference
+                const remoteRef = `refs/remotes/${name}`;
+                const remoteExists = await this.storage.getRef(remoteRef);
+                if (remoteExists)
+                    return true;
+            }
+        }
+        const normalizedName = normalizeBranchName(name);
+        const branchRef = getBranchRefName(normalizedName);
+        const ref = await this.storage.getRef(branchRef);
+        return ref !== null;
     }
     /**
      * Set upstream branch for tracking.
@@ -295,9 +539,31 @@ export class BranchManager {
      * await manager.setUpstream('feature', { unset: true })
      * ```
      */
-    async setUpstream(_branchName, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async setUpstream(branchName, options) {
+        const normalizedName = normalizeBranchName(branchName);
+        const branchRef = getBranchRefName(normalizedName);
+        // Check if branch exists
+        const existing = await this.storage.getRef(branchRef);
+        if (!existing) {
+            throw new BranchError(`Branch '${branchName}' not found`, 'NOT_FOUND', branchName);
+        }
+        // If unset, remove tracking info
+        if (options.unset) {
+            this.trackingInfo.delete(normalizedName);
+            return;
+        }
+        // Build the remote branch ref
+        const remote = options.remote || 'origin';
+        const remoteBranchName = options.remoteBranch || normalizedName;
+        const remoteBranch = `refs/remotes/${remote}/${remoteBranchName}`;
+        const tracking = {
+            remote,
+            remoteBranch,
+            ahead: 0,
+            behind: 0,
+            gone: false
+        };
+        this.trackingInfo.set(normalizedName, tracking);
     }
     /**
      * Get tracking info for a branch.
@@ -316,9 +582,9 @@ export class BranchManager {
      * }
      * ```
      */
-    async getTrackingInfo(_branchName) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async getTrackingInfo(branchName) {
+        const normalizedName = normalizeBranchName(branchName);
+        return this.trackingInfo.get(normalizedName) ?? null;
     }
     /**
      * Check if a branch is fully merged into another branch.
@@ -337,9 +603,35 @@ export class BranchManager {
      * }
      * ```
      */
-    async isMerged(_branchName, _into) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async isMerged(branchName, into) {
+        const normalizedName = normalizeBranchName(branchName);
+        const branchRef = getBranchRefName(normalizedName);
+        // Get the branch SHA
+        const branchSha = await this.storage.getRef(branchRef);
+        if (!branchSha) {
+            throw new BranchError(`Branch '${branchName}' not found`, 'NOT_FOUND', branchName);
+        }
+        // Get the target branch SHA
+        let targetSha;
+        if (into) {
+            const targetRef = getBranchRefName(normalizeBranchName(into));
+            const resolved = await this.storage.getRef(targetRef);
+            if (!resolved) {
+                throw new BranchError(`Branch '${into}' not found`, 'NOT_FOUND', into);
+            }
+            targetSha = resolved.target;
+        }
+        else {
+            // Use current branch
+            const current = await this.getCurrentBranch();
+            if (!current) {
+                throw new BranchError('No current branch', 'DETACHED_HEAD');
+            }
+            targetSha = current.sha;
+        }
+        // Simple check: if the branch points to the same SHA as target, it's merged
+        // For a more accurate check, we'd need to walk the commit graph
+        return branchSha.target === targetSha;
     }
     /**
      * Force delete an unmerged branch.
@@ -357,9 +649,8 @@ export class BranchManager {
      * await manager.forceDeleteBranch('abandoned-feature')
      * ```
      */
-    async forceDeleteBranch(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async forceDeleteBranch(name) {
+        return this.deleteBranch(name, { force: true });
     }
 }
 // ============================================================================
@@ -372,8 +663,6 @@ export class BranchManager {
  * Checks if a branch name is valid and returns detailed validation results
  * including the normalized form of the name.
  *
- * Note: This is a stub implementation. Full validation will be added in GREEN phase.
- *
  * @param name - Branch name to validate
  * @returns Validation result with valid flag, error message, and normalized name
  *
@@ -389,9 +678,44 @@ export class BranchManager {
  * }
  * ```
  */
-export function validateBranchName(_name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function validateBranchName(name) {
+    // Empty name is invalid
+    if (!name || name.length === 0) {
+        return { valid: false, error: 'Branch name cannot be empty' };
+    }
+    // HEAD is not a valid branch name
+    if (name === 'HEAD') {
+        return { valid: false, error: 'HEAD is not a valid branch name' };
+    }
+    // Cannot start with dash
+    if (name.startsWith('-')) {
+        return { valid: false, error: 'Branch name cannot start with a dash' };
+    }
+    // Cannot contain spaces
+    if (name.includes(' ')) {
+        return { valid: false, error: 'Branch name cannot contain spaces' };
+    }
+    // Cannot contain double dots
+    if (name.includes('..')) {
+        return { valid: false, error: 'Branch name cannot contain double dots (..)' };
+    }
+    // Cannot end with .lock
+    if (name.endsWith('.lock')) {
+        return { valid: false, error: 'Branch name cannot end with .lock' };
+    }
+    // Cannot contain control characters (ASCII 0-31, 127)
+    const controlCharRegex = /[\x00-\x1f\x7f]/;
+    if (controlCharRegex.test(name)) {
+        return { valid: false, error: 'Branch name cannot contain control characters' };
+    }
+    // Cannot contain ~, ^, :, ?, *, [, ], \
+    const invalidChars = /[~^:?*[\]\\]/;
+    if (invalidChars.test(name)) {
+        return { valid: false, error: 'Branch name contains invalid characters (~, ^, :, ?, *, [, ], \\)' };
+    }
+    // Normalize the name (strip refs/heads/ if present)
+    const normalized = normalizeBranchName(name);
+    return { valid: true, normalized };
 }
 /**
  * Check if a string is a valid branch name.
@@ -409,9 +733,8 @@ export function validateBranchName(_name) {
  * }
  * ```
  */
-export function isValidBranchName(_name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function isValidBranchName(name) {
+    return validateBranchName(name).valid;
 }
 /**
  * Normalize a branch name.
@@ -428,9 +751,11 @@ export function isValidBranchName(_name) {
  * normalizeBranchName('main')              // 'main'
  * ```
  */
-export function normalizeBranchName(_name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function normalizeBranchName(name) {
+    if (name.startsWith('refs/heads/')) {
+        return name.slice('refs/heads/'.length);
+    }
+    return name;
 }
 /**
  * Get the full ref name for a branch.
@@ -447,9 +772,11 @@ export function normalizeBranchName(_name) {
  * getBranchRefName('refs/heads/main') // 'refs/heads/main'
  * ```
  */
-export function getBranchRefName(_name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function getBranchRefName(name) {
+    if (name.startsWith('refs/heads/')) {
+        return name;
+    }
+    return `refs/heads/${name}`;
 }
 // ============================================================================
 // Convenience Functions
@@ -470,9 +797,9 @@ export function getBranchRefName(_name) {
  * const branch = await createBranch(storage, 'feature', { startPoint: 'main' })
  * ```
  */
-export async function createBranch(_storage, _name, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function createBranch(storage, name, options) {
+    const manager = new BranchManager(storage);
+    return manager.createBranch(name, options);
 }
 /**
  * Delete a branch.
@@ -489,9 +816,9 @@ export async function createBranch(_storage, _name, _options) {
  * await deleteBranch(storage, 'feature', { force: true })
  * ```
  */
-export async function deleteBranch(_storage, _name, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function deleteBranch(storage, name, options) {
+    const manager = new BranchManager(storage);
+    return manager.deleteBranch(name, options);
 }
 /**
  * Rename a branch.
@@ -510,9 +837,9 @@ export async function deleteBranch(_storage, _name, _options) {
  * const branch = await renameBranch(storage, 'old', 'new')
  * ```
  */
-export async function renameBranch(_storage, _oldName, _newName, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function renameBranch(storage, oldName, newName, options) {
+    const manager = new BranchManager(storage);
+    return manager.renameBranch(oldName, newName, options);
 }
 /**
  * List all branches.
@@ -529,9 +856,9 @@ export async function renameBranch(_storage, _oldName, _newName, _options) {
  * const branches = await listBranches(storage, { includeRemotes: true })
  * ```
  */
-export async function listBranches(_storage, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function listBranches(storage, options) {
+    const manager = new BranchManager(storage);
+    return manager.listBranches(options);
 }
 /**
  * Get the current branch.
@@ -547,8 +874,8 @@ export async function listBranches(_storage, _options) {
  * const current = await getCurrentBranch(storage)
  * ```
  */
-export async function getCurrentBranch(_storage) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function getCurrentBranch(storage) {
+    const manager = new BranchManager(storage);
+    return manager.getCurrentBranch();
 }
 //# sourceMappingURL=branch.js.map