@ibgib/vcs-gib 0.0.6 → 0.0.17

package/src/cli/commands/reset-restore-cmd.respec.node.mts

@@ -0,0 +1,222 @@
+/**
+ * @module reset-restore-cmd.respec
+ * 
+ * Unit tests for `vcs reset` and `vcs restore` command handlers.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import {
+    respecfully, ifWe, iReckon
+} 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 { executeStatusCmd } from './status-cmd.mjs';
+import { executeResetCmd } from './reset-cmd.mjs';
+import { executeRestoreCmd } from './restore-cmd.mjs';
+
+const lc = `[apps/vcs-gib/src/cli/commands/reset-restore-cmd.respec.node.mts]`;
+
+await respecfully(lc, `vcs reset and vcs restore Command Handlers`, async () => {
+
+    await ifWe(lc, `vcs reset clears staged file from index while keeping disk file edits intact`, async () => {
+        const testDir = path.join(process.cwd(), '.test_reset_1');
+        const vcsFolderName = '.vcsgib_test_reset_1';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'foo.txt'), 'Hello Foo', 'utf8');
+
+            await executeAddCmd({
+                paths: ['foo.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            let statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.map(x => x.path)).includes('foo.txt');
+
+            // Modify file on disk after staging
+            await fs.writeFile(path.join(testDir, 'foo.txt'), 'Hello Foo Modified', 'utf8');
+
+            // Execute reset
+            const resetRes = await executeResetCmd({
+                paths: ['foo.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, resetRes.unstagedPaths).includes('foo.txt');
+
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Verify file is no longer staged
+            iReckon(lc, statusRes.staged.map(x => x.path)).not.includes('foo.txt');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).includes('foo.txt');
+
+            // Verify disk content is still intact
+            const diskContent = await fs.readFile(path.join(testDir, 'foo.txt'), 'utf8');
+            iReckon(lc, diskContent).willEqual('Hello Foo Modified');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs restore --staged unstages file from index while keeping disk edits intact`, async () => {
+        const testDir = path.join(process.cwd(), '.test_restore_staged');
+        const vcsFolderName = '.vcsgib_test_restore_staged';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'bar.txt'), 'Initial Bar', 'utf8');
+
+            await executeAddCmd({
+                paths: ['bar.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'bar.txt'), 'Edited Bar', 'utf8');
+
+            const restoreRes = await executeRestoreCmd({
+                paths: ['bar.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                staged: true,
+                quiet: true,
+            });
+
+            iReckon(lc, restoreRes.unstagedPaths).includes('bar.txt');
+
+            const statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, statusRes.staged.map(x => x.path)).not.includes('bar.txt');
+
+            const diskContent = await fs.readFile(path.join(testDir, 'bar.txt'), 'utf8');
+            iReckon(lc, diskContent).willEqual('Edited Bar');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs restore <file> reverts modified disk file back to committed snapshot content`, async () => {
+        const testDir = path.join(process.cwd(), '.test_restore_worktree');
+        const vcsFolderName = '.vcsgib_test_restore_worktree';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'committed.txt'), 'Original Committed Content', 'utf8');
+
+            await executeAddCmd({
+                paths: ['committed.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Initial commit',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Modify file on disk
+            await fs.writeFile(path.join(testDir, 'committed.txt'), 'Modified Bad Content', 'utf8');
+
+            // Restore worktree file
+            const restoreRes = await executeRestoreCmd({
+                paths: ['committed.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, restoreRes.restoredPaths).includes('committed.txt');
+
+            // Verify disk content is reverted back to committed snapshot content
+            const diskContent = await fs.readFile(path.join(testDir, 'committed.txt'), 'utf8');
+            iReckon(lc, diskContent).willEqual('Original Committed Content');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `vcs reset --all unstages all files from index`, async () => {
+        const testDir = path.join(process.cwd(), '.test_reset_all');
+        const vcsFolderName = '.vcsgib_test_reset_all';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'f1.txt'), 'F1', 'utf8');
+            await fs.writeFile(path.join(testDir, 'f2.txt'), 'F2', 'utf8');
+
+            await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            let statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.length).willEqual(2);
+
+            const resetRes = await executeResetCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, resetRes.unstagedPaths.length).willEqual(2);
+
+            statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusRes.staged.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+});

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

@@ -0,0 +1,155 @@
+/**
+ * @module restore-cmd
+ * 
+ * Command handler for `vcs restore [path...]`.
+ * Restores working tree files from committed branch snapshot, or unstages files if `--staged` is set.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { promptForConfirm } from '@ibgib/helper-gib/dist/helpers/node-helper.mjs';
+import { putInSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+
+import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
+import { getOrCreateBranchSpace } from '../../engine/branch/branch-space-helper.mjs';
+import { getB2tFSIndexIbGib, unstagePathsFromIndex, restoreWorktreePathsFromSnapshot } from '../../engine/index/index-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[restore-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface RestoreCmdOpts {
+    paths?: string[];
+    targetDir?: string;
+    vcsFolderName?: string;
+    staged?: boolean;
+    worktree?: boolean;
+    yes?: boolean;
+    force?: boolean;
+    quiet?: boolean;
+}
+
+export interface RestoreCmdResult {
+    unstagedPaths?: string[];
+    restoredPaths?: string[];
+}
+
+export async function executeRestoreCmd({
+    paths = [],
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    staged = false,
+    worktree = false,
+    yes = false,
+    force = false,
+    quiet = false,
+}: RestoreCmdOpts = {}): Promise<RestoreCmdResult> {
+    const lc = `${lcFile}[${executeRestoreCmd.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1e)`);
+        }
+
+        const absTargetDir = path.resolve(targetDir);
+
+        const { metaspace, localSpace, vcsPath, repoRoot } = await bootstrapVcsMetaspace({
+            repoPath: absTargetDir,
+            vcsFolderName,
+        });
+
+        // Verify repo exists
+        try {
+            await fs.access(vcsPath);
+        } catch {
+            throw new Error(`Not an ibgib repository (directory ${vcsPath} does not exist) (E: 7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2e)`);
+        }
+
+        // Retrieve authoritative B2tFSIndexIbGib_V1 from space
+        const indexIbGib = await getB2tFSIndexIbGib({ space: localSpace, vcsPath });
+        if (!indexIbGib) {
+            throw new Error(`Repository not initialized. Run 'vcs init' first. (E: 8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3e)`);
+        }
+
+        const activeBranch = indexIbGib.data?.activeBranch || 'main';
+        const activeWorktreeDir = activeBranch === 'main' ? repoRoot : path.join(repoRoot, 'b', activeBranch);
+
+        const { space: activeSpace } = await getOrCreateBranchSpace({
+            metaspace,
+            vcsPath,
+            branchName: activeBranch,
+        });
+
+        const skipPrompt = yes || force || quiet || !process.stdin.isTTY;
+        if (!skipPrompt) {
+            const msg = staged
+                ? 'Unstage specified files from index?'
+                : 'Revert working tree files to committed snapshot?';
+            const confirmed = await promptForConfirm({ msg });
+            if (!confirmed) {
+                if (!quiet) {
+                    console.log('Operation cancelled.');
+                }
+                return { unstagedPaths: [], restoredPaths: [] };
+            }
+        }
+
+        let unstagedPaths: string[] | undefined;
+        let restoredPaths: string[] | undefined;
+
+        if (staged) {
+            const unstageRes = await unstagePathsFromIndex({
+                indexIbGib,
+                paths,
+                targetDir,
+                activeWorktreeDir,
+                vcsPath,
+                space: activeSpace,
+                metaspace,
+            });
+
+            if (localSpace !== activeSpace) {
+                await putInSpace({ space: localSpace, ibGib: unstageRes.updatedIndex });
+            }
+
+            unstagedPaths = unstageRes.unstagedPaths;
+            if (!quiet) {
+                for (const p of unstagedPaths) {
+                    console.log(`unstaged: ${p}`);
+                }
+            }
+        }
+
+        if (!staged || worktree) {
+            const restoreRes = await restoreWorktreePathsFromSnapshot({
+                paths,
+                targetDir,
+                activeWorktreeDir,
+                activeBranchSpace: activeSpace,
+                metaspace,
+                indexIbGib,
+                vcsPath,
+            });
+
+            restoredPaths = restoreRes.restoredPaths;
+            if (!quiet) {
+                for (const p of restoredPaths) {
+                    console.log(`restored: ${p}`);
+                }
+            }
+        }
+
+        return {
+            unstagedPaths,
+            restoredPaths,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4e)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5e)`);
+        }
+    }
+}

package/src/cli/commands/status-add-cmd.respec.node.mts

@@ -243,4 +243,31 @@ await respecfully(lc, `vcs status and vcs add Command Handlers`, async () => {
             await fs.rm(testDir, { recursive: true, force: true });
         }
     });
+
+    await ifWe(lc, `stages relative file paths correctly when targetDir is a subdirectory`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_subdir');
+        const vcsFolderName = '.vcsgib_test_subdir';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            const subDir = path.join(testDir, 'src', 'utils');
+            await fs.mkdir(subDir, { recursive: true });
+            await fs.writeFile(path.join(subDir, 'math.js'), 'export const add = (a, b) => a + b;', 'utf8');
+
+            const addRes = await executeAddCmd({
+                paths: ['math.js'],
+                targetDir: subDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, addRes.stagedPaths).includes('src/utils/math.js');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
 });

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

@@ -17,6 +17,8 @@ import { executeCommitCmd } from './commands/commit-cmd.mjs';
 import { executeLogCmd } from './commands/log-cmd.mjs';
 import { executeBranchCmd } from './commands/branch-cmd.mjs';
 import { executeCheckoutCmd } from './commands/checkout-cmd.mjs';
+import { executeResetCmd } from './commands/reset-cmd.mjs';
+import { executeRestoreCmd } from './commands/restore-cmd.mjs';
 import { AUTO_GENERATED_VERSION } from '../AUTO-GENERATED-version.mjs';
 import { GLOBAL_LOG_A_LOT } from '../vcs-gib-constants.mjs';
 
@@ -42,13 +44,18 @@ Commands:
   log                   Show commit logs
   branch [name]         List or create branches
   checkout <branch>     Switch to a specified branch and project worktree
+  reset [path...]       Unstage specified files from index (-a, --all for all)
+  restore [path...]     Restore working tree files or unstage (--staged)
 
 Flags:
   -h, --help            Show help information
   -v, --version         Show version information
   -m <message>          Commit message
   -b <branch>           Target branch name
-  -a, --all             Stage all tracked/untracked files (for add)
+  -a, --all             Stage all tracked/untracked files (for add/reset)
+  -s, --staged          Unstage specified files from index (for restore)
+  -w, --worktree        Revert physical working tree files (for restore)
+  -y, --yes             Automatically confirm interactive prompts
   -f, --force           Force operation execution
 `;
     console.log(helpText.trim());
@@ -64,7 +71,7 @@ export async function main({
     const lc = `${lcFile}[${main.name}]`;
     try {
         if (logalot) {
-            console.log(`${lc} starting... (I: 4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d)`);
+            console.log(`${lc} starting... (I: 4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e)`);
         }
 
         const parsed = parseVcsArgs(argv);
@@ -113,6 +120,25 @@ export async function main({
                 await executeCheckoutCmd({ branchName });
                 break;
             }
+            case VCS_SUBCOMMANDS.RESET: {
+                await executeResetCmd({
+                    paths: parsed.positionals,
+                    all: parsed.flags.all,
+                    yes: parsed.flags.yes,
+                    force: parsed.flags.force,
+                });
+                break;
+            }
+            case VCS_SUBCOMMANDS.RESTORE: {
+                await executeRestoreCmd({
+                    paths: parsed.positionals,
+                    staged: parsed.flags.staged,
+                    worktree: parsed.flags.worktree,
+                    yes: parsed.flags.yes,
+                    force: parsed.flags.force,
+                });
+                break;
+            }
             case VCS_SUBCOMMANDS.VERSION: {
                 showVersion();
                 break;
@@ -126,7 +152,7 @@ export async function main({
 
         return 0;
     } catch (error) {
-        console.error(`Error: ${extractErrorMsg(error)} (E: 8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c)`);
+        console.error(`Error: ${extractErrorMsg(error)} (E: 8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d)`);
         return 1;
     } finally {
         if (logalot) {

package/src/engine/branch/branch-graph-helper.mts

@@ -1,17 +1,20 @@
 /**
  * @module branch-graph-helper
  * 
- * Helper for extracting dependency graphs and populating branch spaces.
+ * Helper for populating branch spaces via SyncSagaCoordinator.
  */
 
