@ibgib/vcs-gib 0.0.30 → 0.0.32

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

@@ -1,36 +1,21 @@
 /**
  * @module add-cmd
  * 
- * Command handler for `vcs add <path...>`.
- * Stages files and directories into candidate B2tFSItemIbGib_V1 and BinIbGib_V1 graph nodes
- * and updates B2tFSIndexIbGib_V1 in localSpace.
+ * CLI command handler for `vcs add <path...>`.
+ * Bootstraps workspace projection space and delegates to executeVcsAdd.
  */
 
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import crypto from 'node:crypto';
 
-import { extractErrorMsg, getUUID } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
-import { Factory_V1 } from '@ibgib/ts-gib/dist/V1/factory.mjs';
-import { ROOT } from '@ibgib/ts-gib/dist/V1/constants.mjs';
-import { getGib } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
-import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
-import { BinIbGib_V1 } from '@ibgib/core-gib/dist/common/bin/bin-types.mjs';
-import { putInSpace, persistTransformResult } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { executeVcsAdd } from '@ibgib/core-gib/dist/vcs/commands/add-cmd.mjs';
+import { resolveContextualBranchName } from '@ibgib/core-gib/dist/vcs/branch/branch-helper.mjs';
 
 import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
-import { getOrCreateBranchSpace } from '../../engine/branch/branch-space-helper.mjs';
-import { resolveContextualBranchName } from '../../engine/branch/branch-helper.mjs';
-import { isCommentMetadataFilename } from '../../engine/status/status-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, createB2tFSItemIbGib, evolveB2tFSItemIbGib } from '../../engine/item/item-helper.mjs';
-import { B2tFSBranchIbGib_V1 } from '../../engine/branch/branch-types.mjs';
-import { isPathFiltered, parseFilterFileContent, globToRegExp } from '../../engine/filter/glob-helper.mjs';
-import { getB2tFSIndexIbGib, updateB2tFSIndexIbGib } 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 { getOrCreateBranchSpace } from '@ibgib/node-gib/dist/vcs/branch-space-helper.mjs';
+import { getOrCreateWorkspaceProjectionSpace } from '@ibgib/node-gib/dist/vcs/workspace-space-helper.mjs';
+import { readVcsIndexProjectionFromDisk, writeVcsIndexProjectionToDisk } from '../vcs-projection-helper.mjs';
 import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
 
 const lcFile = `[add-cmd]`;
