@ibgib/vcs-gib 0.0.6 → 0.0.18

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

@@ -24,11 +24,13 @@ import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
 import { getOrCreateBranchSpace } from '../../engine/branch/branch-space-helper.mjs';
 import { getB2tFSItemIb } from '../../engine/item/item-atom-helper.mjs';
 import { B2tFSItemIbGib_V1, B2TFS_CHILD_ITEM_REL8N_NAME } from '../../engine/item/item-types.mjs';
-import { getIbGibWithMetaspaceFallback } from '../../engine/item/item-helper.mjs';
+import { getIbGibWithMetaspaceFallback, createB2tFSItemIbGib, evolveB2tFSItemIbGib } from '../../engine/item/item-helper.mjs';
 import { getB2tFSBranchSpaceName } from '../../engine/branch/branch-helper.mjs';
 import { B2tFSBranchIbGib_V1 } from '../../engine/branch/branch-types.mjs';
 import { getB2tFSIndexIbGib, updateB2tFSIndexIbGib, getSpaceQualifiedIbGibAddr } from '../../engine/index/index-helper.mjs';
 import { B2tFSStagedItemRecord } from '../../engine/index/index-types.mjs';
+import { TransformResult } from '@ibgib/ts-gib/dist/types.mjs';
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
 
 const lcFile = `[commit-cmd]`;
@@ -127,16 +129,18 @@ export async function executeCommitCmd({
                 }
             }
 
-            currentBranchIbGib = branchIbGibs.find(
+            currentBranchIbGib = branchIbGibs.findLast(
                 (b) => (b as B2tFSBranchIbGib_V1)?.data?.name === branchName,
-            ) as B2tFSBranchIbGib_V1 || (branchIbGibs.at(0) as B2tFSBranchIbGib_V1);
+            ) as B2tFSBranchIbGib_V1 || (branchIbGibs.at(-1) as B2tFSBranchIbGib_V1);
+
 
             if (currentBranchIbGib) {
                 currentBranchAddr = getIbGibAddr({ ibGib: currentBranchIbGib });
             }
         }
 