-import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { clone, extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-import { getDependencyGraph } from '@ibgib/core-gib/dist/common/other/graph-helper.mjs';
 import { IbGibSpaceAny } from '@ibgib/core-gib/dist/witness/space/space-base-v1.mjs';
-import { putInSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
 import { MetaspaceService } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-types.mjs';
+import { SyncSagaCoordinator } from '@ibgib/core-gib/dist/sync/sync-saga-coordinator.mjs';
+import { SyncPeerInnerspace_V1 } from '@ibgib/core-gib/dist/sync/sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mjs';
+import { SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1 } from '@ibgib/core-gib/dist/sync/sync-peer/sync-peer-innerspace/sync-peer-innerspace-constants.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+import { B2tFSBranchIbGib_V1 } from './branch-types.mjs';
+import { createB2tFSBranchIbGib } from './branch-helper.mjs';
 
 const lcFile = `[branch-graph-helper]`;
 const logalot = GLOBAL_LOG_A_LOT;
@@ -20,44 +23,88 @@ export interface PopulateBranchSpaceFromGraphOpts {
     sourceSpace: IbGibSpaceAny;
     targetBranchSpace: IbGibSpaceAny;
     rootItemIbGib: IbGib_V1;
+    branchName?: string;
     metaspace?: MetaspaceService;
 }
 
+export interface PopulateBranchSpaceFromGraphResult {
+    syncedCount: number;
+    branchIbGib?: B2tFSBranchIbGib_V1;
+}
+
 /**
- * Extracts the live dependency graph of rootItemIbGib from sourceSpace and persists all ibgibs into targetBranchSpace.
+ * Executes SSM (Space - Sync - Metadata) for branch space initialization:
+ * 1. Space: Target branch space targetBranchSpace (b2s_<branchName>).
+ * 2. Sync: Syncs rootItemIbGib from sourceSpace -> targetBranchSpace using SyncSagaCoordinator.
+ * 3. Metadata: Creates B2tFSBranchIbGib_V1 metadata node in targetBranchSpace pointing to rootItem.
  */
 export async function populateBranchSpaceFromGraph({
     sourceSpace,
     targetBranchSpace,
     rootItemIbGib,
+    branchName,
     metaspace,
-}: PopulateBranchSpaceFromGraphOpts): Promise<void> {
+}: PopulateBranchSpaceFromGraphOpts): Promise<PopulateBranchSpaceFromGraphResult> {
     const lc = `${lcFile}[${populateBranchSpaceFromGraph.name}]`;
     try {
         if (logalot) {
             console.log(`${lc} starting... (I: 1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d)`);
         }
 
-        if (!sourceSpace || !targetBranchSpace || !rootItemIbGib) {
-            throw new Error(`sourceSpace, targetBranchSpace, and rootItemIbGib are required (E: 2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e)`);
+        if (!sourceSpace || !targetBranchSpace || !rootItemIbGib || !metaspace) {
+            throw new Error(`sourceSpace, targetBranchSpace, rootItemIbGib, and metaspace are required (E: 2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e)`);
         }
 
-        const graph = await getDependencyGraph({
-            ibGib: rootItemIbGib,
-            space: sourceSpace,
-            live: true,
+        // 1. Space: targetBranchSpace provided/instantiated
+
+        // 2. Sync: Execute SyncSagaCoordinator space-to-space sync (sourceSpace -> targetBranchSpace)
+        const senderCoordinator = new SyncSagaCoordinator();
+        const receiverCoordinator = new SyncSagaCoordinator();
+
+        const peer = new SyncPeerInnerspace_V1(clone(SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1));
+        await peer.initialized;
+        await peer.initializeOpts({
+            localMetaspace: metaspace,
+            localSpace: sourceSpace,
+            receiverSpace: targetBranchSpace,
+            receiverCoordinator,
+            receiverMetaspace: metaspace,
         });
 
-        for (const [addr, ibGib] of Object.entries(graph)) {
-            await putInSpace({ space: targetBranchSpace, ibGib });
-            if (metaspace) {
-                await metaspace.registerNewIbGib({ ibGib, space: targetBranchSpace });
-            }
+        const resSync = await senderCoordinator.sync({
+            peer,
+            localSpace: sourceSpace,
+            metaspace,
+            domainIbGibs: [rootItemIbGib],
+        });
+
+        await resSync.done;
+
+        if (logalot) {
+            console.log(`${lc} SyncSagaCoordinator sync initiated for ${rootItemIbGib.ib} (I: 3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f)`);
+        }
+
+        const syncedCount = 1;
+
+        // 3. Metadata: Create B2tFSBranchIbGib_V1 metadata node in targetBranchSpace pointing to rootItem
+        let branchIbGib: B2tFSBranchIbGib_V1 | undefined;
+        if (branchName && metaspace) {
+            branchIbGib = await createB2tFSBranchIbGib({
+                branchName,
+                rootItem: rootItemIbGib as any,
+                space: targetBranchSpace,
+                metaspace,
+            });
         }
 
         if (logalot) {
-            console.log(`${lc} Populated target branch space with ${Object.keys(graph).length} ibgibs (I: 3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f)`);
+            console.log(`${lc} Populated target branch space via SyncSagaCoordinator (I: 4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f)`);
         }
+
+        return {
+            syncedCount,
+            branchIbGib,
+        };
     } catch (error) {
         console.error(`${lc} ${extractErrorMsg(error)} (E: 4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a)`);
         throw error;
@@ -67,3 +114,4 @@ export async function populateBranchSpaceFromGraph({
         }
     }
 }
+

package/src/engine/branch/branch-space-helper.mts

@@ -14,6 +14,12 @@ import { putInSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs'
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
 import { getB2tFSBranchSpaceName } from './branch-helper.mjs';
 
+export {
+    populateBranchSpaceFromGraph,
+    PopulateBranchSpaceFromGraphOpts,
+    PopulateBranchSpaceFromGraphResult,
+} from './branch-graph-helper.mjs';
+
 const lcFile = `[branch-space-helper]`;
 const logalot = GLOBAL_LOG_A_LOT;
 

package/src/engine/branch/branch-space.respec.node.mts

@@ -136,20 +136,26 @@ await respecfully(lc, `Branch Space & Graph Helper Respecs`, async () => {
                     branchName: 'main',
                 });
 
-                // Populate target branch space from source localSpace graph
-                await populateBranchSpaceFromGraph({
+                // Populate target branch space from source localSpace graph and create branch metadata node (SSM)
+                const popResult = await populateBranchSpaceFromGraph({
                     sourceSpace: localSpace,
                     targetBranchSpace,
                     rootItemIbGib: rootItem,
+                    branchName: 'main',
                     metaspace,
                 });
 
+                iReckon(lc, popResult.syncedCount > 0).isGonnaBeTrue();
+                iReckon(lc, popResult.branchIbGib).isGonnaBeTruthy();
+                iReckon(lc, popResult.branchIbGib?.data?.name).willEqual('main');
+                iReckon(lc, popResult.branchIbGib?.rel8ns?.b2tfs_item).includes(rootAddr);
+
                 // Verify items exist in targetBranchSpace
-                const rootGet = await getFromSpace({ space: targetBranchSpace, addr: rootAddr });
-                iReckon(lc, rootGet).isGonnaBeTruthy();
+                const rootGet = await getFromSpace({ space: targetBranchSpace, addrs: [rootAddr] });
+                iReckon(lc, rootGet?.ibGibs?.length === 1).isGonnaBeTrue();
 
-                const childGet = await getFromSpace({ space: targetBranchSpace, addr: childAddr });
-                iReckon(lc, childGet).isGonnaBeTruthy();
+                const childGet = await getFromSpace({ space: targetBranchSpace, addrs: [childAddr] });
+                iReckon(lc, childGet?.ibGibs?.length === 1).isGonnaBeTrue();
             } finally {
                 await fs.rm(testDir, { recursive: true, force: true });
             }