@ibgib/vcs-gib 0.0.6

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

@@ -0,0 +1,415 @@
+/**
+ * @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.
+ */
+
+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 { 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 { 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 { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[add-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface AddCmdOpts {
+    paths?: string[];
+    targetDir?: string;
+    vcsFolderName?: string;
+    all?: boolean;
+    quiet?: boolean;
+}
+
+export interface AddCmdResult {
+    stagedPaths: string[];
+    stagedCount: number;
+}
+
+export async function executeAddCmd({
+    paths = [],
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    all = false,
+    quiet = false,
+}: AddCmdOpts = {}): Promise<AddCmdResult> {
+    const lc = `${lcFile}[${executeAddCmd.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: 2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d)`);
+        }
+
+        // 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: 2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e)`);
+        }
+
+        const activeBranch = indexIbGib.data?.activeBranch || 'main';
+        const activeWorktreeDir = activeBranch === 'main' ? repoRoot : path.join(repoRoot, 'b', activeBranch);
+
+        // Target active branch space b2s_<activeBranch>
+        const { space: activeSpace } = await getOrCreateBranchSpace({
+            metaspace,
+            vcsPath,
+            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' }>();
+        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.find(
+                (b) => (b as B2tFSBranchIbGib_V1)?.data?.name === activeBranch,
+            ) as B2tFSBranchIbGib_V1 || (branchIbGibs.at(0) as B2tFSBranchIbGib_V1);
+
+            const rootItemAddr = activeBranchIbGib?.rel8ns?.b2tfs_item?.at(0);
+            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.resolve(activeWorktreeDir, 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 (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 B2tFSItemIbGib_V1 candidate graph node
+            const fileName = path.basename(absFilePath);
+            const fileNameSansExt = path.parse(fileName).name;
+            const fileExt = path.parse(fileName).ext.replace(/^\./, '');
+            const nameHash = crypto.createHash('sha256').update(fileName).digest('hex');
+
+            const itemRes = await Factory_V1.firstGen({
+                parentIbGib: ROOT,
+                ib: getB2tFSItemIb('file', fileName, nameHash),
+                data: {
+                    name: fileName,
+                    nameHash,
+                    fsType: 'file',
+                    fileNameSansExt,
+                    fileExt,
+                    fileHash,
+                    fileEncoding: 'utf8',
+                    diffTransactionId: await getUUID(),
+                    uuid: await getUUID(),
+                    classname: 'B2tFSItemIbGib_V1',
+                },
+                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}`);
+            }
+        }
+
+        // 3. Update B2tFSIndexIbGib_V1 in activeSpace & localSpace
+        const updatedIndex = await updateB2tFSIndexIbGib({
+            space: activeSpace,
+            metaspace,
+            indexIbGib,
+            dataToUpdate: {
+                stagedPaths: stagedPathsMap,
+                staged_item: stagedItemAddrs,
+            },
+            vcsPath,
+        });
+
+        if (localSpace !== activeSpace) {
+            await putInSpace({ space: localSpace, ibGib: updatedIndex });
+        }
+
+        return {
+            stagedPaths: newlyStagedPaths,
+            stagedCount: newlyStagedPaths.length,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f)`);
+        throw error;
+    } finally {
+        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' }>;
+}): Promise<void> {
+    if (!item || !item.data) { return; }
+
+    const { fsType, fileHash } = item.data;
+    if (currentRelPath) {
+        outMap.set(currentRelPath, { relPath: currentRelPath, fileHash, fsType });
+    }
+
+    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()) {
+            outFiles.push(fullPath);
+        }
+    }
+}
+// #endregion addCmd_collectFilesRecursively