@ibgib/node-gib 0.0.22 → 0.0.24

package/src/witness/space/node-workspace-projection-space/node-workspace-projection-space-v1.mts

@@ -0,0 +1,416 @@
+/**
+ * @module node-workspace-projection-space-v1
+ *
+ * Concrete Node.js workspace projection space implementation.
+ * Projects B2tFS items to physical OS disk and scans physical directories.
+ */
+
+import { Dirent } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+import { clone, extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+import { GLOBAL_LOG_A_LOT } from '@ibgib/core-gib/dist/core-constants.mjs';
+import { IbGibSpaceAny } from '@ibgib/core-gib/dist/witness/space/space-base-v1.mjs';
+import { getFromSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+import { WorkspaceProjectionSpaceBase_V1 } from '@ibgib/core-gib/dist/witness/space/workspace-projection-space/workspace-projection-space-base-v1.mjs';
+import {
+    WorkspaceScanResultData,
+    WorkspaceFileObservation,
+    PendingCommentObservation,
+} from '@ibgib/core-gib/dist/witness/space/workspace-projection-space/workspace-projection-space-types.mjs';
+import { B2tFSItemIbGib_V1 } from '@ibgib/core-gib/dist/vcs/item/item-types.mjs';
+import { isPathFiltered, parseFilterFileContent } from '@ibgib/core-gib/dist/vcs/filter/glob-helper.mjs';
+
+import {
+    NodeWorkspaceProjectionSpaceData_V1,
+    NodeWorkspaceProjectionSpaceRel8ns_V1,
+    DEFAULT_NODE_WORKSPACE_PROJECTION_SPACE_DATA_V1,
+} from './node-workspace-projection-space-types.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface NodeWorkspaceProjectionSpaceOpts {
+    initialData?: NodeWorkspaceProjectionSpaceData_V1;
+    initialRel8ns?: NodeWorkspaceProjectionSpaceRel8ns_V1;
+    backingSpace?: IbGibSpaceAny;
+}
+
+/**
+ * Node.js Workspace Projection Space that projects B2tFS item DAGs directly onto
+ * the local filesystem and scans physical directories to report workspace state.
+ */
+export class NodeWorkspaceProjectionSpace_V1 extends WorkspaceProjectionSpaceBase_V1<
+    NodeWorkspaceProjectionSpaceData_V1,
+    NodeWorkspaceProjectionSpaceRel8ns_V1
+> {
+    protected override lc: string = `[${NodeWorkspaceProjectionSpace_V1.name}]`;
+
+    /** Backing CAS space where source BinIbGibs and child items reside */
+    backingSpace?: IbGibSpaceAny;
+
+    constructor(
+        initialDataOrOpts?: NodeWorkspaceProjectionSpaceData_V1 | NodeWorkspaceProjectionSpaceOpts,
+        initialRel8ns?: NodeWorkspaceProjectionSpaceRel8ns_V1,
+    ) {
+        let data: NodeWorkspaceProjectionSpaceData_V1 | undefined;
+        let rel8ns: NodeWorkspaceProjectionSpaceRel8ns_V1 | undefined = initialRel8ns;
+        let backingSpace: IbGibSpaceAny | undefined;
+
+        if (initialDataOrOpts && ('workspaceRoot' in initialDataOrOpts || 'name' in initialDataOrOpts)) {
+            data = initialDataOrOpts as NodeWorkspaceProjectionSpaceData_V1;
+        } else if (initialDataOrOpts && typeof initialDataOrOpts === 'object') {
+            const opts = initialDataOrOpts as NodeWorkspaceProjectionSpaceOpts;
+            data = opts.initialData;
+            rel8ns = opts.initialRel8ns ?? initialRel8ns;
+            backingSpace = opts.backingSpace;
+        }
+
+        super(data ?? (clone(DEFAULT_NODE_WORKSPACE_PROJECTION_SPACE_DATA_V1) as NodeWorkspaceProjectionSpaceData_V1), rel8ns);
+        this.backingSpace = backingSpace;
+    }
+
+    // #region Implementation of Abstract Extension Hooks
+
+    /**
+     * Projects an item (and its recursive child hierarchy or binary payload) onto the physical workspace.
+     */
+    protected override async putItemToWorkspaceImpl({
+        item,
+        subPath,
+    }: {
+        item: B2tFSItemIbGib_V1;
+        subPath?: string;
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.putItemToWorkspaceImpl.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} projecting item to workspace...`); }
+
+            const workspaceRoot = this.data?.workspaceRoot;
+            if (!workspaceRoot) {
+                throw new Error(`${lc} workspaceRoot is required in space data (E: genuuid)`);
+            }
+
+            if (!item || !item.data) {
+                throw new Error(`${lc} item and item.data are required (E: genuuid)`);
+            }
+
+            const { fsType, name } = item.data;
+
+            let itemRelPath: string;
+            if (subPath === undefined) {
+                itemRelPath = fsType === 'folder' ? '' : (name || '');
+            } else {
+                itemRelPath = name ? (subPath ? path.join(subPath, name) : name) : subPath;
+            }
+
+            const targetPath = itemRelPath ? path.join(workspaceRoot, itemRelPath) : workspaceRoot;
+
+            if (fsType === 'folder') {
+                await fs.mkdir(targetPath, { recursive: true });
+
+                const childAddrs = item.rel8ns?.b2tFS_child || item.rel8ns?.b2tfs_child || [];
+                for (const childAddr of childAddrs) {
+                    const childItem = (await this.fetchIbGib(childAddr)) as B2tFSItemIbGib_V1;
+                    await this.putItemToWorkspaceImpl({
+                        item: childItem,
+                        subPath: itemRelPath,
+                    });
+                }
+            } else if (fsType === 'file') {
+                await fs.mkdir(path.dirname(targetPath), { recursive: true });
+
+                if (!item.rel8ns) {
+                    throw new Error(`${lc} item.rel8ns required for file item (E: genuuid)`);
+                }
+
+                const binAddrs = item.rel8ns.bin;
+                if (!binAddrs || binAddrs.length === 0) {
+                    throw new Error(`${lc} item.rel8ns.bin required for file item ${name} (E: genuuid)`);
+                }
+
+                const latestBinAddr = binAddrs.at(-1)!;
+                const binIbGib = await this.fetchIbGib(latestBinAddr);
+
+                if (binIbGib.data === undefined) {
+                    throw new Error(`${lc} BinIbGib at addr ${latestBinAddr} has undefined data (E: genuuid)`);
+                }
+
+                let fileData: Uint8Array | string;
+                if (binIbGib.data instanceof Uint8Array || Buffer.isBuffer(binIbGib.data)) {
+                    fileData = binIbGib.data as Uint8Array;
+                } else if (typeof binIbGib.data === 'string') {
+                    fileData = binIbGib.data;
+                } else if (typeof binIbGib.data === 'object') {
+                    const vals = Object.values(binIbGib.data as object);
+                    fileData = new Uint8Array(vals);
+                } else {
+                    fileData = new Uint8Array(0);
+                }
+
+                await fs.writeFile(targetPath, fileData);
+            }
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    /**
+     * Scans the physical workspace directory and returns file observations and pending companion notes.
+     */
+    protected override async scanWorkspaceImpl({
+        subPath,
+        filterPatterns,
+    }: {
+        subPath?: string;
+        filterPatterns?: string[];
+    }): Promise<WorkspaceScanResultData> {
+        const lc = `${this.lc}[${this.scanWorkspaceImpl.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting physical scan...`); }
+
+            const workspaceRoot = this.data?.workspaceRoot;
+            if (!workspaceRoot) {
+                throw new Error(`${lc} workspaceRoot is required in space data (E: genuuid)`);
+            }
+
+            const scanDir = subPath ? path.join(workspaceRoot, subPath) : workspaceRoot;
+            const vcsFolderName = this.data?.vcsFolderName || '.vcsgib';
+            let patterns = filterPatterns ?? this.data?.filterPatterns;
+
+            if (!patterns || patterns.length === 0) {
+                try {
+                    const ignorePath = path.join(workspaceRoot, '.ibgibignore');
+                    const ignoreContent = await fs.readFile(ignorePath, 'utf8');
+                    patterns = parseFilterFileContent(ignoreContent);
+                } catch {
+                    patterns = [];
+                }
+            }
+
+            const files = new Map<string, WorkspaceFileObservation>();
+            const pendingComments: PendingCommentObservation[] = [];
+
+            await this.scanDirRecursive({
+                dirPath: scanDir,
+                baseDir: workspaceRoot,
+                vcsFolderName,
+                filterPatterns: patterns,
+                outFiles: files,
+                outComments: pendingComments,
+            });
+
+            return {
+                files,
+                pendingComments,
+            };
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    /**
+     * Unlinks a file, folder, or comment file from disk.
+     */
+    protected override async deleteFromWorkspaceImpl({
+        relPath,
+        ibGib,
+    }: {
+        relPath?: string;
+        ibGib?: IbGib_V1;
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.deleteFromWorkspaceImpl.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} deleting from workspace...`); }
+
+            const workspaceRoot = this.data?.workspaceRoot;
+            if (!workspaceRoot) {
+                throw new Error(`${lc} workspaceRoot is required (E: genuuid)`);
+            }
+
+            const targetRelPath = relPath || (ibGib?.data as any)?.name;
+            if (!targetRelPath) {
+                throw new Error(`${lc} relPath or item name required for deletion (E: genuuid)`);
+            }
+
+            const fullPath = path.join(workspaceRoot, targetRelPath);
+            await fs.rm(fullPath, { recursive: true, force: true });
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    /**
+     * Reads raw bytes of a physical workspace file from disk.
+     */
+    protected override async getFileBytesImpl({
+        relPath,
+    }: {
+        relPath: string;
+    }): Promise<Uint8Array | undefined> {
+        const lc = `${this.lc}[${this.getFileBytesImpl.name}]`;
+        try {
+            const workspaceRoot = this.data?.workspaceRoot;
+            if (!workspaceRoot) { return undefined; }
+            const fullPath = path.isAbsolute(relPath) ? relPath : path.join(workspaceRoot, relPath);
+            const buf = await fs.readFile(fullPath);
+            return new Uint8Array(buf);
+        } catch {
+            return undefined;
+        }
+    }
+
+    // #endregion
+
+    // #region Internal Helpers
+
+    /**
+     * Recursively scans physical directories on disk.
+     */
+    private async scanDirRecursive({
+        dirPath,
+        baseDir,
+        vcsFolderName,
+        filterPatterns,
+        outFiles,
+        outComments,
+    }: {
+        dirPath: string;
+        baseDir: string;
+        vcsFolderName: string;
+        filterPatterns: string[];
+        outFiles: Map<string, WorkspaceFileObservation>;
+        outComments: PendingCommentObservation[];
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.scanDirRecursive.name}]`;
+        let entries: Dirent[] = [];
+        try {
+            entries = await fs.readdir(dirPath, { withFileTypes: true });
+        } catch (error) {
+            console.error(`${lc} Failed to read directory ${dirPath}: ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+
+        for (const entry of entries) {
+            const fullEntryPath = path.join(dirPath, entry.name);
+            const relPath = path.relative(baseDir, fullEntryPath).replace(/\\/g, '/');
+
+            // Exclude VCS metadata folders, .git, and worktrees folder 'b'
+            if (
+                relPath === vcsFolderName || relPath.startsWith(vcsFolderName + '/') ||
+                relPath === '.git' || relPath.startsWith('.git/') ||
+                relPath === 'b' || relPath.startsWith('b/')
+            ) {
+                continue;
+            }
+
+            if (this.isFiltered(relPath, entry.isDirectory(), filterPatterns)) {
+                continue;
+            }
+
+            if (entry.isDirectory()) {
+                outFiles.set(relPath, {
+                    relPath,
+                    fullPath: fullEntryPath,
+                    isDirectory: true,
+                });
+                await this.scanDirRecursive({
+                    dirPath: fullEntryPath,
+                    baseDir,
+                    vcsFolderName,
+                    filterPatterns,
+                    outFiles,
+                    outComments,
+                });
+            } else if (entry.isFile()) {
+                if (this.isCommentMetadataFilename(entry.name)) {
+                    const parentRelPath = path.relative(baseDir, dirPath).replace(/\\/g, '/');
+                    const normalizedParent = parentRelPath === '.' ? '' : parentRelPath;
+                    let content = '';
+                    try {
+                        content = await fs.readFile(fullEntryPath, 'utf8');
+                    } catch (error) {
+                        console.error(`${lc} Failed to read comment file ${fullEntryPath}: ${extractErrorMsg(error)} (E: genuuid)`);
+                        throw error;
+                    }
+
+                    const topicName = this.extractCommentTopicName(entry.name);
+                    const targetRelPath = normalizedParent ? `${normalizedParent}/${topicName}` : topicName;
+
+                    outComments.push({
+                        commentRelPath: relPath,
+                        commentFullPath: fullEntryPath,
+                        targetRelPath,
+                        targetType: entry.name.startsWith('.ib.') ? 'file' : 'folder',
+                        topicName,
+                        content,
+                    });
+                } else {
+                    let fileHash: string;
+                    let size: number;
+                    try {
+                        const fileData = await fs.readFile(fullEntryPath);
+                        fileHash = crypto.createHash('sha256').update(fileData).digest('hex');
+                        size = fileData.length;
+                    } catch (error) {
+                        console.error(`${lc} Failed to read file ${fullEntryPath}: ${extractErrorMsg(error)} (E: genuuid)`);
+                        throw error;
+                    }
+
+                    outFiles.set(relPath, {
+                        relPath,
+                        fullPath: fullEntryPath,
+                        isDirectory: false,
+                        fileHash,
+                        size,
+                    });
+                }
+            }
+        }
+    }
+
+    private isCommentMetadataFilename(filename: string): boolean {
+        return filename.startsWith('.ib.') && filename.endsWith('.md') && filename.length > '.ib..md'.length;
+    }
+
+    private extractCommentTopicName(filename: string): string {
+        if (!this.isCommentMetadataFilename(filename)) { return ''; }
+        return filename.slice(4, -3);
+    }
+
+    private isFiltered(relPath: string, isDirectory: boolean, filterPatterns: string[]): boolean {
+        return isPathFiltered({ relativePath: relPath, isDirectory, filterPatterns });
+    }
+
+    /**
+     * Helper to fetch an IbGib strictly from backingSpace with fail-fast validation.
+     */
+    private async fetchIbGib(addr: IbGibAddr): Promise<IbGib_V1> {
+        const lc = `${this.lc}[${this.fetchIbGib.name}]`;
+        try {
+            if (!this.backingSpace) {
+                throw new Error(`${lc} backingSpace required to fetch IbGib at ${addr} (E: genuuid)`);
+            }
+
+            const resGet = await getFromSpace({ space: this.backingSpace, addrs: [addr] });
+            if (!resGet.success || !resGet.ibGibs || resGet.ibGibs.length === 0) {
+                const resIbGib = resGet.rawResultIbGib as any;
+                const addrsNotFound = resIbGib?.data?.addrsNotFound ?? 'unknown';
+                throw new Error(`${lc} couldn't find addr ${addr} in backingSpace. addrsNotFound: ${addrsNotFound} (E: genuuid)`);
+            }
+
+            return resGet.ibGibs[0];
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    // #endregion
+}

package/src/witness/space/node-workspace-projection-space/node-workspace-projection-space-v1.respec.mts

@@ -0,0 +1,212 @@
+/**
+ * @module node-workspace-projection-space-v1.respec
+ *
+ * Unit tests for NodeWorkspaceProjectionSpace_V1.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import crypto from 'node:crypto';
+
+import {
+    respecfully, ifWe, ifWeMight, iReckon, firstOfAll, lastOfAll, // don't remove ifWe/ifWeMight even if unused
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+import { Factory_V1 as factory } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { getGib } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { argy_ } from '@ibgib/core-gib/dist/witness/witness-helper.mjs';
+import { putInSpace } from '@ibgib/core-gib/dist/witness/space/space-helper.mjs';
+import { CMD_MODIFIER_WORKSPACE_SCAN } from '@ibgib/core-gib/dist/witness/space/workspace-projection-space/workspace-projection-space-constants.mjs';
+import { WorkspaceScanResultData } from '@ibgib/core-gib/dist/witness/space/workspace-projection-space/workspace-projection-space-types.mjs';
+
+import { NodeFilesystemSpace_V1 } from '../node-filesystem-space/node-filesystem-space-v1.mjs';
+import { DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1 } from '../node-filesystem-space/node-filesystem-space-types.mjs';
+import { NodeWorkspaceProjectionSpace_V1 } from './node-workspace-projection-space-v1.mjs';
+
+const lc = `[node-workspace-projection-space-v1.respec.node.mts]`;
+
+await respecfully(lc, `NodeWorkspaceProjectionSpace_V1`, async () => {
+
+    const testRootDir = path.join(process.cwd(), '.test_node_workspace_projection');
+    const casSpaceDir = path.join(testRootDir, '.vcsgib', 'ibgib', 'b2s_main');
+    const worktreeDir = path.join(testRootDir, 'working');
+
+    firstOfAll(lc, async () => {
+        await fs.mkdir(casSpaceDir, { recursive: true });
+        await fs.mkdir(worktreeDir, { recursive: true });
+    });
+
+    lastOfAll(lc, async () => {
+        await fs.rm(testRootDir, { recursive: true, force: true });
+    });
+
+    await ifWeMight(lc, `reifies files and child folders to disk and observes them via workspace_scan`, async () => {
+        // 1. Initialize CAS backing space
+        const backingSpace = new NodeFilesystemSpace_V1({
+            ...DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1,
+            workspaceRoot: testRootDir,
+            baseSubPath: '.vcsgib/ibgib',
+            spaceSubPath: 'b2s_main',
+            baseDir: testRootDir as any,
+        });
+        await backingSpace.initialized;
+
+        // 2. Initialize Projection Space
+        const projectionSpace = new NodeWorkspaceProjectionSpace_V1({
+            initialData: {
+                workspaceRoot: worktreeDir,
+                vcsFolderName: '.vcsgib',
+                classname: 'NodeWorkspaceProjectionSpace_V1',
+                name: 'test_projection',
+                uuid: 'proj-1',
+                version: '1',
+            },
+            backingSpace,
+        });
+        await projectionSpace.initialized;
+
+        // 3. Create BinIbGib and store in backing space
+        const fileContent = 'export const greeting = "hello projection space";\n';
+        const fileBytes = Buffer.from(fileContent);
+        const fileHash = crypto.createHash('sha256').update(fileBytes).digest('hex');
+        const binIb = `bin ${fileHash}`;
+        const binGib = await getGib({ ibGib: { ib: binIb, data: new Uint8Array(fileBytes) as any } });
+        const binIbGib = {
+            ib: binIb,
+            gib: binGib,
+            data: new Uint8Array(fileBytes),
+        };
+        const binAddr = getIbGibAddr({ ibGib: binIbGib });
+        await putInSpace({ ibGib: binIbGib, space: backingSpace });
+
+        // 4. Create child file item
+        const fileItemRes = await factory.firstGen({
+            ib: 'b2tfs_item file index.ts',
+            parentIbGib: factory.primitive({ ib: 'b2tfs_item' }),
+            data: {
+                name: 'index.ts',
+                fsType: 'file',
+            },
+            rel8ns: {
+                bin: [binAddr],
+            },
+            dna: false,
+        });
+        const fileItem = fileItemRes.newIbGib!;
+        const fileAddr = getIbGibAddr({ ibGib: fileItem });
+        await putInSpace({ ibGib: fileItem, space: backingSpace });
+
+        // 5. Create root folder item containing child file
+        const rootFolderRes = await factory.firstGen({
+            ib: 'b2tfs_item folder root',
+            parentIbGib: factory.primitive({ ib: 'b2tfs_item' }),
+            data: {
+                name: '',
+                fsType: 'folder',
+            },
+            rel8ns: {
+                b2tfs_child: [fileAddr],
+            },
+            dna: false,
+        });
+        const rootFolderItem = rootFolderRes.newIbGib!;
+
+        // 6. Put root folder into projection space (reify to disk)
+        await putInSpace({
+            ibGib: rootFolderItem,
+            space: projectionSpace,
+        });
+
+        // 7. Verify disk file physically exists and content matches
+        const diskContent = await fs.readFile(path.join(worktreeDir, 'index.ts'), 'utf8');
+        iReckon(lc, diskContent).willEqual(fileContent);
+
+        // 8. Add a companion comment file on disk manually
+        const commentContent = '# Companion Comment\nfeat: initial projection test';
+        await fs.writeFile(path.join(worktreeDir, '.ib.index.ts.md'), commentContent, 'utf8');
+
+        // 9. Scan workspace observation
+        const scanArg = await argy_({
+            ibMetadata: 'workspace_projection_space',
+            argData: {
+                cmd: 'get',
+                cmdModifiers: [CMD_MODIFIER_WORKSPACE_SCAN],
+            },
+        });
+        const scanRes = await projectionSpace.witness(scanArg);
+
+        const scanData = scanRes?.data?.scanResult as WorkspaceScanResultData;
+        iReckon(lc, scanData).isGonnaBeTruthy();
+        iReckon(lc, scanData.files.has('index.ts')).isGonnaBeTrue();
+        iReckon(lc, scanData.files.get('index.ts')?.isDirectory).isGonnaBeFalse();
+        iReckon(lc, scanData.files.get('index.ts')?.fileHash).isGonnaBeTruthy();
+
+        // 10. Verify companion comment file detected in pendingComments
+        iReckon(lc, scanData.pendingComments.length).willEqual(1);
+        const commentObs = scanData.pendingComments[0];
+        iReckon(lc, commentObs.commentRelPath).willEqual('.ib.index.ts.md');
+        iReckon(lc, commentObs.targetRelPath).willEqual('index.ts');
+        iReckon(lc, commentObs.content).includes('feat: initial projection test');
+
+        // 11. Delete companion comment file via deleteFromSpace
+        const delArg = await argy_({
+            ibMetadata: 'workspace_projection_space',
+            argData: {
+                cmd: 'delete',
+                relPath: '.ib.index.ts.md',
+            },
+        });
+        await projectionSpace.witness(delArg);
+
+        // 12. Verify deleted on disk and no longer in scan
+        const scanArgAfter = await argy_({
+            ibMetadata: 'workspace_projection_space',
+            argData: {
+                cmd: 'get',
+                cmdModifiers: [CMD_MODIFIER_WORKSPACE_SCAN],
+            },
+        });
+        const scanResAfter = await projectionSpace.witness(scanArgAfter);
+        const scanDataAfter = scanResAfter?.data?.scanResult as WorkspaceScanResultData;
+        iReckon(lc, scanDataAfter.pendingComments.length).willEqual(0);
+    });
+
+    await ifWeMight(lc, `filters ignored paths matching .ibgibignore patterns`, async () => {
+        const ignoreWorktreeDir = path.join(testRootDir, 'working_ignore');
+        await fs.mkdir(ignoreWorktreeDir, { recursive: true });
+
+        const projectionSpace = new NodeWorkspaceProjectionSpace_V1({
+            initialData: {
+                workspaceRoot: ignoreWorktreeDir,
+                vcsFolderName: '.vcsgib',
+                filterPatterns: ['*.log', 'build/', 'node_modules/'],
+                classname: 'NodeWorkspaceProjectionSpace_V1',
+                name: 'test_ignore_projection',
+                uuid: 'proj-ignore-1',
+                version: '1',
+            },
+        });
+        await projectionSpace.initialized;
+
+        // Write sample files on disk
+        await fs.writeFile(path.join(ignoreWorktreeDir, 'main.ts'), 'console.log("main");');
+        await fs.writeFile(path.join(ignoreWorktreeDir, 'debug.log'), 'error at line 1');
+        await fs.mkdir(path.join(ignoreWorktreeDir, 'build'), { recursive: true });
+        await fs.writeFile(path.join(ignoreWorktreeDir, 'build', 'bundle.js'), 'bundle');
+
+        const scanArg = await argy_({
+            ibMetadata: 'workspace_projection_space',
+            argData: {
+                cmd: 'get',
+                cmdModifiers: [CMD_MODIFIER_WORKSPACE_SCAN],
+            },
+        });
+        const scanRes = await projectionSpace.witness(scanArg);
+        const scanData = scanRes?.data?.scanResult as WorkspaceScanResultData;
+
+        iReckon(lc, scanData.files.has('main.ts')).isGonnaBeTrue();
+        iReckon(lc, scanData.files.has('debug.log')).isGonnaBeFalse();
+        iReckon(lc, scanData.files.has('build/bundle.js')).isGonnaBeFalse();
+    });
+
+});