@ibgib/vcs-gib 0.0.6 → 0.0.18

package/src/engine/index/index-helper.mts

@@ -18,6 +18,9 @@ import { putInSpace, persistTransformResult } from '@ibgib/core-gib/dist/witness
 
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
 import { SpaceQualifiedIbGibAddr, B2tFSIndexIbGib_V1, B2tFSIndexData_V1, B2tFSIndexRel8ns_V1 } from './index-types.mjs';
+import { B2tFSBranchIbGib_V1 } from '../branch/branch-types.mjs';
+import { B2tFSItemIbGib_V1, B2TFS_CHILD_ITEM_REL8N_NAME } from '../item/item-types.mjs';
+import { getIbGibWithMetaspaceFallback, writeB2tFSItemToFS } from '../item/item-helper.mjs';
 
 const lcFile = `[index-helper]`;
 const logalot = GLOBAL_LOG_A_LOT;
@@ -376,3 +379,324 @@ export async function writeVcsIndexProjection({
         }
     }
 }
+
+export interface UnstagePathsFromIndexOpts {
+    indexIbGib: B2tFSIndexIbGib_V1;
+    paths?: string[];
+    targetDir?: string;
+    activeWorktreeDir?: string;
+    vcsPath?: string;
+    space: IbGibSpaceAny;
+    metaspace: MetaspaceService;
+    all?: boolean;
+}
+
+export interface UnstagePathsFromIndexResult {
+    updatedIndex: B2tFSIndexIbGib_V1;
+    unstagedPaths: string[];
+}
+
+/**
+ * Unstages specified paths (or all paths if `all` or empty `paths`) from `indexIbGib.data.stagedPaths`
+ * and `indexIbGib.data.staged_item`.
+ */
+export async function unstagePathsFromIndex({
+    indexIbGib,
+    paths = [],
+    targetDir = process.cwd(),
+    activeWorktreeDir,
+    vcsPath,
+    space,
+    metaspace,
+    all = false,
+}: UnstagePathsFromIndexOpts): Promise<UnstagePathsFromIndexResult> {
+    const lc = `${lcFile}[${unstagePathsFromIndex.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d)`);
+        }
+
+        const currentStagedPaths = { ...(indexIbGib.data?.stagedPaths || {}) };
+        let currentStagedItems = [...(indexIbGib.data?.staged_item || [])];
+        const unstagedPaths: string[] = [];
+
+        const worktreeDir = activeWorktreeDir || targetDir;
+
+        if (all || paths.length === 0 || (paths.length === 1 && (paths[0] === '.' || paths[0] === ''))) {
+            for (const relPath of Object.keys(currentStagedPaths)) {
+                unstagedPaths.push(relPath);
+            }
+            const updatedIndex = await updateB2tFSIndexIbGib({
+                space,
+                metaspace,
+                indexIbGib,
+                dataToUpdate: {
+                    stagedPaths: {},
+                    staged_item: [],
+                },
+                vcsPath,
+            });
+            return { updatedIndex, unstagedPaths };
+        }
+
+        for (const p of paths) {
+            let relPath = p.replace(/\\/g, '/');
+            if (path.isAbsolute(p)) {
+                relPath = path.relative(worktreeDir, p).replace(/\\/g, '/');
+            } else if (targetDir !== worktreeDir) {
+                const absP = path.resolve(targetDir, p);
+                relPath = path.relative(worktreeDir, absP).replace(/\\/g, '/');
+            }
+
+            const targetKeys = Object.keys(currentStagedPaths).filter((k) => {
+                return k === relPath || k.startsWith(relPath + '/');
+            });
+
+            for (const key of targetKeys) {
+                const record = currentStagedPaths[key];
+                if (record && record.itemAddr) {
+                    currentStagedItems = currentStagedItems.filter((addr) => addr !== record.itemAddr);
+                }
+                delete currentStagedPaths[key];
+                if (!unstagedPaths.includes(key)) {
+                    unstagedPaths.push(key);
+                }
+            }
+        }
+
+        const updatedIndex = await updateB2tFSIndexIbGib({
+            space,
+            metaspace,
+            indexIbGib,
+            dataToUpdate: {
+                stagedPaths: currentStagedPaths,
+                staged_item: currentStagedItems,
+            },
+            vcsPath,
+        });
+
+        return { updatedIndex, unstagedPaths };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f)`);
+        }
+    }
+}
+
+export interface RestoreWorktreePathsOpts {
+    paths?: string[];
+    targetDir?: string;
+    activeWorktreeDir: string;
+    activeBranchSpace: IbGibSpaceAny;
+    metaspace: MetaspaceService;
+    indexIbGib?: B2tFSIndexIbGib_V1;
+    vcsPath?: string;
+}
+
+export interface RestoreWorktreePathsResult {
+    restoredPaths: string[];
+}
+
+/**
+ * Restores working tree physical files from committed branch item snapshot.
+ */
+export async function restoreWorktreePathsFromSnapshot({
+    paths = [],
+    targetDir = process.cwd(),
+    activeWorktreeDir,
+    activeBranchSpace,
+    metaspace,
+    indexIbGib,
+    vcsPath,
+}: RestoreWorktreePathsOpts): Promise<RestoreWorktreePathsResult> {
+    const lc = `${lcFile}[${restoreWorktreePathsFromSnapshot.name}]`;
+    try {
+        if (logalot) {
+            console.log(`${lc} starting... (I: 9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a)`);
+        }
+
+        let currIndex = indexIbGib;
+        if (!currIndex) {
+            currIndex = await getB2tFSIndexIbGib({ space: activeBranchSpace, vcsPath });
+        }
+        if (!currIndex) {
+            throw new Error(`Repository index B2tFSIndexIbGib_V1 not found (E: 0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b)`);
+        }
+
+        const activeBranch = currIndex.data?.activeBranch || 'main';
+        const branchAddrs = [
+            ...(currIndex.rel8ns?.branch || []),
+            ...(currIndex.rel8ns?.branch_tjp || []),
+        ];
+
+        let branchIbGibs: B2tFSBranchIbGib_V1[] = [];
+        if (branchAddrs.length > 0) {
+            for (const bAddr of branchAddrs) {
+                const bIbGib = await getIbGibWithMetaspaceFallback({
+                    addr: bAddr,
+                    space: activeBranchSpace,
+                    metaspace,
+                });
+                if (bIbGib) {
+                    branchIbGibs.push(bIbGib as B2tFSBranchIbGib_V1);
+                }
+            }
+        }
+
+        const activeBranchIbGib = branchIbGibs.find(
+            (b) => b?.data?.name === activeBranch,
+        ) || (branchIbGibs.at(0) as B2tFSBranchIbGib_V1);
+
+        if (!activeBranchIbGib) {
+            throw new Error(`Branch '${activeBranch}' not found (E: 1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c)`);
+        }
+
+        const rootItemAddr = activeBranchIbGib.rel8ns?.b2tfs_item?.at(0);
+        if (!rootItemAddr) {
+            throw new Error(`Branch '${activeBranch}' has no root item (E: 2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d)`);
+        }
+
+        const rootItem = await getIbGibWithMetaspaceFallback({
+            addr: rootItemAddr,
+            space: activeBranchSpace,
+            metaspace,
+        }) as B2tFSItemIbGib_V1;
+
+        if (!rootItem) {
+            throw new Error(`Root item node '${rootItemAddr}' could not be fetched (E: 3f7e6d5c4b3a2f1e0d9c8b7a6f5e4d3c)`);
+        }
+
+        const committedItemMap = new Map<string, { relPath: string; parentRelPath: string; item: B2tFSItemIbGib_V1 }>();
+
+        await restoreCmd_collectCommittedItems({
+            item: rootItem,
+            parentRelPath: '',
+            space: activeBranchSpace,
+            metaspace,
+            outMap: committedItemMap,
+        });
+
+        const restoredPaths: string[] = [];
+
+        if (paths.length === 0 || (paths.length === 1 && (paths[0] === '.' || paths[0] === ''))) {
+            for (const entry of committedItemMap.values()) {
+                const destPath = path.join(activeWorktreeDir, entry.parentRelPath);
+                await writeB2tFSItemToFS({
+                    item: entry.item,
+                    destPath,
+                    space: activeBranchSpace,
+                    metaspace,
+                });
+                restoredPaths.push(entry.relPath);
+            }
+        } else {
+            for (const p of paths) {
+                let relPath = p.replace(/\\/g, '/');
+                if (path.isAbsolute(p)) {
+                    relPath = path.relative(activeWorktreeDir, p).replace(/\\/g, '/');
+                } else if (targetDir !== activeWorktreeDir) {
+                    const absP = path.resolve(targetDir, p);
+                    relPath = path.relative(activeWorktreeDir, absP).replace(/\\/g, '/');
+                }
+
+                let matchedCount = 0;
+                for (const entry of committedItemMap.values()) {
+                    if (entry.relPath === relPath || entry.relPath.startsWith(relPath + '/')) {
+                        const destPath = path.join(activeWorktreeDir, entry.parentRelPath);
+                        await writeB2tFSItemToFS({
+                            item: entry.item,
+                            destPath,
+                            space: activeBranchSpace,
+                            metaspace,
+                        });
+                        if (!restoredPaths.includes(entry.relPath)) {
+                            restoredPaths.push(entry.relPath);
+                        }
+                        matchedCount++;
+                    }
+                }
+
+                if (matchedCount === 0) {
+                    throw new Error(`pathspec '${p}' did not match any committed file(s) in snapshot (E: 4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c)`);
+                }
+            }
+        }
+
+        return { restoredPaths };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b)`);
+        }
+    }
+}
+
+// #region restoreCmd_collectCommittedItems
+async function restoreCmd_collectCommittedItems({
+    item,
+    parentRelPath,
+    space,
+    metaspace,
+    outMap,
+}: {
+    item: B2tFSItemIbGib_V1;
+    parentRelPath: string;
+    space: IbGibSpaceAny;
+    metaspace: MetaspaceService;
+    outMap: Map<string, { relPath: string; parentRelPath: string; item: B2tFSItemIbGib_V1 }>;
+}): Promise<void> {
+    if (!item || !item.data) { return; }
+
+    const { fsType, name } = item.data;
+
+    if (fsType === 'folder' && !parentRelPath) {
+        const childAddrs = item.rel8ns?.[B2TFS_CHILD_ITEM_REL8N_NAME] || [];
+        for (const childAddr of childAddrs) {
+            const childItem = await getIbGibWithMetaspaceFallback({
+                addr: childAddr,
+                space,
+                metaspace,
+            }) as B2tFSItemIbGib_V1;
+
+            if (childItem) {
+                await restoreCmd_collectCommittedItems({
+                    item: childItem,
+                    parentRelPath: '',
+                    space,
+                    metaspace,
+                    outMap,
+                });
+            }
+        }
+    } else {
+        const relPath = parentRelPath ? `${parentRelPath}/${name}` : name;
+        outMap.set(relPath, { relPath, parentRelPath, item });
+
+        if (fsType === 'folder') {
+            const childAddrs = item.rel8ns?.[B2TFS_CHILD_ITEM_REL8N_NAME] || [];
+            for (const childAddr of childAddrs) {
+                const childItem = await getIbGibWithMetaspaceFallback({
+                    addr: childAddr,
+                    space,
+                    metaspace,
+                }) as B2tFSItemIbGib_V1;
+
+                if (childItem) {
+                    await restoreCmd_collectCommittedItems({
+                        item: childItem,
+                        parentRelPath: relPath,
+                        space,
+                        metaspace,
+                        outMap,
+                    });
+                }
+            }
+        }
+    }
+}
+// #endregion restoreCmd_collectCommittedItems