@@ -75,7 +60,7 @@ export async function executeAddCmd({
         }
 
         // Retrieve authoritative B2tFSIndexIbGib_V1 from space
-        const indexIbGib = await getB2tFSIndexIbGib({ space: localSpace, vcsPath });
+        const indexIbGib = await readVcsIndexProjectionFromDisk({ vcsPath, space: localSpace });
         if (!indexIbGib) {
             throw new Error(`Repository not initialized. Run 'vcs init' first. (E: 2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e)`);
         }
@@ -94,241 +79,37 @@ export async function executeAddCmd({
             branchName: activeBranch,
         });
 
-        // Read .ibgibignore if present in active worktree
-        let filterPatterns: string[] = [];
-        const ignorePath = path.join(activeWorktreeDir, '.ibgibignore');
-        try {
-            const ignoreContent = await fs.readFile(ignorePath, 'utf8');
-            filterPatterns = parseFilterFileContent(ignoreContent);
-        } catch {
-            // Ignore file not found is fine
-        }
-
-        // Walk active branch graph items to find committed files in snapshot
-        const committedBranchItemsMap = new Map<string, { relPath: string; fileHash?: string; fsType: 'file' | 'folder'; item?: B2tFSItemIbGib_V1 }>();
-        const branchAddrs = [
-            ...(indexIbGib?.rel8ns?.branch || []),
-            ...(indexIbGib?.rel8ns?.branch_tjp || []),
-        ];
-
-        if (branchAddrs.length > 0) {
-            let branchIbGibs: B2tFSBranchIbGib_V1[] = [];
-            for (const bAddr of branchAddrs) {
-                const bIbGib = await getIbGibWithMetaspaceFallback({
-                    addr: bAddr,
-                    space: activeSpace,
-                    metaspace,
-                });
-                if (bIbGib) {
-                    branchIbGibs.push(bIbGib as B2tFSBranchIbGib_V1);
-                }
-            }
-
-            const activeBranchIbGib = branchIbGibs.findLast(
-                (b) => (b as B2tFSBranchIbGib_V1)?.data?.name === activeBranch,
-            ) as B2tFSBranchIbGib_V1 || (branchIbGibs.at(-1) as B2tFSBranchIbGib_V1);
-
-
-            const rootItemAddr = activeBranchIbGib?.rel8ns?.b2tfs_item?.at(-1);
-
-            if (rootItemAddr) {
-                const rootItem = await getIbGibWithMetaspaceFallback({
-                    addr: rootItemAddr,
-                    space: activeSpace,
-                    metaspace,
-                }) as B2tFSItemIbGib_V1;
-
-                if (rootItem) {
-                    await addCmd_walkBranchGraph({
-                        item: rootItem,
-                        space: activeSpace,
-                        metaspace,
-                        currentRelPath: '',
-                        outMap: committedBranchItemsMap,
-                    });
-                }
-            }
-        }
-
-        // Determine candidate file paths to stage
-        const targetFilePaths: string[] = [];
-
-        if (all || paths.length === 0 || (paths.length === 1 && paths[0] === '.')) {
-            await addCmd_collectFilesRecursively({
-                dirPath: activeWorktreeDir,
-                baseDir: activeWorktreeDir,
-                vcsFolderName,
-                filterPatterns,
-                outFiles: targetFilePaths,
-            });
-        } else {
-            for (const relOrAbs of paths) {
-                if (relOrAbs.includes('*') || relOrAbs.includes('?')) {
-                    const rx = globToRegExp(relOrAbs);
-
-                    const candidateFiles: string[] = [];
-                    await addCmd_collectFilesRecursively({
-                        dirPath: activeWorktreeDir,
-                        baseDir: activeWorktreeDir,
-                        vcsFolderName,
-                        filterPatterns,
-                        outFiles: candidateFiles,
-                    });
-
-                    let matchedCount = 0;
-                    for (const candidateAbsPath of candidateFiles) {
-                        const candidateRelPath = path.relative(activeWorktreeDir, candidateAbsPath).replace(/\\/g, '/');
-                        const pathBasename = candidateRelPath.split('/').pop() || candidateRelPath;
-
-                        if (rx.test(candidateRelPath) || rx.test(pathBasename)) {
-                            if (!targetFilePaths.includes(candidateAbsPath)) {
-                                targetFilePaths.push(candidateAbsPath);
-                            }
-                            matchedCount++;
-                        }
-                    }
-
-                    if (matchedCount === 0) {
-                        throw new Error(`No files matched glob pattern: ${relOrAbs} (E: e23d4c5f6a7b8c9d0e1f2a3b4c5d6e7f)`);
-                    }
-                } else {
-                    const fullPath = path.isAbsolute(relOrAbs) ? relOrAbs : path.resolve(absTargetDir, relOrAbs);
-                    let stat;
-                    try {
-                        stat = await fs.stat(fullPath);
-                    } catch {
-                        throw new Error(`Path does not exist: ${relOrAbs} (E: 10c11d12e13f14a15b16c17d18e19f20)`);
-                    }
-
-                    const relPath = path.relative(activeWorktreeDir, fullPath).replace(/\\/g, '/');
-                    if (relPath.startsWith('..') || path.isAbsolute(relPath)) {
-                        throw new Error(`Path '${relOrAbs}' is outside of active worktree repository (E: 7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f)`);
-                    }
-
-                    if (isPathFiltered({ relativePath: relPath, isDirectory: stat.isDirectory(), filterPatterns })) {
-                        continue;
-                    }
-
-                    if (stat.isDirectory()) {
-                        await addCmd_collectFilesRecursively({
-                            dirPath: fullPath,
-                            baseDir: activeWorktreeDir,
-                            vcsFolderName,
-                            filterPatterns,
-                            outFiles: targetFilePaths,
-                        });
-                    } else if (stat.isFile()) {
-                        if (!targetFilePaths.includes(fullPath)) {
-                            targetFilePaths.push(fullPath);
-                        }
-                    }
-                }
-            }
-        }
-
-        const stagedItemAddrs: string[] = [...(indexIbGib.data?.staged_item || [])];
-        const stagedPathsMap: { [relPath: string]: B2tFSStagedItemRecord } = { ...(indexIbGib.data?.stagedPaths || {}) };
-        const newlyStagedPaths: string[] = [];
-
-        for (const absFilePath of targetFilePaths) {
-            const relPath = path.relative(activeWorktreeDir, absFilePath).replace(/\\/g, '/');
-
-            // Read file data & compute hash
-            const fileData = await fs.readFile(absFilePath);
-            const fileHash = crypto.createHash('sha256').update(fileData).digest('hex');
-
-            // Skip staging if candidate file matches active branch committed snapshot
-            const committedItem = committedBranchItemsMap.get(relPath);
-            if (committedItem && committedItem.fileHash && committedItem.fileHash === fileHash) {
-                continue;
-            }
-
-            // 1. Create BinIbGib_V1 graph node as Uint8Array
-            const binData = new Uint8Array(fileData);
-            const binIb = `bin ${fileHash}`;
-            const binGib = await getGib({ ibGib: { ib: binIb, data: binData as any } });
-            const binIbGib: BinIbGib_V1 = {
-                ib: binIb,
-                gib: binGib,
-                data: binData as any,
-            };
-            const binAddr = getIbGibAddr({ ibGib: binIbGib });
-            await putInSpace({ ibGib: binIbGib, space: activeSpace });
-            await metaspace.registerNewIbGib({ ibGib: binIbGib, space: activeSpace });
-
-            // 2. Create or Evolve B2tFSItemIbGib_V1 candidate graph node
-            const fileName = path.basename(absFilePath);
-            const nameHash = crypto.createHash('sha256').update(fileName).digest('hex');
-
-            let itemRes: TransformResult<IbGib_V1>;
-            if (committedItem && committedItem.item) {
-                itemRes = await evolveB2tFSItemIbGib({
-                    existingItem: committedItem.item,
-                    dataToUpdate: {
-                        fileHash,
-                    },
-                    rel8nsToUpdate: {
-                        bin: [binAddr],
-                    },
-                });
-            } else {
-                itemRes = await createB2tFSItemIbGib({
-                    fsType: 'file',
-                    name: fileName,
-                    data: {
-                        nameHash,
-                        fileHash,
-                        fileEncoding: 'utf8',
-                    },
-                    rel8ns: {
-                        bin: [binAddr],
-                    },
-                });
-            }
-
-            const itemIbGib = itemRes.newIbGib as B2tFSItemIbGib_V1;
-            const itemAddr = getIbGibAddr({ ibGib: itemIbGib });
-            await persistTransformResult({ resTransform: itemRes, space: activeSpace });
-            await metaspace.registerNewIbGib({ ibGib: itemIbGib, space: activeSpace });
-
-            if (!stagedItemAddrs.includes(itemAddr)) {
-                stagedItemAddrs.push(itemAddr);
-            }
-
-            stagedPathsMap[relPath] = {
-                itemAddr,
-                binAddr,
-                fileHash,
-                fsType: 'file',
-                stagedAt: new Date().toISOString(),
-            };
-
-            newlyStagedPaths.push(relPath);
-
-            if (!quiet) {
-                console.log(`staged: ${relPath}`);
-            }
-        }
+        const { space: workspaceSpace } = await getOrCreateWorkspaceProjectionSpace({
+            metaspace,
+            workspaceRoot: activeWorktreeDir,
+            vcsFolderName,
+            backingSpace: activeSpace,
+        });
 
-        // 3. Update B2tFSIndexIbGib_V1 in activeSpace & localSpace
-        const updatedIndex = await updateB2tFSIndexIbGib({
-            space: activeSpace,
+        const addRes = await executeVcsAdd({
             metaspace,
+            localSpace,
+            activeBranchSpace: activeSpace,
+            workspaceSpace,
             indexIbGib,
-            dataToUpdate: {
-                stagedPaths: stagedPathsMap,
-                staged_item: stagedItemAddrs,
-            },
-            vcsPath,
+            paths,
+            all,
+            repoRoot,
+            targetDir: absTargetDir,
+            vcsFolderName,
         });
 
-        if (localSpace !== activeSpace) {
-            await putInSpace({ space: localSpace, ibGib: updatedIndex });
+        await writeVcsIndexProjectionToDisk({ vcsPath, indexIbGib: addRes.updatedIndex });
+
+        if (!quiet) {
+            for (const stagedPath of addRes.stagedPaths) {
+                console.log(`staged: ${stagedPath}`);
+            }
         }
 
         return {
-            stagedPaths: newlyStagedPaths,
-            stagedCount: newlyStagedPaths.length,
+            stagedPaths: addRes.stagedPaths,
+            stagedCount: addRes.stagedCount,
         };
     } catch (error) {
         console.error(`${lc} ${extractErrorMsg(error)} (E: 3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f)`);
@@ -337,99 +118,3 @@ export async function executeAddCmd({
         if (logalot) { console.log(`${lc} complete. (I: 4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a)`); }
     }
 }
-
-// #region addCmd_walkBranchGraph
-async function addCmd_walkBranchGraph({
-    item,
-    space,
-    metaspace,
-    currentRelPath,
-    outMap,
-}: {
-    item: B2tFSItemIbGib_V1;
-    space: any;
-    metaspace?: any;
-    currentRelPath: string;
-    outMap: Map<string, { relPath: string; fileHash?: string; fsType: 'file' | 'folder'; item?: B2tFSItemIbGib_V1 }>;
-}): Promise<void> {
-    if (!item || !item.data) { return; }
-
-    const { fsType, fileHash } = item.data;
-    if (currentRelPath) {
-        outMap.set(currentRelPath, { relPath: currentRelPath, fileHash, fsType, 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 && childItem.data) {
-                const childRelPath = currentRelPath
-                    ? `${currentRelPath}/${childItem.data.name}`
-                    : childItem.data.name;
-                await addCmd_walkBranchGraph({
-                    item: childItem,
-                    space,
-                    metaspace,
-                    currentRelPath: childRelPath,
-                    outMap,
-                });
-            }
-        }
-    }
-}
-// #endregion addCmd_walkBranchGraph
-
-// #region addCmd_collectFilesRecursively
-async function addCmd_collectFilesRecursively({
-    dirPath,
-    baseDir,
-    vcsFolderName,
-    filterPatterns,
-    outFiles,
-}: {
-    dirPath: string;
-    baseDir: string;
-    vcsFolderName: string;
-    filterPatterns: string[];
-    outFiles: string[];
-}): Promise<void> {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry.name);
-        const relPath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
-
-        // Ignore vcs storage folder, .git, and worktrees folder b
-        if (
-            relPath === vcsFolderName || relPath.startsWith(vcsFolderName + '/') ||
-            relPath === '.git' || relPath.startsWith('.git/') ||
-            relPath === 'b' || relPath.startsWith('b/')
-        ) {
-            continue;
-        }
-
-        if (isPathFiltered({ relativePath: relPath, isDirectory: entry.isDirectory(), filterPatterns })) {
-            continue;
-        }
-
-        if (entry.isDirectory()) {
-            await addCmd_collectFilesRecursively({
-                dirPath: fullPath,
-                baseDir,
-                vcsFolderName,
-                filterPatterns,
-                outFiles,
-            });
-        } else if (entry.isFile()) {
-            if (!isCommentMetadataFilename(entry.name)) {
-                outFiles.push(fullPath);
-            }
-        }
-    }
-}
-// #endregion addCmd_collectFilesRecursively