-        const currentRootAddr = currentBranchIbGib?.rel8ns?.b2tfs_item?.at(0);
+        const currentRootAddr = currentBranchIbGib?.rel8ns?.b2tfs_item?.at(-1);
+
 
         // 1. Create CommentIbGib_V1 commit comment node in activeSpace
         const commentRes = await createCommentIbGib({
@@ -244,7 +248,7 @@ async function commitCmd_buildEvolvedRootItem({
     metaspace: any;
     repoName: string;
 }): Promise<{ newRootItem: B2tFSItemIbGib_V1; newRootAddr: string }> {
-    const itemsByRelPath = new Map<string, { itemAddr: string; fsType: 'file' | 'folder' }>();
+    const itemsByRelPath = new Map<string, { itemAddr: string; fsType: 'file' | 'folder'; item?: B2tFSItemIbGib_V1 }>();
 
     if (currentRootAddr) {
         const currentRootItem = await getIbGibWithMetaspaceFallback({
@@ -328,27 +332,34 @@ async function commitCmd_buildEvolvedRootItem({
         }
 
         const folderName = folderRelPath ? path.basename(folderRelPath) : repoName;
-        const diffTxId = await getUUID();
         const nameHash = crypto.createHash('sha256').update(folderName).digest('hex');
 
-        const rel8ns: Record<string, string[]> = {};
-        if (childAddrs.length > 0) {
-            rel8ns[B2TFS_CHILD_ITEM_REL8N_NAME] = childAddrs;
-        }
+        const existingFolderRec = itemsByRelPath.get(folderRelPath);
 
-        const folderRes = await Factory_V1.firstGen({
-            parentIbGib: ROOT,
-            ib: getB2tFSItemIb('folder', folderName, nameHash),
-            data: {
-                name: folderName,
-                nameHash,
+        let folderRes: TransformResult<IbGib_V1>;
+
+        if (existingFolderRec && existingFolderRec.item) {
+            const oldChildAddrs = existingFolderRec.item.rel8ns?.[B2TFS_CHILD_ITEM_REL8N_NAME] || [];
+            const toRemoveChildAddrs = oldChildAddrs.filter(a => !childAddrs.includes(a));
+
+            folderRes = await evolveB2tFSItemIbGib({
+                existingItem: existingFolderRec.item,
+                dataToUpdate: {
+                    nameHash,
+                },
+                rel8nsToUpdate: childAddrs.length > 0 ? { [B2TFS_CHILD_ITEM_REL8N_NAME]: childAddrs } : undefined,
+                rel8nsToRemove: toRemoveChildAddrs.length > 0 ? { [B2TFS_CHILD_ITEM_REL8N_NAME]: toRemoveChildAddrs } : undefined,
+            });
+        } else {
+            folderRes = await createB2tFSItemIbGib({
                 fsType: 'folder',
-                diffTransactionId: diffTxId,
-                uuid: await getUUID(),
-                classname: 'B2tFSItemIbGib_V1',
-            },
-            rel8ns,
-        });
+                name: folderName,
+                data: {
+                    nameHash,
+                },
+                rel8ns: childAddrs.length > 0 ? { [B2TFS_CHILD_ITEM_REL8N_NAME]: childAddrs } : undefined,
+            });
+        }
 
         const folderItem = folderRes.newIbGib as B2tFSItemIbGib_V1;
         const folderAddr = getIbGibAddr({ ibGib: folderItem });
@@ -383,16 +394,14 @@ async function commitCmd_walkBranchGraph({
     space: any;
     metaspace?: any;
     currentRelPath: string;
-    outMap: Map<string, { itemAddr: string; fsType: 'file' | 'folder' }>;
+    outMap: Map<string, { itemAddr: string; fsType: 'file' | 'folder'; item?: B2tFSItemIbGib_V1 }>;
 }): Promise<void> {
     if (!item || !item.data) { return; }
 
     const { fsType } = item.data;
     const itemAddr = getIbGibAddr({ ibGib: item });
 
-    if (currentRelPath) {
-        outMap.set(currentRelPath, { itemAddr, fsType });
-    }
+    outMap.set(currentRelPath, { itemAddr, fsType, item });
 
     if (fsType === 'folder') {
         const childAddrs = item.rel8ns?.[B2TFS_CHILD_ITEM_REL8N_NAME] || [];

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

@@ -0,0 +1,289 @@
+/**
+ * @module merge-cmd
+ * 
+ * Command handler for `vcs merge <branchName>`.
+ * Merges target branch into active branch using SyncSagaCoordinator sync and 3-way graft merge strategy.
+ * Projects merged branch snapshot onto active branch physical worktree path.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import { clone, extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { rel8 } from '@ibgib/ts-gib/dist/V1/transforms/rel8.mjs';
+import { putInSpace, getLatestAddrs, getFromSpace, registerNewIbGib } from '@ibgib/core-gib/dist/witness/space/space-helper.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 { SyncConflictStrategy } from '@ibgib/core-gib/dist/sync/sync-constants.mjs';
+import { GraftPreference } from '@ibgib/core-gib/dist/sync/graft-info/graft-info-types.mjs';
+
+
+import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
+import { B2tFSBranchIbGib_V1 } from '../../engine/branch/branch-types.mjs';
+import { getOrCreateBranchSpace } from '../../engine/branch/branch-space-helper.mjs';
+import { B2tFSItemIbGib_V1, B2TFS_CHILD_ITEM_REL8N_NAME } from '../../engine/item/item-types.mjs';
+import { writeB2tFSItemToFS, getIbGibWithMetaspaceFallback } from '../../engine/item/item-helper.mjs';
+import { getB2tFSIndexIbGib, updateB2tFSIndexIbGib } from '../../engine/index/index-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[merge-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface MergeCmdOpts {
+    targetBranchName?: string;
+    targetDir?: string;
+    vcsFolderName?: string;
+    quiet?: boolean;
+}
+
+export interface MergeCmdResult {
+    activeBranch: string;
+    targetBranch: string;
+    activeSpaceId: string;
+    targetSpaceId: string;
+    mergedBranchAddr?: string;
+    worktreePath: string;
+}
+
+export async function executeMergeCmd({
+    targetBranchName,
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    quiet = false,
+}: MergeCmdOpts = {}): Promise<MergeCmdResult> {
+    const lc = `${lcFile}[${executeMergeCmd.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f)`);
+        }
+
+        const trimmedTargetBranch = targetBranchName?.trim();
+        if (!trimmedTargetBranch) {
+            throw new Error(`Branch name is required for merge (E: 5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a)`);
+        }
+
+        const absTargetDir = path.resolve(targetDir);
+
+        const { metaspace, localSpace, repoRoot, vcsPath } = 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: 6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b)`);
+        }
+
+        // 1. Fetch authoritative repository index from localSpace
+        const indexIbGib = await getB2tFSIndexIbGib({ space: localSpace, vcsPath });
+        if (!indexIbGib) {
+            throw new Error(`Repository index B2tFSIndexIbGib_V1 not found in localSpace (E: 7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c)`);
+        }
+
+        const activeBranchName = indexIbGib.data?.activeBranch || 'main';
+
+        if (activeBranchName === trimmedTargetBranch) {
+            throw new Error(`Cannot merge branch '${trimmedTargetBranch}' into itself (E: 8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d)`);
+        }
+
+        // 2. Fetch all registered branch ibgibs
+        const branchAddrs = [
+            ...(indexIbGib.rel8ns?.branch || []),
+            ...(indexIbGib.rel8ns?.branch_tjp || []),
+        ];
+
+        let branchIbGibs: B2tFSBranchIbGib_V1[] = [];
+        if (branchAddrs.length > 0) {
+            for (const bAddr of branchAddrs) {
+                const bIbGib = await getIbGibWithMetaspaceFallback({
+                    addr: bAddr,
+                    space: localSpace,
+                    metaspace,
+                });
+                if (bIbGib) {
+                    branchIbGibs.push(bIbGib as B2tFSBranchIbGib_V1);
+                }
+            }
+        }
+
+        // Resolve active branch node & target branch node
+        const activeBranchIbGib = branchIbGibs.findLast(
+            (b) => b?.data?.name === activeBranchName,
+        );
+        if (!activeBranchIbGib) {
+            throw new Error(`Active branch '${activeBranchName}' not found in repository (E: 9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e)`);
+        }
+
+        const targetBranchIbGib = branchIbGibs.findLast(
+            (b) => b?.data?.name === trimmedTargetBranch,
+        );
+
+        if (!targetBranchIbGib) {
+            throw new Error(`Branch '${trimmedTargetBranch}' does not exist (E: 0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f)`);
+        }
+
+        // 3. Resolve active branch space & target branch space
+        const activeSpaceRes = await getOrCreateBranchSpace({
+            metaspace,
+            vcsPath,
+            branchName: activeBranchName,
+        });
+        const activeSpace = activeSpaceRes.space;
+
+        const targetSpaceRes = await getOrCreateBranchSpace({
+            metaspace,
+            vcsPath,
+            branchName: trimmedTargetBranch,
+        });
+        const targetSpace = targetSpaceRes.space;
+
+        await putInSpace({ space: activeSpace, ibGib: activeBranchIbGib });
+        await putInSpace({ space: targetSpace, ibGib: targetBranchIbGib });
+
+        // Resolve latest branch tip inside targetSpace (in case commits occurred on target branch)
+        const targetBranchTjpAddr = targetBranchIbGib.rel8ns?.tjp?.at(0) || getIbGibAddr({ ibGib: targetBranchIbGib });
+        const latestTargetBranchRes = await getLatestAddrs({ space: targetSpace, addrs: [targetBranchTjpAddr] });
+        const latestTargetBranchAddr = (latestTargetBranchRes?.data as any)?.latestAddrs?.[0] || getIbGibAddr({ ibGib: targetBranchIbGib });
+
+        const latestTargetBranchIbGib = (await getIbGibWithMetaspaceFallback({
+            addr: latestTargetBranchAddr,
+            space: targetSpace,
+            metaspace,
+        })) as B2tFSBranchIbGib_V1 || targetBranchIbGib;
+
+        const targetRootAddr = latestTargetBranchIbGib.rel8ns?.b2tfs_item?.at(-1);
+
+        if (!targetRootAddr) {
+            throw new Error(`Target branch '${trimmedTargetBranch}' has no valid root item address (E: 3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e)`);
+        }
+        const targetRootItem = await getIbGibWithMetaspaceFallback({
+            addr: targetRootAddr,
+            space: targetSpace,
+            metaspace,
+        });
+        if (!targetRootItem) {
+            throw new Error(`Target root item '${targetRootAddr}' not found in target space (E: 4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f)`);
+        }
+
+        // 4. Setup SyncPeerInnerspace and SyncSagaCoordinator syncing target branch space into active branch space
+        const peer = new SyncPeerInnerspace_V1(clone(SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1));
+        await peer.initialized;
+        await peer.initializeOpts({
+            localMetaspace: metaspace,
+            localSpace: targetSpace,
+            receiverSpace: activeSpace,
+            receiverCoordinator: new SyncSagaCoordinator(),
+            receiverMetaspace: metaspace,
+        });
+
+        const senderCoordinator = new SyncSagaCoordinator();
+        const syncSaga = await senderCoordinator.sync({
+            peer,
+            localSpace: targetSpace,
+            metaspace,
+            domainIbGibs: [targetRootItem],
+            conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+            graftPreference: GraftPreference.receiver,
+        });
+
+
+
+
+        await syncSaga.done;
+
+        // 5. Query activeSpace for updated active branch node & root item evolved natively by sync graft strategy
+        const activeBranchTjpAddr = activeBranchIbGib.rel8ns?.tjp?.at(0) || getIbGibAddr({ ibGib: activeBranchIbGib });
+        const latestBranchRes = await getLatestAddrs({ space: activeSpace, addrs: [activeBranchTjpAddr] });
+        const mergedBranchAddr = (latestBranchRes?.data as any)?.latestAddrs?.[0] || getIbGibAddr({ ibGib: activeBranchIbGib });
+
+        const mergedBranchIbGib = (await getIbGibWithMetaspaceFallback({
+            addr: mergedBranchAddr,
+            space: activeSpace,
+            metaspace,
+        })) as B2tFSBranchIbGib_V1 || activeBranchIbGib;
+
+        const mergedRootItemAddr = mergedBranchIbGib.rel8ns?.b2tfs_item?.at(-1);
+
+        // Update indexIbGib to reference new merged branch node
+        await updateB2tFSIndexIbGib({
+            space: activeSpace,
+            metaspace,
+            indexIbGib,
+            rel8nsToUpdate: {
+                branch: [mergedBranchAddr],
+            },
+            vcsPath,
+        });
+
+
+        // 6. Project merged branch snapshot files onto physical worktree disk
+        const isDefaultBranch = activeBranchName === 'main';
+        const worktreePath = isDefaultBranch
+            ? repoRoot
+            : path.join(repoRoot, 'b', activeBranchName);
+
+        await fs.mkdir(worktreePath, { recursive: true });
+
+        if (mergedRootItemAddr) {
+            const mergedRootItem = await getIbGibWithMetaspaceFallback({
+                addr: mergedRootItemAddr,
+                space: activeSpace,
+                metaspace,
+            }) as B2tFSItemIbGib_V1;
+
+            if (mergedRootItem) {
+                if (mergedRootItem.data?.fsType === 'file') {
+                    await writeB2tFSItemToFS({
+                        item: mergedRootItem,
+                        destPath: worktreePath,
+                        space: activeSpace,
+                        metaspace,
+                    });
+                } else {
+                    const childAddrs = mergedRootItem.rel8ns?.[B2TFS_CHILD_ITEM_REL8N_NAME] || [];
+                    for (const childAddr of childAddrs) {
+                        const childItem = await getIbGibWithMetaspaceFallback({
+                            addr: childAddr,
+                            space: activeSpace,
+                            metaspace,
+                        }) as B2tFSItemIbGib_V1;
+
+                        if (childItem) {
+                            await writeB2tFSItemToFS({
+                                item: childItem,
+                                destPath: worktreePath,
+                                space: activeSpace,
+                                metaspace,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!quiet) {
+            console.log(`Successfully merged branch '${trimmedTargetBranch}' into '${activeBranchName}' (I: 1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a)`);
+            console.log(`  Worktree projection: ${worktreePath}`);
+        }
+
+        return {
+            activeBranch: activeBranchName,
+            targetBranch: trimmedTargetBranch,
+            activeSpaceId: activeSpaceRes.spaceId,
+            targetSpaceId: targetSpaceRes.spaceId,
+            mergedBranchAddr: getIbGibAddr({ ibGib: mergedBranchIbGib }),
+            worktreePath,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c)`);
+        }
+    }
+}

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

@@ -0,0 +1,128 @@
+/**
+ * @module reset-cmd
+ * 
+ * Command handler for `vcs reset [path...]`.
+ * Unstages specified files (or all files) from active branch index in localSpace.
+ */
+
+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 } from '../../engine/index/index-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[reset-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface ResetCmdOpts {
+    paths?: string[];
+    targetDir?: string;
+    vcsFolderName?: string;
+    all?: boolean;
+    yes?: boolean;
+    force?: boolean;
+    quiet?: boolean;
+}
+
+export interface ResetCmdResult {
+    unstagedPaths: string[];
+    stagedCount: number;
+}
+
+export async function executeResetCmd({
+    paths = [],
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    all = false,
+    yes = false,
+    force = false,
+    quiet = false,
+}: ResetCmdOpts = {}): Promise<ResetCmdResult> {
+    const lc = `${lcFile}[${executeResetCmd.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d)`);
+        }
+
+        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: 2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b)`);
+        }
+
+        // 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: 3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b)`);
+        }
+
+        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 confirmed = await promptForConfirm({ msg: 'Unstage specified files from index?' });
+            if (!confirmed) {
+                if (!quiet) {
+                    console.log('Operation cancelled.');
+                }
+                const stagedCount = Object.keys(indexIbGib.data?.stagedPaths || {}).length;
+                return { unstagedPaths: [], stagedCount };
+            }
+        }
+
+        const unstageRes = await unstagePathsFromIndex({
+            indexIbGib,
+            paths,
+            targetDir,
+            activeWorktreeDir,
+            vcsPath,
+            space: activeSpace,
+            metaspace,
+            all,
+        });
+
+        if (localSpace !== activeSpace) {
+            await putInSpace({ space: localSpace, ibGib: unstageRes.updatedIndex });
+        }
+
+        if (!quiet) {
+            for (const unstagedPath of unstageRes.unstagedPaths) {
+                console.log(`unstaged: ${unstagedPath}`);
+            }
+        }
+
+        const finalStagedCount = Object.keys(unstageRes.updatedIndex.data?.stagedPaths || {}).length;
+        return {
+            unstagedPaths: unstageRes.unstagedPaths,
+            stagedCount: finalStagedCount,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c)`);
+        }
+    }
+}