@ibgib/vcs-gib 0.0.6

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

@@ -0,0 +1,246 @@
+/**
+ * @module status-add-cmd.respec
+ * 
+ * Unit tests for `vcs status` and `vcs add` 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 { executeStatusCmd } from './status-cmd.mjs';
+import { executeAddCmd } from './add-cmd.mjs';
+import { executeCommitCmd } from './commit-cmd.mjs';
+import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.mjs';
+import { getB2tFSIndexIbGib } from '../../engine/index/index-helper.mjs';
+
+const lc = `[apps/vcs-gib/src/cli/commands/status-add-cmd.respec.node.mts]`;
+
+await respecfully(lc, `vcs status and vcs add Command Handlers`, async () => {
+
+    await ifWe(lc, `detects untracked files in fresh repository`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_1');
+        const vcsFolderName = '.vcsgib_test_1';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'hello.txt'), 'Hello ibgib!', 'utf8');
+
+            const statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, statusRes.branchName).willEqual('main');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).includes('hello.txt');
+            iReckon(lc, statusRes.staged.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `discovers .vcsgib via upward discovery when executed from a subfolder`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_subfolder');
+        const vcsFolderName = '.vcsgib_test_subfolder';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            const subDir = path.join(testDir, 'src', 'components');
+            await fs.mkdir(subDir, { recursive: true });
+            await fs.writeFile(path.join(subDir, 'Button.tsx'), 'export const Button = () => null;', 'utf8');
+
+            const statusRes = await executeStatusCmd({
+                targetDir: subDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, statusRes.branchName).willEqual('main');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).includes('src/components/Button.tsx');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `skips re-staging unmodified committed files during executeAddCmd with all flag`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_unmodified');
+        const vcsFolderName = '.vcsgib_test_unmodified';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'file.txt'), 'Initial Content', 'utf8');
+
+            await executeAddCmd({
+                paths: ['file.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                message: 'Initial commit',
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            // Run add -a again when file is unmodified
+            const addRes = await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, addRes.stagedCount).willEqual(0);
+            iReckon(lc, addRes.stagedPaths.length).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `stages untracked file via executeAddCmd`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_2');
+        const vcsFolderName = '.vcsgib_test_2';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'file1.txt'), 'Content 1', 'utf8');
+            await fs.writeFile(path.join(testDir, 'file2.txt'), 'Content 2', 'utf8');
+
+            const addRes = await executeAddCmd({
+                paths: ['file1.txt'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, addRes.stagedPaths).includes('file1.txt');
+
+            const { localSpace, vcsPath } = await bootstrapVcsMetaspace({
+                repoPath: testDir,
+                vcsFolderName,
+            });
+            const indexIbGib = await getB2tFSIndexIbGib({ space: localSpace, vcsPath });
+            iReckon(lc, Boolean(indexIbGib?.data?.staged_item && indexIbGib.data.staged_item.length > 0)).isGonnaBeTrue();
+            iReckon(lc, indexIbGib?.rel8ns?.staged_item).isGonnaBeFalsy();
+
+            const statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, statusRes.staged.map(x => x.path)).includes('file1.txt');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).includes('file2.txt');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).not.includes('file1.txt');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `respects .ibgibignore patterns during status and add`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_3');
+        const vcsFolderName = '.vcsgib_test_3';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, '.ibgibignore'), 'ignored.txt\ntemp/\n', 'utf8');
+            await fs.writeFile(path.join(testDir, 'ignored.txt'), 'Secrets', 'utf8');
+            await fs.writeFile(path.join(testDir, 'tracked.txt'), 'Public', 'utf8');
+            await fs.mkdir(path.join(testDir, 'temp'), { recursive: true });
+            await fs.writeFile(path.join(testDir, 'temp/cache.dat'), 'Cache', 'utf8');
+
+            const statusRes = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, statusRes.untracked.map(x => x.path)).includes('tracked.txt');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).not.includes('ignored.txt');
+            iReckon(lc, statusRes.untracked.map(x => x.path)).not.includes('temp/cache.dat');
+
+            const addRes = await executeAddCmd({
+                all: true,
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, addRes.stagedPaths).includes('tracked.txt');
+            iReckon(lc, addRes.stagedPaths).not.includes('ignored.txt');
+            iReckon(lc, addRes.stagedPaths).not.includes('temp/cache.dat');
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `stages files matching glob pattern with executeAddCmd`, async () => {
+        const testDir = path.join(process.cwd(), '.test_status_add_glob');
+        const vcsFolderName = '.vcsgib_test_glob';
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            await fs.writeFile(path.join(testDir, 'app.js'), 'console.log("app");', 'utf8');
+            await fs.writeFile(path.join(testDir, 'utils.js'), 'console.log("utils");', 'utf8');
+            await fs.writeFile(path.join(testDir, 'index.html'), '<html></html>', 'utf8');
+
+            const addRes = await executeAddCmd({
+                paths: ['*.js'],
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, addRes.stagedPaths).includes('app.js');
+            iReckon(lc, addRes.stagedPaths).includes('utils.js');
+            iReckon(lc, addRes.stagedPaths).not.includes('index.html');
+
+            let errorThrown = false;
+            try {
+                await executeAddCmd({
+                    paths: ['*.xyz'],
+                    targetDir: testDir,
+                    vcsFolderName,
+                    quiet: true,
+                });
+            } catch (err: any) {
+                errorThrown = true;
+                iReckon(lc, err.message).includes('No files matched glob pattern: *.xyz');
+            }
+            iReckon(lc, errorThrown).isGonnaBeTrue();
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -0,0 +1,366 @@
+/**
+ * @module status-cmd
+ * 
+ * Command handler for `vcs status`.
+ * Compares physical workspace state against active branch snapshot tip and in-band index staging area.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { Dirent } from 'node:fs';
+import crypto from 'node:crypto';
+
+import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibsFromCache_fallbackToSpaces } from '@ibgib/core-gib/dist/common/other/ibgib-helper.mjs';
+
+import { bootstrapVcsMetaspace } from '../../bootstrap/node-bootstrap.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 { getIbGibWithMetaspaceFallback } from '../../engine/item/item-helper.mjs';
+import { B2tFSBranchIbGib_V1 } from '../../engine/branch/branch-types.mjs';
+import { isPathFiltered, parseFilterFileContent } from '../../engine/filter/glob-helper.mjs';
+import { getB2tFSIndexIbGib } 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 = `[status-cmd]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface VcsStatusItem {
+    path: string;
+    fsType: 'file' | 'folder';
+    status: 'untracked' | 'modified' | 'deleted' | 'staged';
+}
+
+export interface StatusCmdResult {
+    branchName: string;
+    staged: VcsStatusItem[];
+    modified: VcsStatusItem[];
+    deleted: VcsStatusItem[];
+    untracked: VcsStatusItem[];
+}
+
+export interface StatusCmdOpts {
+    targetDir?: string;
+    vcsFolderName?: string;
+    quiet?: boolean;
+}
+
+export async function executeStatusCmd({
+    targetDir = process.cwd(),
+    vcsFolderName = '.vcsgib',
+    quiet = false,
+}: StatusCmdOpts = {}): Promise<StatusCmdResult> {
+    const lc = `${lcFile}[${executeStatusCmd.name}]`;
+
+    try {
+        if (logalot) {
+            console.log(`${lc} starting executeStatusCmd (I: 7a8b9c10d11e12f13a14b15c16d17e18)`);
+        }
+
+        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: 4d5e6f7a8b9c10d11e12f13a14b15c6d)`);
+        }
+
+        // 1. Fetch authoritative B2tFSIndexIbGib_V1 directly from localSpace
+        const indexIbGib = await getB2tFSIndexIbGib({ space: localSpace, vcsPath });
+        const branchName = indexIbGib?.data?.activeBranch || 'main';
+
+        const activeWorktreeDir = branchName === 'main' ? repoRoot : path.join(repoRoot, 'b', branchName);
+
+        // Target active branch space b2s_<activeBranch>
+        const { space: activeBranchSpace } = await getOrCreateBranchSpace({
+            metaspace,
+            vcsPath,
+            branchName,
+        });
+
+        // 2. Extract staged items directly from in-band B2tFSIndexIbGib_V1 data
+        const stagedMap = new Map<string, B2tFSStagedItemRecord>();
+        const indexStagedPaths = indexIbGib?.data?.stagedPaths || {};
+        for (const [relPath, itemRec] of Object.entries(indexStagedPaths)) {
+            stagedMap.set(relPath, itemRec);
+        }
+
+        // 3. Find active branch root item address from in-band branch graph node
+        let rootItemAddr: string | undefined;
+        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: activeBranchSpace,
+                    metaspace,
+                });
+                if (bIbGib) {
+                    branchIbGibs.push(bIbGib as B2tFSBranchIbGib_V1);
+                }
+            }
+
+            const activeBranchIbGib = branchIbGibs.find(
+                (b) => (b as B2tFSBranchIbGib_V1)?.data?.name === branchName,
+            ) as B2tFSBranchIbGib_V1 || (branchIbGibs.at(0) as B2tFSBranchIbGib_V1);
+
+            rootItemAddr = activeBranchIbGib?.rel8ns?.b2tfs_item?.at(0);
+        }
+
+        // Read .ibgibignore patterns
+        let filterPatterns: string[] = [];
+        const ignorePath = path.join(activeWorktreeDir, '.ibgibignore');
+        try {
+            const ignoreContent = await fs.readFile(ignorePath, 'utf8');
+            filterPatterns = parseFilterFileContent(ignoreContent);
+        } catch {
+            // Ignore file missing is fine
+        }
+
+        // 4. Walk active branch graph items
+        const branchItemsMap = new Map<string, { relPath: string; fileHash?: string; fsType: 'file' | 'folder' }>();
+
+        if (rootItemAddr) {
+            const rootItem = await getIbGibWithMetaspaceFallback({
+                addr: rootItemAddr,
+                space: activeBranchSpace,
+                metaspace,
+            }) as B2tFSItemIbGib_V1;
+
+            if (rootItem) {
+                await statusCmd_walkBranchGraph({
+                    item: rootItem,
+                    space: activeBranchSpace,
+                    metaspace,
+                    currentRelPath: '',
+                    outMap: branchItemsMap,
+                });
+            }
+        }
+
+        // 5. Scan physical workspace
+        const physicalItemsMap = new Map<string, { relPath: string; fullPath: string; isDirectory: boolean; fileHash?: string }>();
+        await statusCmd_scanPhysicalWorkspace({
+            dirPath: activeWorktreeDir,
+            baseDir: activeWorktreeDir,
+            vcsFolderName,
+            filterPatterns,
+            outMap: physicalItemsMap,
+        });
+
+        // 6. Categorize items into staged, modified, deleted, untracked
+        const staged: VcsStatusItem[] = [];
+        const modified: VcsStatusItem[] = [];
+        const deleted: VcsStatusItem[] = [];
+        const untracked: VcsStatusItem[] = [];
+
+        // Add staged items
+        for (const [relPath, stagedRec] of stagedMap.entries()) {
+            staged.push({
+                path: relPath,
+                fsType: stagedRec.fsType || 'file',
+                status: 'staged',
+            });
+        }
+
+        // Compare physical items against branch items and staged
+        for (const [relPath, physItem] of physicalItemsMap.entries()) {
+            if (stagedMap.has(relPath)) {
+                continue; // Staged item already reported
+            }
+
+            const branchItem = branchItemsMap.get(relPath);
+            if (!branchItem) {
+                // Not in active branch snapshot and not staged => untracked
+                untracked.push({
+                    path: relPath,
+                    fsType: physItem.isDirectory ? 'folder' : 'file',
+                    status: 'untracked',
+                });
+            } else {
+                // Tracked in branch -> check if modified
+                if (!physItem.isDirectory && physItem.fileHash && branchItem.fileHash && physItem.fileHash !== branchItem.fileHash) {
+                    modified.push({
+                        path: relPath,
+                        fsType: 'file',
+                        status: 'modified',
+                    });
+                }
+            }
+        }
+
+        // Check for deleted items (in branch snapshot, but not in physical workspace and not staged)
+        for (const [relPath, branchItem] of branchItemsMap.entries()) {
+            if (!relPath || relPath === '.' || relPath === '') { continue; }
+            if (!physicalItemsMap.has(relPath) && !stagedMap.has(relPath)) {
+                deleted.push({
+                    path: relPath,
+                    fsType: branchItem.fsType,
+                    status: 'deleted',
+                });
+            }
+        }
+
+        if (!quiet) {
+            console.log(`On branch ${branchName} (I: 9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b)`);
+            if (staged.length > 0) {
+                console.log('\nChanges to be committed:');
+                for (const item of staged) {
+                    console.log(`  staged:   ${item.path}`);
+                }
+            }
+            if (modified.length > 0 || deleted.length > 0) {
+                console.log('\nChanges not staged for commit:');
+                for (const item of modified) {
+                    console.log(`  modified: ${item.path}`);
+                }
+                for (const item of deleted) {
+                    console.log(`  deleted:  ${item.path}`);
+                }
+            }
+            if (untracked.length > 0) {
+                console.log('\nUntracked files:');
+                for (const item of untracked) {
+                    console.log(`  untracked:${item.path}`);
+                }
+            }
+            if (staged.length === 0 && modified.length === 0 && deleted.length === 0 && untracked.length === 0) {
+                console.log('nothing to commit, working tree clean');
+            }
+        }
+
+        return {
+            branchName,
+            staged,
+            modified,
+            deleted,
+            untracked,
+        };
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)} (E: 5e6f7a8b9c10d11e12f13a14b15c6d7e)`);
+        throw error;
+    } finally {
+        if (logalot) {
+            console.log(`${lc} complete. (I: 6f7a8b9c10d11e12f13a14b15c6d7e8f)`);
+        }
+    }
+}
+
+// #region statusCmd_walkBranchGraph
+async function statusCmd_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 statusCmd_walkBranchGraph({
+                    item: childItem,
+                    space,
+                    metaspace,
+                    currentRelPath: childRelPath,
+                    outMap,
+                });
+            }
+        }
+    }
+}
+// #endregion statusCmd_walkBranchGraph
+
+// #region statusCmd_scanPhysicalWorkspace
+async function statusCmd_scanPhysicalWorkspace({
+    dirPath,
+    baseDir,
+    vcsFolderName,
+    filterPatterns,
+    outMap,
+}: {
+    dirPath: string;
+    baseDir: string;
+    vcsFolderName: string;
+    filterPatterns: string[];
+    outMap: Map<string, { relPath: string; fullPath: string; isDirectory: boolean; fileHash?: string }>;
+}): Promise<void> {
+    let entries: Dirent[] = [];
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    } catch {
+        return;
+    }
+
+    for (const entry of entries) {
+        const fullEntryPath = path.join(dirPath, entry.name);
+        const relPath = path.relative(baseDir, fullEntryPath).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()) {
+            outMap.set(relPath, { relPath, fullPath: fullEntryPath, isDirectory: true });
+            await statusCmd_scanPhysicalWorkspace({
+                dirPath: fullEntryPath,
+                baseDir,
+                vcsFolderName,
+                filterPatterns,
+                outMap,
+            });
+        } else if (entry.isFile()) {
+            let fileHash: string | undefined;
+            try {
+                const fileData = await fs.readFile(fullEntryPath);
+                fileHash = crypto.createHash('sha256').update(fileData).digest('hex');
+            } catch {
+                // File unreadable
+            }
+            outMap.set(relPath, { relPath, fullPath: fullEntryPath, isDirectory: false, fileHash });
+        }
+    }
+}
+// #endregion statusCmd_scanPhysicalWorkspace