@ibgib/vcs-gib 0.0.30 → 0.0.33

package/src/cli/commands/branch-checkout-cmd.respec.mts

@@ -8,111 +8,114 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 
 import {
-    respecfully, ifWe, iReckon,
-    ifWeMight
+    respecfully, ifWe, iReckon, ifWeMight, // don't remove ifWe/ifWeMight even if unused
 } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
 
-import { executeInitCmd } from './init-cmd.mjs';
-import { executeAddCmd } from './add-cmd.mjs';
-import { executeCommitCmd } from './commit-cmd.mjs';
-import { executeBranchCmd } from './branch-cmd.mjs';
-import { executeCheckoutCmd } from './checkout-cmd.mjs';
-import { executeMergeCmd } from './merge-cmd.mjs';
-import { executeStatusCmd } from './status-cmd.mjs';
-import { executeLogCmd } from './log-cmd.mjs';
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+
+import { executeInitCmd } from './cli-init-cmd.mjs';
+import { executeAddCmd } from './cli-add-cmd.mjs';
+import { executeCommitCmd } from './cli-commit-cmd.mjs';
+import { executeBranchCmd } from './cli-branch-cmd.mjs';
+import { executeCheckoutCmd } from './cli-checkout-cmd.mjs';
+import { executeMergeCmd } from './cli-merge-cmd.mjs';
+import { executeStatusCmd } from './cli-status-cmd.mjs';
+import { executeLogCmd } from './cli-log-cmd.mjs';
 import { logCheckpoint } from '../../test/test-helpers.mjs';
 
