@ibgib/vcs-gib 0.0.34 → 0.0.39

package/src/bootstrap/node-bootstrap.mts

@@ -37,6 +37,10 @@ export interface BootstrapVcsMetaspaceOpts {
      * Default space name for non-interactive headless testing. Defaults to 'vcs_space'
      */
     defaultSpaceName?: string;
+    /**
+     * If true, throws if .vcsgib is not found during upward discovery without initializing spaces.
+     */
+    mustExist?: boolean;
 }
 
 export interface BootstrapVcsMetaspaceResult {
@@ -44,6 +48,7 @@ export interface BootstrapVcsMetaspaceResult {
     localSpace: IbGibSpaceAny;
     vcsPath: string;
     repoRoot: string;
+    foundVcsPath?: string;
 }
 
 /**
@@ -94,6 +99,10 @@ export async function bootstrapVcsMetaspace(
             currentDir = parentDir;
         }
 
+        if (opts.mustExist && !foundVcsPath) {
+            throw new Error(`fatal: not an ibgib repository (or any of the parent directories): ${vcsFolderName}`);
+        }
+
         const vcsPath = foundVcsPath || path.resolve(repoPath, vcsFolderName);
         if (!foundVcsPath) {
             repoRoot = path.resolve(repoPath);
@@ -181,6 +190,7 @@ export async function bootstrapVcsMetaspace(
             localSpace,
             vcsPath,
             repoRoot,
+            foundVcsPath,
         };
     } catch (error: any) {
         console.error(`${lc} ${error?.message || error} (E: genuuid)`);

package/src/cli/cli-e2e.respec.mts

@@ -21,6 +21,7 @@ import { executeCommitCmd } from './commands/cli-commit-cmd.mjs';
 import { executeLogCmd } from './commands/cli-log-cmd.mjs';
 import { executeBranchCmd } from './commands/cli-branch-cmd.mjs';
 import { executeCheckoutCmd } from './commands/cli-checkout-cmd.mjs';
+import { executeMergeCmd } from './commands/cli-merge-cmd.mjs';
 import { bootstrapVcsMetaspace } from '../bootstrap/node-bootstrap.mjs';
 import { getB2tFSIndexIbGib } from '@ibgib/core-gib/dist/vcs/index/index-helper.mjs';
 
@@ -316,4 +317,154 @@ await respecfully(lc, `Full E2E CLI Integration Spec`, async () => {
         }
     });
 
+    await ifWe(lc, `fails gracefully with fatal error message on uninitialized repository`, async () => {
+        const uninitDir = path.join(process.cwd(), `.test_cli_e2e_uninit_${Date.now()}`);
+        await fs.mkdir(uninitDir, { recursive: true });
+
+        const origCwd = process.cwd();
+        const origError = console.error;
+        let capturedErrors: string[] = [];
+
+        console.error = (...args: any[]) => {
+            capturedErrors.push(args.join(' '));
+        };
+
+        try {
+            process.chdir(uninitDir);
+
+            // Execute status, commit, log, branch, checkout in uninitialized directory
+            const statusExitCode = await main({ argv: ['status'] });
+            iReckon(lc, statusExitCode).willEqual(1);
+
+            const commitExitCode = await main({ argv: ['commit', '-m', 'test'] });
+            iReckon(lc, commitExitCode).willEqual(1);
+
+            const logExitCode = await main({ argv: ['log'] });
+            iReckon(lc, logExitCode).willEqual(1);
+
+            const branchExitCode = await main({ argv: ['branch'] });
+            iReckon(lc, branchExitCode).willEqual(1);
+
+            const checkoutExitCode = await main({ argv: ['checkout', 'main'] });
+            iReckon(lc, checkoutExitCode).willEqual(1);
+
+            // Verify clean error messages without storage stack traces
+            const hasFatalMsg = capturedErrors.some(e => e.includes('fatal: not an ibgib repository'));
+            iReckon(lc, hasFatalMsg).isGonnaBeTrue();
+
+            const hasStorageError = capturedErrors.some(e => e.includes('couldn\'t get special'));
+            iReckon(lc, hasStorageError).isGonnaBeFalse();
+        } finally {
+            process.chdir(origCwd);
+            console.error = origError;
+            await fs.rm(uninitDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `preserves worktree state when checkout is executed from within secondary worktree`, async () => {
+        const testDir = path.join(process.cwd(), `.test_cli_e2e_worktree_${Date.now()}`);
+        const vcsFolderName = '.vcsgib';
+
+        const origCwd = process.cwd();
+
+        try {
+            process.chdir(testDir);
+        } catch {
+            await fs.mkdir(testDir, { recursive: true });
+            process.chdir(testDir);
+        }
+
+        try {
+            // 1. Init main repo
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'main.txt'), 'content on main\n', 'utf8');
+            await executeAddCmd({ targetDir: testDir, vcsFolderName, all: true, quiet: true });
+            await executeCommitCmd({ targetDir: testDir, vcsFolderName, message: 'Commit on main', quiet: true });
+
+            // 2. Create feature branch
+            await executeBranchCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                branchName: 'feature-strings',
+                quiet: true,
+            });
+
+            const worktreeDir = path.join(testDir, 'b', 'feature-strings');
+            await fs.mkdir(worktreeDir, { recursive: true });
+            const worktreeFile = path.join(worktreeDir, 'feature.txt');
+            await fs.writeFile(worktreeFile, 'content on feature branch\n', 'utf8');
+
+            // 3. Commit within secondary worktree
+            await executeAddCmd({ targetDir: worktreeDir, vcsFolderName, all: true, quiet: true });
+            await executeCommitCmd({ targetDir: worktreeDir, vcsFolderName, message: 'Commit on feature', quiet: true });
+
+            // 4. Run checkout main from within the secondary worktree directory
+            process.chdir(worktreeDir);
+            const checkoutRes = await executeCheckoutCmd({
+                targetDir: worktreeDir,
+                vcsFolderName,
+                branchName: 'main',
+                quiet: true,
+            });
+
+            iReckon(lc, checkoutRes.currentBranch).willEqual('main');
+
+            // 5. Verify feature.txt still exists untouched in b/feature-strings
+            const featureFileExists = await fs.stat(worktreeFile).then(s => s.isFile()).catch(() => false);
+            iReckon(lc, featureFileExists).isGonnaBeTrue();
+
+            const featureContent = await fs.readFile(worktreeFile, 'utf8');
+            iReckon(lc, featureContent).willEqual('content on feature branch\n');
+
+            // 6. Verify log from inside worktree succeeds and reflects feature branch history
+            const logRes = await executeLogCmd({
+                targetDir: worktreeDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, logRes.branchName).willEqual('feature-strings');
+            iReckon(lc, logRes.commits.length).willEqual(2);
+            iReckon(lc, logRes.commits[0].message).willEqual('Commit on feature');
+            iReckon(lc, logRes.commits[1].message).willEqual('Commit on main');
+
+            // 7. Verify explicit -b flag logs feature-strings from repo root
+            const rootLogExplicitBranchRes = await executeLogCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                branchName: 'feature-strings',
+                quiet: true,
+            });
+            iReckon(lc, rootLogExplicitBranchRes.branchName).willEqual('feature-strings');
+            iReckon(lc, rootLogExplicitBranchRes.commits.length).willEqual(2);
+            iReckon(lc, rootLogExplicitBranchRes.commits[0].message).willEqual('Commit on feature');
+            iReckon(lc, rootLogExplicitBranchRes.commits[1].message).willEqual('Commit on main');
+
+            // 8. Merge feature-strings into main and verify log on main
+            process.chdir(testDir);
+            await executeMergeCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                incomingBranchName: 'feature-strings',
+            });
+
+            const mainLogAfterMergeRes = await executeLogCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, mainLogAfterMergeRes.branchName).willEqual('main');
+            iReckon(lc, mainLogAfterMergeRes.commits.length >= 2).isGonnaBeTrue();
+            iReckon(lc, mainLogAfterMergeRes.commits[0].message).willEqual('Commit on feature');
+            iReckon(lc, mainLogAfterMergeRes.commits[1].message).willEqual('Commit on main');
+        } finally {
+            process.chdir(origCwd);
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
 });

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

@@ -37,11 +37,11 @@ export async function executeCheckoutCmd({
 }: CheckoutCmdOpts = {}): Promise<CheckoutCmdResult> {
     const lc = `${lcFile}[${executeCheckoutCmd.name}]`;
     try {
-        if (logalot) { console.log(`${lc} starting... (I: genuuid)`); }
+        if (logalot) { console.log(`${lc} starting... (I: 1cd9d2565ff16c18e82d7802ea033226)`); }
 
         const trimmedBranchName = branchName?.trim();
         if (!trimmedBranchName) {
-            throw new Error(`Branch name is required for checkout (E: genuuid)`);
+            throw new Error(`Branch name is required for checkout (E: 16edcde284b7fdfb05547c829fda5d26)`);
         }
 
         const absTargetDir = path.resolve(targetDir);
@@ -54,7 +54,7 @@ export async function executeCheckoutCmd({
         });
 
         if (!quiet) {
-            console.log(`Switched to branch '${checkoutRes.currentBranch}' (I: genuuid)`);
+            console.log(`Switched to branch '${checkoutRes.currentBranch}' (I: f73f287d3271149058e5ee9851392726)`);
             console.log(`Worktree path: ${checkoutRes.worktreePath}`);
         }
 
@@ -64,9 +64,9 @@ export async function executeCheckoutCmd({
             worktreePath: checkoutRes.worktreePath,
         };
     } catch (error) {
-        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 008fbfd6f9f8eb496854b4edc55ea726)`);
         throw error;
     } finally {
-        if (logalot) { console.log(`${lc} complete. (I: genuuid)`); }
+        if (logalot) { console.log(`${lc} complete. (I: d515f834dd18286f2fe1871605888c26)`); }
     }
 }

package/src/cli/commands/cli-init-cmd.mts

@@ -14,6 +14,7 @@ import { B2TFS_BRANCH_DEFAULT_NAME } from '@ibgib/core-gib/dist/vcs/branch/branc
 
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
 import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
+import { getB2tFSIndexIbGib } from '@ibgib/core-gib/dist/vcs/index/index-helper.mjs';
 import { writeVcsIndexProjectionToDisk } from '../vcs-projection-helper.mjs';
 
 const lcFile = `[init-cmd]`;
@@ -46,12 +47,27 @@ export async function executeInitCmd({
     await fs.mkdir(absTargetDir, { recursive: true });
 
     // 2. Bootstrap Metaspace and localSpace (creates .vcsgib on disk)
-    const { metaspace, localSpace } = await bootstrapVcsMetaspace({
+    const { metaspace, localSpace, foundVcsPath } = await bootstrapVcsMetaspace({
         repoPath: absTargetDir,
         vcsFolderName,
         defaultSpaceName: `vcs_${path.basename(absTargetDir).replace(/[^a-zA-Z0-9_\-]/g, '_')}`,
     });
 
+    if (foundVcsPath) {
+        const existingIndex = await getB2tFSIndexIbGib({ space: localSpace, metaspace });
+        if (existingIndex) {
+            if (!quiet) {
+                console.log(`Reinitialized existing ibgib repository in ${vcsPath}`);
+            }
+            return {
+                vcsPath,
+                spaceId: existingIndex.data.activeSpaceId,
+                branchName: existingIndex.data.activeBranchName || defaultBranchName,
+                rootItemIb: '',
+            };
+        }
+    }
+
     // 3. Facade instantiation and domain init
     const repo = new VcsRepository({
         metaspace,

package/src/cli/commands/cli-log-cmd.mts

@@ -9,7 +9,7 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 
 import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
-// import { getSpaceIdFromIb } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace-helper.mjs';
+import { getAllBranchInfosFromIndex } from '@ibgib/core-gib/dist/vcs/branch/branch-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
 import { openVcsRepository } from '../vcs-repo-helper.mjs';
@@ -33,6 +33,7 @@ export interface LogCmdOpts {
     targetDir?: string;
     vcsFolderName?: string;
     filePath?: string;
+    branchName?: string;
     allComments?: boolean;
     quiet?: boolean;
 }
@@ -47,6 +48,7 @@ export async function executeLogCmd({
     targetDir = process.cwd(),
     vcsFolderName = '.vcsgib',
     filePath,
+    branchName,
     allComments = false,
     quiet = false,
 }: LogCmdOpts = {}): Promise<LogCmdResult> {
@@ -54,19 +56,35 @@ export async function executeLogCmd({
 
     try {
         if (logalot) {
-            console.log(`${lc} starting executeLogCmd (I: genuuid)`);
+            console.log(`${lc} starting executeLogCmd (I: c6920dc083bff49d8b4dd148a36de826)`);
         }
 
         const absTargetDir = path.resolve(targetDir);
         const { repo } = await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
         const indexIbGib = await repo.getIndexIbGib();
-        const activeBranchSpace = await repo.getActiveBranchSpace(indexIbGib);
+
+        let resolvedBranchName = branchName;
+        let resolvedFilePath = filePath;
+
+        if (!resolvedBranchName && resolvedFilePath) {
+            const branchInfos = await getAllBranchInfosFromIndex({ indexIbGib });
+            if (branchInfos.some(b => b.branchName === resolvedFilePath)) {
+                resolvedBranchName = resolvedFilePath;
+                resolvedFilePath = undefined;
+            }
+        }
+
+        const activeBranchSpace = await repo.getActiveBranchSpace({
+            indexIbGib,
+            targetDir: absTargetDir,
+            branchName: resolvedBranchName,
+        });
 
         const logRes = await repo.log({
             activeBranchSpace,
             indexIbGib,
-            // repoRoot, // need this? we need jsdocs on wth repoRoot is
-            filePath,
+            branchName: resolvedBranchName,
+            filePath: resolvedFilePath,
             allComments,
             targetDir: absTargetDir,
         });
@@ -75,7 +93,7 @@ export async function executeLogCmd({
 
         if (!quiet) {
             if (logRes.targetPath) {
-                console.log(`File: ${logRes.targetPath} (branch: ${logRes.branchName}) (I: genuuid)`);
+                console.log(`File: ${logRes.targetPath} (branch: ${logRes.branchName}) (I: 5b56b87941a81ed7e9036f382ca80326)`);
                 if (commits.length === 0) {
                     console.log('No comments found for this file.');
                 } else {
@@ -86,7 +104,7 @@ export async function executeLogCmd({
                     }
                 }
             } else {
-                console.log(`Branch: ${logRes.branchName} (I: genuuid)`);
+                console.log(`Branch: ${logRes.branchName} (I: da4a28fe715c302be839ad08d9f0ca26)`);
                 if (commits.length === 0) {
                     console.log('No commits yet.');
                 } else {
@@ -116,11 +134,11 @@ export async function executeLogCmd({
             commits,
         };
     } catch (error) {
-        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        console.error(`${lc} ${extractErrorMsg(error)} (E: f279d589ced70f7e78050948f2191e26)`);
         throw error;
     } finally {
         if (logalot) {
-            console.log(`${lc} complete. (I: genuuid)`);
+            console.log(`${lc} complete. (I: 081e084ef158f7a608fd16a801bedf26)`);
         }
     }
 }

package/src/cli/commands/cli-merge-cmd.mts

@@ -42,40 +42,38 @@ export async function executeMergeCmd({
     const lc = `${lcFile}[${executeMergeCmd.name}]`;
     try {
         if (logalot) {
-            console.log(`${lc} starting... (I: genuuid)`);
+            console.log(`${lc} starting... (I: d14fb7ac187875d165abcbf8fe51ce26)`);
         }
 
         const trimmedIncomingBranchName = incomingBranchName?.trim();
         if (!trimmedIncomingBranchName) {
-            throw new Error(`Branch name is required for merge (E: genuuid)`);
+            throw new Error(`Branch name is required for merge (E: f47fd65e49a8518da859217ae1bef826)`);
         }
 
         const absTargetDir = path.resolve(targetDir);
         const { repo, vcsPath, activeWorktreeDir } =
             await openVcsRepository({ targetDir: absTargetDir, vcsFolderName });
 
-        // todo: get baseBranchName based off of targetDir?
-        const baseBranchName = await repo.getActiveBranchName();
+        const indexIbGib = await repo.getIndexIbGib();
+        const baseBranchName = await repo.getActiveBranchName({ indexIbGib, targetDir: absTargetDir });
 
         const incomingSpaceRes = await getOrCreateBranchSpace({
             metaspace: repo.metaspace,
             branchName: trimmedIncomingBranchName,
         });
 
-        const activeBranchSpace = await repo.getActiveBranchSpace();
+        const activeBranchSpace = await repo.getActiveBranchSpace({ indexIbGib, targetDir: absTargetDir });
         const activeBranchSpaceId = getSpaceIdFromIb(activeBranchSpace.ib);
 
         const mergeRes = await repo.merge({
-            baseBranchSpace: activeBranchSpace, // what should this be? always the active one? Or does the working dir determine it? What is absTargetDir?
-            // message,
-            // repoRoot,
+            baseBranchSpace: activeBranchSpace,
             incomingBranchName: trimmedIncomingBranchName,
             incomingBranchSpace: incomingSpaceRes.space,
             targetDir: absTargetDir,
         });
 
         if (!quiet) {
-            console.log(`Successfully merged branch '${trimmedIncomingBranchName}' into '${baseBranchName}' (I: genuuid)`);
+            console.log(`Successfully merged branch '${trimmedIncomingBranchName}' into '${baseBranchName}' (I: 943c67d40bb8a3177d470da667571726)`);
             console.log(`  Worktree projection: ${activeWorktreeDir}`);
         }
 
@@ -89,11 +87,11 @@ export async function executeMergeCmd({
             worktreePath: activeWorktreeDir,
         };
     } catch (error) {
-        console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+        console.error(`${lc} ${extractErrorMsg(error)} (E: acfb283f49f8e533586e0578ac9d4426)`);
         throw error;
     } finally {
         if (logalot) {
-            console.log(`${lc} complete. (I: genuuid)`);
+            console.log(`${lc} complete. (I: 67210ef7c05454c19cdb6b08149b7326)`);
         }
     }
 }

package/src/cli/vcs-cli-main.mts

@@ -126,9 +126,11 @@ export async function main({
             case VCS_SUBCOMMANDS.LOG: {
                 const targetDir = process.cwd();
                 const filePath = parsed.positionals[0];
+                const branchName = parsed.flags.branchName;
                 await executeLogCmd({
                     targetDir,
                     filePath,
+                    branchName,
                     allComments: parsed.flags.all,
                 });
                 break;
@@ -183,7 +185,25 @@ export async function main({
 
         return 0;
     } catch (error) {
-        console.error(`Error: ${extractErrorMsg(error)} (E: genuuid)`);
+        let rawMsg = extractErrorMsg(error);
+        // Strip trailing internal UUID / error markers like (E: ...)
+        const cleanMsg = rawMsg.replace(/\s*\(E:\s*[a-f0-9-]+\)\s*$/i, '').trim();
+
+        if (cleanMsg.startsWith('fatal:') || cleanMsg.startsWith('error:')) {
+            console.error(cleanMsg);
+        } else if (cleanMsg.toLowerCase().includes('nothing to commit')) {
+            console.error('nothing to commit, working tree clean');
+        } else if (cleanMsg.toLowerCase().includes('already exists')) {
+            const branchMatch = cleanMsg.match(/["']([^"']+)["']/);
+            const name = branchMatch ? branchMatch[1] : '';
+            console.error(name ? `fatal: a branch named '${name}' already exists.` : `fatal: ${cleanMsg}`);
+        } else if (cleanMsg.toLowerCase().includes('not found in indexibgib') || cleanMsg.toLowerCase().includes('not found on branch')) {
+            const branchMatch = cleanMsg.match(/\(([^)]+)\)/) || cleanMsg.match(/['"]([^'"]+)['"]/);
+            const name = branchMatch ? branchMatch[1] : '';
+            console.error(name ? `error: pathspec '${name}' did not match any file(s) known to ibgib` : `error: ${cleanMsg}`);
+        } else {
+            console.error(`fatal: ${cleanMsg}`);
+        }
         return 1;
     } finally {
         if (logalot) {

package/src/cli/vcs-repo-helper.mts

@@ -45,15 +45,20 @@ export async function openVcsRepository({
         const absTargetDir = path.resolve(targetDir);
 
         // 1. Locate repository root and bootstrap Node localSpace
-        const { metaspace, localSpace, vcsPath, repoRoot } = await bootstrapVcsMetaspace({
+        const { metaspace, localSpace, vcsPath, repoRoot, foundVcsPath } = await bootstrapVcsMetaspace({
             repoPath: absTargetDir,
             vcsFolderName,
+            mustExist: true,
         });
 
+        if (!foundVcsPath) {
+            throw new Error(`fatal: not an ibgib repository (or any of the parent directories): ${vcsFolderName}`);
+        }
+
         // 2. Fetch authoritative in-band index from localSpace
         const indexIbGib = await getB2tFSIndexIbGib({ space: localSpace, metaspace });
         if (!indexIbGib) {
-            throw new Error(`Not an ibgib repository (index not found in ${vcsPath})`);
+            throw new Error(`fatal: not an ibgib repository (index not found in ${vcsPath})`);
         }
 
         // 3. Determine active branch and worktree directory