-const lc = `[apps/vcs-gib/src/cli/commands/branch-checkout-cmd.respec.node.mts]`;
+const lc = `[apps/vcs-gib/src/cli/commands/branch-checkout-cmd.respec.mts]`;
 
 await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async () => {
 
-    await ifWe(lc, `lists default branch main for new repository`, async () => {
-        const testDir = path.join(process.cwd(), '.test_branch_checkout_1');
-        const vcsFolderName = '.vcsgib_test_bc_1';
-        try {
-            await executeInitCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            const branchRes = await executeBranchCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            iReckon(lc, branchRes.branches.length).willEqual(1);
-            iReckon(lc, branchRes.branches[0].name).willEqual('main');
-            iReckon(lc, branchRes.branches[0].isActive).isGonnaBeTrue();
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
-
-    await ifWe(lc, `creates new branch from active branch root item and rejects duplicates`, async () => {
-        const testDir = path.join(process.cwd(), '.test_branch_checkout_2');
-        const vcsFolderName = '.vcsgib_test_bc_2';
-        try {
-            await executeInitCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // Create feature branch
-            const createRes = await executeBranchCmd({
-                branchName: 'feature-auth',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            iReckon(lc, createRes.createdBranchName).willEqual('feature-auth');
-            iReckon(lc, Boolean(createRes.createdBranchAddr)).isGonnaBeTrue();
-
-            // List branches
-            const listRes = await executeBranchCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            iReckon(lc, listRes.branches.length).willEqual(2);
-            const featureBranch = listRes.branches.find(b => b.name === 'feature-auth');
-            iReckon(lc, Boolean(featureBranch)).isGonnaBeTrue();
-            iReckon(lc, featureBranch?.isActive).isGonnaBeFalse();
-
-            // Verify dedicated branch space subfolders exist in .vcsgib
-            const mainSpaceDir = path.join(testDir, vcsFolderName, 'ibgib', 'b2s_main');
-            const featureSpaceDir = path.join(testDir, vcsFolderName, 'ibgib', 'b2s_feature-auth');
-            const mainSpaceExists = await fs.stat(mainSpaceDir).then(s => s.isDirectory()).catch(() =>
-                fs.stat(path.join(testDir, vcsFolderName, 'b2s_main')).then(s => s.isDirectory()).catch(() => false)
-            );
-            const featureSpaceExists = await fs.stat(featureSpaceDir).then(s => s.isDirectory()).catch(() =>
-                fs.stat(path.join(testDir, vcsFolderName, 'b2s_feature-auth')).then(s => s.isDirectory()).catch(() => false)
-            );
-            iReckon(lc, mainSpaceExists).isGonnaBeTrue();
-            iReckon(lc, featureSpaceExists).isGonnaBeTrue();
-
-            // Duplicate branch attempt
-            let errorThrown = false;
-            try {
-                await executeBranchCmd({
-                    branchName: 'feature-auth',
-                    targetDir: testDir,
-                    vcsFolderName,
-                    quiet: true,
-                });
-            } catch (err: any) {
-                errorThrown = true;
-                iReckon(lc, err.message).includes("already exists");
-            }
-            iReckon(lc, errorThrown).isGonnaBeTrue();
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
+    // await ifWe(lc, `lists default branch main for new repository`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_branch_checkout_1');
+    //     const vcsFolderName = '.vcsgib_test_bc_1';
+    //     try {
+    //         await executeInitCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         const branchRes = await executeBranchCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         iReckon(lc, branchRes.branches.length).willEqual(1);
+    //         iReckon(lc, branchRes.branches[0].name).willEqual('main');
+    //         iReckon(lc, branchRes.branches[0].isActive).isGonnaBeTrue();
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
+
+    // await ifWe(lc, `creates new branch from active branch root item and rejects duplicates`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_branch_checkout_2');
+    //     const vcsFolderName = '.vcsgib_test_bc_2';
+    //     try {
+    //         await executeInitCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // Create feature branch
+    //         debugger; // walk through branch exec
+    //         const createRes = await executeBranchCmd({
+    //             branchName: 'feature-auth',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         iReckon(lc, createRes.createdBranchName).willEqual('feature-auth');
+    //         iReckon(lc, Boolean(createRes.createdBranchAddr)).isGonnaBeTrue();
+
+    //         // List branches
+    //         const listRes = await executeBranchCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         console.dir(listRes)
+
+    //         iReckon(lc, listRes.branches.length).willEqual(2);
+    //         const featureBranch = listRes.branches.find(b => b.name === 'feature-auth');
+    //         iReckon(lc, Boolean(featureBranch)).isGonnaBeTrue();
+    //         iReckon(lc, featureBranch?.isActive).isGonnaBeFalse();
+
+    //         // Verify dedicated branch space subfolders exist in .vcsgib
+    //         const mainSpaceDir = path.join(testDir, vcsFolderName, 'ibgib', 'b2s_main');
+    //         const featureSpaceDir = path.join(testDir, vcsFolderName, 'ibgib', 'b2s_feature-auth');
+    //         const mainSpaceExists = await fs.stat(mainSpaceDir).then(s => s.isDirectory()).catch(() =>
+    //             fs.stat(path.join(testDir, vcsFolderName, 'b2s_main')).then(s => s.isDirectory()).catch(() => false)
+    //         );
+    //         const featureSpaceExists = await fs.stat(featureSpaceDir).then(s => s.isDirectory()).catch(() =>
+    //             fs.stat(path.join(testDir, vcsFolderName, 'b2s_feature-auth')).then(s => s.isDirectory()).catch(() => false)
+    //         );
+    //         iReckon(lc, mainSpaceExists).isGonnaBeTrue();
+    //         iReckon(lc, featureSpaceExists).isGonnaBeTrue();
+
+    //         // Duplicate branch attempt
+    //         let errorThrown = false;
+    //         try {
+    //             await executeBranchCmd({
+    //                 branchName: 'feature-auth',
+    //                 targetDir: testDir,
+    //                 vcsFolderName,
+    //                 quiet: true,
+    //             });
+    //         } catch (err: any) {
+    //             errorThrown = true;
+    //             iReckon(lc, err.message).includes("already exists");
+    //         }
+    //         iReckon(lc, errorThrown).isGonnaBeTrue();
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
 
     await ifWe(lc, `switches active branch with checkout and projects branch snapshot onto worktree subfolder`, async () => {
         const testDir = path.join(process.cwd(), '.test_branch_checkout_3');
@@ -147,6 +150,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
                 quiet: true,
             });
 
+            debugger; // 3
             // Checkout feature-ui
             const checkoutRes = await executeCheckoutCmd({
                 branchName: 'feature-ui',
@@ -166,6 +170,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
             const fileContent = await fs.readFile(projectedFile, 'utf8');
             iReckon(lc, fileContent).willEqual('console.log("Main");');
 
+            debugger; // 4
             // Verify active branch in status
             const statusRes = await executeStatusCmd({
                 targetDir: testDir,
@@ -174,6 +179,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
             });
             iReckon(lc, statusRes.branchName).willEqual('feature-ui');
 
+            debugger; // 5
             // Verify branch list displays ALL branches while on feature-ui
             const branchListOnFeature = await executeBranchCmd({
                 targetDir: testDir,
@@ -184,6 +190,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
             iReckon(lc, branchListOnFeature.branches.map(b => b.name)).includes('main');
             iReckon(lc, branchListOnFeature.branches.map(b => b.name)).includes('feature-ui');
 
+            debugger; // 6
             // Make a commit on feature-ui branch
             await fs.writeFile(path.join(expectedWorktree, 'ui.ts'), 'export const ui = 1;', 'utf8');
             await executeAddCmd({
@@ -192,6 +199,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
                 vcsFolderName,
                 quiet: true,
             });
+            debugger; // 7
             await executeCommitCmd({
                 message: 'Add ui.ts on feature-ui',
                 targetDir: expectedWorktree,
@@ -199,6 +207,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
                 quiet: true,
             });
 
+            debugger; // 8
             // Verify branch list after commit on feature-ui still displays ALL branches
             const branchListAfterCommit = await executeBranchCmd({
                 targetDir: expectedWorktree,
@@ -207,6 +216,7 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
             });
             iReckon(lc, branchListAfterCommit.branches.length).willEqual(2);
 
+            debugger; // 9
             // Switch back to main
             const switchBackRes = await executeCheckoutCmd({
                 branchName: 'main',
@@ -217,6 +227,8 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
             iReckon(lc, switchBackRes.currentBranch).willEqual('main');
             iReckon(lc, switchBackRes.worktreePath).willEqual(testDir);
 
+            debugger; // 10
+
             // Verify branch list displays ALL branches while on main after feature-ui commit
             const branchListOnMain = await executeBranchCmd({
                 targetDir: testDir,
@@ -235,325 +247,327 @@ await respecfully(lc, `vcs branch, checkout, and merge Command Handlers`, async
                 quiet: true,
             });
             iReckon(lc, switchAgainRes.currentBranch).willEqual('feature-ui');
+        } catch (error) {
+            iReckon(lc, true).asTo(extractErrorMsg(error)).isGonnaBeFalse();
         } finally {
             await fs.rm(testDir, { recursive: true, force: true });
         }
     });
 
-    await ifWe(lc, `rejects checkout when branch does not exist or branchName missing`, async () => {
-        const testDir = path.join(process.cwd(), '.test_branch_checkout_4');
-        const vcsFolderName = '.vcsgib_test_bc_4';
-        try {
-            await executeInitCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            let err1 = false;
-            try {
-                await executeCheckoutCmd({
-                    branchName: '',
-                    targetDir: testDir,
-                    vcsFolderName,
-                    quiet: true,
-                });
-            } catch (err: any) {
-                err1 = true;
-                iReckon(lc, err.message).includes('Branch name is required');
-            }
-            iReckon(lc, err1).isGonnaBeTrue();
-
-            let err2 = false;
-            try {
-                await executeCheckoutCmd({
-                    branchName: 'non-existent-branch',
-                    targetDir: testDir,
-                    vcsFolderName,
-                    quiet: true,
-                });
-            } catch (err: any) {
-                err2 = true;
-                iReckon(lc, err.message).includes("does not exist");
-            }
-            iReckon(lc, err2).isGonnaBeTrue();
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
-
-    await ifWe(lc, `lists branches silently on secondary branch without error noise`, async () => {
-        const testDir = path.join(process.cwd(), '.test_branch_checkout_secondary');
-        const vcsFolderName = '.vcsgib_test_bc_sec';
-        try {
-            await executeInitCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // Create and checkout secondary branch feature-math
-            await executeBranchCmd({
-                branchName: 'feature-math',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            await executeCheckoutCmd({
-                branchName: 'feature-math',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // Run branch list while on secondary branch
-            const listRes = await executeBranchCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            iReckon(lc, listRes.branches.length).willEqual(2);
-            const mathBranch = listRes.branches.find(b => b.name === 'feature-math');
-            const mainBranch = listRes.branches.find(b => b.name === 'main');
-            iReckon(lc, mathBranch?.isActive).isGonnaBeTrue();
-            iReckon(lc, mainBranch?.isActive).isGonnaBeFalse();
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
-
-    await ifWe(lc, `branches single file-root item and projects into file-branch worktree on checkout`, async () => {
-        const testDir = path.join(process.cwd(), '.test_branch_checkout_file_root');
-        const vcsFolderName = '.vcsgib_test_bc_file';
-        try {
-            await executeInitCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // Create nested file structure src/utils/math.js and commit on main
-            const mathRelPath = 'src/utils/math.js';
-            await fs.mkdir(path.join(testDir, 'src', 'utils'), { recursive: true });
-            await fs.writeFile(path.join(testDir, mathRelPath), 'export function add(a, b) { return a + b; }', 'utf8');
-
-            await executeAddCmd({
-                paths: [mathRelPath],
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            await executeCommitCmd({
-                message: 'Add math.js',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // Execute branch command for single file math-opt targeting src/utils/math.js
-            const branchRes = await executeBranchCmd({
-                branchName: 'math-opt',
-                itemPath: mathRelPath,
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            iReckon(lc, branchRes.createdBranchName).willEqual('math-opt');
-
-            // Attempt branching uncommitted/non-existent item
-            let uncommittedErr = false;
-            try {
-                await executeBranchCmd({
-                    branchName: 'invalid-file-branch',
-                    itemPath: 'src/utils/non-existent.js',
-                    targetDir: testDir,
-                    vcsFolderName,
-                    quiet: true,
-                });
-            } catch (err: any) {
-                uncommittedErr = true;
-                iReckon(lc, err.message).includes("not found in active branch snapshot");
-            }
-            iReckon(lc, uncommittedErr).isGonnaBeTrue();
-
-            // Execute checkout command for math-opt
-            const checkoutRes = await executeCheckoutCmd({
-                branchName: 'math-opt',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            const expectedWorktree = path.join(testDir, 'b', 'math-opt');
-            iReckon(lc, checkoutRes.worktreePath).willEqual(expectedWorktree);
-
-            // Verify single file projected at expectedWorktree/math.js (my-repo/b/math-opt/math.js)
-            const projectedFilePath = path.join(expectedWorktree, 'math.js');
-            const fileExists = await fs.stat(projectedFilePath).then(s => s.isFile()).catch(() => false);
-            iReckon(lc, fileExists).isGonnaBeTrue();
-
-            const fileContent = await fs.readFile(projectedFilePath, 'utf8');
-            iReckon(lc, fileContent).willEqual('export function add(a, b) { return a + b; }');
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
-
-    await ifWe(lc, `performs vcs merge end-to-end between main and secondary branch`, async () => {
-        const testDir = path.join(process.cwd(), '.test_vcs_merge_e2e');
-        const vcsFolderName = '.vcsgib_test_merge_e2e';
-        try {
-            await executeInitCmd({
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // 1. Initial commit on main
-            const initialContent = "line 1\nline 2\nline 3";
-            await fs.writeFile(path.join(testDir, 'app.ts'), initialContent, 'utf8');
-            await executeAddCmd({
-                paths: [path.join(testDir, 'app.ts')],
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            await executeCommitCmd({
-                message: 'Initial commit on main',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // 2. Create secondary branch feature-merge
-            await executeBranchCmd({
-                branchName: 'feature-merge',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // 3. Checkout feature-merge branch and make a commit (modify line 3)
-            await executeCheckoutCmd({
-                branchName: 'feature-merge',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            const featureWorktree = path.join(testDir, 'b', 'feature-merge');
-            const featureContent = "line 1\nline 2\nline 3 modified by secondary";
-            await fs.writeFile(path.join(featureWorktree, 'app.ts'), featureContent, 'utf8');
-            await executeAddCmd({
-                paths: [path.join(featureWorktree, 'app.ts')],
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            await executeCommitCmd({
-                message: 'Update app.ts on feature-merge',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // 4. Checkout main branch and make a commit (modify line 1)
-            await executeCheckoutCmd({
-                branchName: 'main',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            const mainContent = "line 1 modified by main\nline 2\nline 3";
-            await fs.writeFile(path.join(testDir, 'app.ts'), mainContent, 'utf8');
-            await executeAddCmd({
-                paths: [path.join(testDir, 'app.ts')],
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            await executeCommitCmd({
-                message: 'Update app.ts on main',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            // 5. Execute vcs merge feature-merge into main
-            const mergeRes = await executeMergeCmd({
-                incomingBranchName: 'feature-merge',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-
-            iReckon(lc, mergeRes.baseBranch).willEqual('main');
-            iReckon(lc, mergeRes.incomingBranch).willEqual('feature-merge');
-
-            // 6. Verify projected file on physical worktree disk contains merged lines
-            const mergedAppTs = await fs.readFile(path.join(testDir, 'app.ts'), 'utf8');
-            iReckon(lc, mergedAppTs).includes('line 1 modified by main');
-            iReckon(lc, mergedAppTs).includes('line 2');
-            iReckon(lc, mergedAppTs).includes('line 3 modified by secondary');
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
-
-    await ifWe(lc, `resolves contextual branch for log and status inside secondary branch worktree`, async () => {
-        const testDir = path.join(process.cwd(), '.test_contextual_worktree_branch');
-        const vcsFolderName = '.vcsgib_test_cwb';
-        try {
-            await executeInitCmd({ targetDir: testDir, vcsFolderName, quiet: true });
-
-            await fs.writeFile(path.join(testDir, 'app.ts'), 'console.log("main");\n', 'utf8');
-            await executeAddCmd({ paths: [path.join(testDir, 'app.ts')], targetDir: testDir, vcsFolderName, quiet: true });
-            await executeCommitCmd({ message: 'Main initial commit', targetDir: testDir, vcsFolderName, quiet: true });
-
-            // Create and switch to feature branch
-            await executeBranchCmd({
-                branchName: 'feature-calc',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            const checkoutRes = await executeCheckoutCmd({
-                branchName: 'feature-calc',
-                targetDir: testDir,
-                vcsFolderName,
-                quiet: true,
-            });
-            const featureWorktree = checkoutRes.worktreePath;
-            iReckon(lc, featureWorktree).isGonnaBeTruthy();
-
-            // Commit on feature branch inside worktree
-            await fs.writeFile(path.join(featureWorktree!, 'calc.ts'), 'export const add = (a, b) => a + b;\n', 'utf8');
-            await executeAddCmd({ paths: [path.join(featureWorktree!, 'calc.ts')], targetDir: featureWorktree!, vcsFolderName, quiet: true });
-            await executeCommitCmd({ message: 'Add calc on feature-calc', targetDir: featureWorktree!, vcsFolderName, quiet: true });
-
-            // Checkout main again so index.activeBranch is 'main'
-            await executeCheckoutCmd({ branchName: 'main', targetDir: testDir, vcsFolderName, quiet: true });
-
-            // Now query log from inside featureWorktree
-            const featureLogRes = await executeLogCmd({ targetDir: featureWorktree!, vcsFolderName, quiet: true });
-            iReckon(lc, featureLogRes.branchName).willEqual('feature-calc');
-            const featureMessages = featureLogRes.commits.map(c => c.message);
-            iReckon(lc, featureMessages.some(m => m.includes('Add calc on feature-calc'))).isGonnaBeTrue();
-
-            // Query status from inside featureWorktree
-            const featureStatusRes = await executeStatusCmd({ targetDir: featureWorktree!, vcsFolderName, quiet: true });
-            iReckon(lc, featureStatusRes.branchName).willEqual('feature-calc');
-
-            // Query log from main repoRoot
-            const mainLogRes = await executeLogCmd({ targetDir: testDir, vcsFolderName, quiet: true });
-            iReckon(lc, mainLogRes.branchName).willEqual('main');
-        } finally {
-            await fs.rm(testDir, { recursive: true, force: true });
-        }
-    });
+    // await ifWe(lc, `rejects checkout when branch does not exist or branchName missing`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_branch_checkout_4');
+    //     const vcsFolderName = '.vcsgib_test_bc_4';
+    //     try {
+    //         await executeInitCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         let err1 = false;
+    //         try {
+    //             await executeCheckoutCmd({
+    //                 branchName: '',
+    //                 targetDir: testDir,
+    //                 vcsFolderName,
+    //                 quiet: true,
+    //             });
+    //         } catch (err: any) {
+    //             err1 = true;
+    //             iReckon(lc, err.message).includes('Branch name is required');
+    //         }
+    //         iReckon(lc, err1).isGonnaBeTrue();
+
+    //         let err2 = false;
+    //         try {
+    //             await executeCheckoutCmd({
+    //                 branchName: 'non-existent-branch',
+    //                 targetDir: testDir,
+    //                 vcsFolderName,
+    //                 quiet: true,
+    //             });
+    //         } catch (err: any) {
+    //             err2 = true;
+    //             iReckon(lc, err.message).includes("not found");
+    //         }
+    //         iReckon(lc, err2).isGonnaBeTrue();
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
+
+    // await ifWe(lc, `lists branches silently on secondary branch without error noise`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_branch_checkout_secondary');
+    //     const vcsFolderName = '.vcsgib_test_bc_sec';
+    //     try {
+    //         await executeInitCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // Create and checkout secondary branch feature-math
+    //         await executeBranchCmd({
+    //             branchName: 'feature-math',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         await executeCheckoutCmd({
+    //             branchName: 'feature-math',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // Run branch list while on secondary branch
+    //         const listRes = await executeBranchCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         iReckon(lc, listRes.branches.length).willEqual(2);
+    //         const mathBranch = listRes.branches.find(b => b.name === 'feature-math');
+    //         const mainBranch = listRes.branches.find(b => b.name === 'main');
+    //         iReckon(lc, mathBranch?.isActive).isGonnaBeTrue();
+    //         iReckon(lc, mainBranch?.isActive).isGonnaBeFalse();
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
+
+    // await ifWe(lc, `branches single file-root item and projects into file-branch worktree on checkout`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_branch_checkout_file_root');
+    //     const vcsFolderName = '.vcsgib_test_bc_file';
+    //     try {
+    //         await executeInitCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // Create nested file structure src/utils/math.js and commit on main
+    //         const mathRelPath = 'src/utils/math.js';
+    //         await fs.mkdir(path.join(testDir, 'src', 'utils'), { recursive: true });
+    //         await fs.writeFile(path.join(testDir, mathRelPath), 'export function add(a, b) { return a + b; }', 'utf8');
+
+    //         await executeAddCmd({
+    //             paths: [mathRelPath],
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         await executeCommitCmd({
+    //             message: 'Add math.js',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // Execute branch command for single file math-opt targeting src/utils/math.js
+    //         const branchRes = await executeBranchCmd({
+    //             branchName: 'math-opt',
+    //             itemPath: mathRelPath,
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         iReckon(lc, branchRes.createdBranchName).willEqual('math-opt');
+
+    //         // Attempt branching uncommitted/non-existent item
+    //         let uncommittedErr = false;
+    //         try {
+    //             await executeBranchCmd({
+    //                 branchName: 'invalid-file-branch',
+    //                 itemPath: 'src/utils/non-existent.js',
+    //                 targetDir: testDir,
+    //                 vcsFolderName,
+    //                 quiet: true,
+    //             });
+    //         } catch (err: any) {
+    //             uncommittedErr = true;
+    //             iReckon(lc, err.message).includes("not found in active branch snapshot");
+    //         }
+    //         iReckon(lc, uncommittedErr).isGonnaBeTrue();
+
+    //         // Execute checkout command for math-opt
+    //         const checkoutRes = await executeCheckoutCmd({
+    //             branchName: 'math-opt',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         const expectedWorktree = path.join(testDir, 'b', 'math-opt');
+    //         iReckon(lc, checkoutRes.worktreePath).willEqual(expectedWorktree);
+
+    //         // Verify single file projected at expectedWorktree/math.js (my-repo/b/math-opt/math.js)
+    //         const projectedFilePath = path.join(expectedWorktree, 'math.js');
+    //         const fileExists = await fs.stat(projectedFilePath).then(s => s.isFile()).catch(() => false);
+    //         iReckon(lc, fileExists).isGonnaBeTrue();
+
+    //         const fileContent = await fs.readFile(projectedFilePath, 'utf8');
+    //         iReckon(lc, fileContent).willEqual('export function add(a, b) { return a + b; }');
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
+
+    // await ifWe(lc, `performs vcs merge end-to-end between main and secondary branch`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_vcs_merge_e2e');
+    //     const vcsFolderName = '.vcsgib_test_merge_e2e';
+    //     try {
+    //         await executeInitCmd({
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // 1. Initial commit on main
+    //         const initialContent = "line 1\nline 2\nline 3";
+    //         await fs.writeFile(path.join(testDir, 'app.ts'), initialContent, 'utf8');
+    //         await executeAddCmd({
+    //             paths: [path.join(testDir, 'app.ts')],
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         await executeCommitCmd({
+    //             message: 'Initial commit on main',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // 2. Create secondary branch feature-merge
+    //         await executeBranchCmd({
+    //             branchName: 'feature-merge',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // 3. Checkout feature-merge branch and make a commit (modify line 3)
+    //         await executeCheckoutCmd({
+    //             branchName: 'feature-merge',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         const featureWorktree = path.join(testDir, 'b', 'feature-merge');
+    //         const featureContent = "line 1\nline 2\nline 3 modified by secondary";
+    //         await fs.writeFile(path.join(featureWorktree, 'app.ts'), featureContent, 'utf8');
+    //         await executeAddCmd({
+    //             paths: [path.join(featureWorktree, 'app.ts')],
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         await executeCommitCmd({
+    //             message: 'Update app.ts on feature-merge',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // 4. Checkout main branch and make a commit (modify line 1)
+    //         await executeCheckoutCmd({
+    //             branchName: 'main',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         const mainContent = "line 1 modified by main\nline 2\nline 3";
+    //         await fs.writeFile(path.join(testDir, 'app.ts'), mainContent, 'utf8');
+    //         await executeAddCmd({
+    //             paths: [path.join(testDir, 'app.ts')],
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         await executeCommitCmd({
+    //             message: 'Update app.ts on main',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         // 5. Execute vcs merge feature-merge into main
+    //         const mergeRes = await executeMergeCmd({
+    //             incomingBranchName: 'feature-merge',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+
+    //         iReckon(lc, mergeRes.baseBranch).willEqual('main');
+    //         iReckon(lc, mergeRes.incomingBranch).willEqual('feature-merge');
+
+    //         // 6. Verify projected file on physical worktree disk contains merged lines
+    //         const mergedAppTs = await fs.readFile(path.join(testDir, 'app.ts'), 'utf8');
+    //         iReckon(lc, mergedAppTs).includes('line 1 modified by main');
+    //         iReckon(lc, mergedAppTs).includes('line 2');
+    //         iReckon(lc, mergedAppTs).includes('line 3 modified by secondary');
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
+
+    // await ifWe(lc, `resolves contextual branch for log and status inside secondary branch worktree`, async () => {
+    //     const testDir = path.join(process.cwd(), '.test_contextual_worktree_branch');
+    //     const vcsFolderName = '.vcsgib_test_cwb';
+    //     try {
+    //         await executeInitCmd({ targetDir: testDir, vcsFolderName, quiet: true });
+
+    //         await fs.writeFile(path.join(testDir, 'app.ts'), 'console.log("main");\n', 'utf8');
+    //         await executeAddCmd({ paths: [path.join(testDir, 'app.ts')], targetDir: testDir, vcsFolderName, quiet: true });
+    //         await executeCommitCmd({ message: 'Main initial commit', targetDir: testDir, vcsFolderName, quiet: true });
+
+    //         // Create and switch to feature branch
+    //         await executeBranchCmd({
+    //             branchName: 'feature-calc',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         const checkoutRes = await executeCheckoutCmd({
+    //             branchName: 'feature-calc',
+    //             targetDir: testDir,
+    //             vcsFolderName,
+    //             quiet: true,
+    //         });
+    //         const featureWorktree = checkoutRes.worktreePath;
+    //         iReckon(lc, featureWorktree).isGonnaBeTruthy();
+
+    //         // Commit on feature branch inside worktree
+    //         await fs.writeFile(path.join(featureWorktree!, 'calc.ts'), 'export const add = (a, b) => a + b;\n', 'utf8');
+    //         await executeAddCmd({ paths: [path.join(featureWorktree!, 'calc.ts')], targetDir: featureWorktree!, vcsFolderName, quiet: true });
+    //         await executeCommitCmd({ message: 'Add calc on feature-calc', targetDir: featureWorktree!, vcsFolderName, quiet: true });
+
+    //         // Checkout main again so index.activeBranch is 'main'
+    //         await executeCheckoutCmd({ branchName: 'main', targetDir: testDir, vcsFolderName, quiet: true });
+
+    //         // Now query log from inside featureWorktree
+    //         const featureLogRes = await executeLogCmd({ targetDir: featureWorktree!, vcsFolderName, quiet: true });
+    //         iReckon(lc, featureLogRes.branchName).willEqual('feature-calc');
+    //         const featureMessages = featureLogRes.commits.map(c => c.message);
+    //         iReckon(lc, featureMessages.some(m => m.includes('Add calc on feature-calc'))).isGonnaBeTrue();
+
+    //         // Query status from inside featureWorktree
+    //         const featureStatusRes = await executeStatusCmd({ targetDir: featureWorktree!, vcsFolderName, quiet: true });
+    //         iReckon(lc, featureStatusRes.branchName).willEqual('feature-calc');
+
+    //         // Query log from main repoRoot
+    //         const mainLogRes = await executeLogCmd({ targetDir: testDir, vcsFolderName, quiet: true });
+    //         iReckon(lc, mainLogRes.branchName).willEqual('main');
+    //     } finally {
+    //         await fs.rm(testDir, { recursive: true, force: true });
+    //     }
+    // });
 });