@ibgib/web-gib 0.0.63 → 0.0.65

package/src/witness/space/web-in-memory-workspace-projection-space/web-in-memory-workspace-projection-space-v1.mts

@@ -0,0 +1,424 @@
+/**
+ * @module web-in-memory-workspace-projection-space-v1
+ *
+ * Concrete in-memory Web workspace projection space implementation.
+ * Projects B2tFS item DAGs into an in-memory virtual file tree and scans/observes
+ * virtual files for status and diff operations in browser environments.
+ */
+
+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 {
+    WebInMemoryWorkspaceProjectionSpaceData_V1,
+    WebInMemoryWorkspaceProjectionSpaceRel8ns_V1,
+    DEFAULT_WEB_IN_MEMORY_WORKSPACE_PROJECTION_SPACE_DATA_V1,
+    VirtualFileEntry,
+} from './web-in-memory-workspace-projection-space-types.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface WebInMemoryWorkspaceProjectionSpaceOpts {
+    initialData?: WebInMemoryWorkspaceProjectionSpaceData_V1;
+    initialRel8ns?: WebInMemoryWorkspaceProjectionSpaceRel8ns_V1;
+    backingSpace?: IbGibSpaceAny;
+}
+
+/**
+ * In-Memory Web Workspace Projection Space that projects B2tFS item DAGs into
+ * an in-memory virtual file tree for browser code browsing, editing, and staging.
+ */
+export class WebInMemoryWorkspaceProjectionSpace_V1 extends WorkspaceProjectionSpaceBase_V1<
+    WebInMemoryWorkspaceProjectionSpaceData_V1,
+    WebInMemoryWorkspaceProjectionSpaceRel8ns_V1
+> {
+    protected override lc: string = `[${WebInMemoryWorkspaceProjectionSpace_V1.name}]`;
+
+    /** Backing CAS space where source BinIbGibs and child items reside */
+    backingSpace?: IbGibSpaceAny;
+
+    /** Map of normalized relative paths -> virtual file entries */
+    private _virtualFiles: Map<string, VirtualFileEntry> = new Map();
+
+    constructor(
+        initialDataOrOpts?: WebInMemoryWorkspaceProjectionSpaceData_V1 | WebInMemoryWorkspaceProjectionSpaceOpts,
+        initialRel8ns?: WebInMemoryWorkspaceProjectionSpaceRel8ns_V1,
+    ) {
+        let data: WebInMemoryWorkspaceProjectionSpaceData_V1 | undefined;
+        let rel8ns: WebInMemoryWorkspaceProjectionSpaceRel8ns_V1 | undefined = initialRel8ns;
+        let backingSpace: IbGibSpaceAny | undefined;
+
+        if (initialDataOrOpts && ('workspaceRoot' in initialDataOrOpts || 'name' in initialDataOrOpts)) {
+            data = initialDataOrOpts as WebInMemoryWorkspaceProjectionSpaceData_V1;
+        } else if (initialDataOrOpts && typeof initialDataOrOpts === 'object') {
+            const opts = initialDataOrOpts as WebInMemoryWorkspaceProjectionSpaceOpts;
+            data = opts.initialData;
+            rel8ns = opts.initialRel8ns ?? initialRel8ns;
+            backingSpace = opts.backingSpace;
+        }
+
+        super(data ?? (clone(DEFAULT_WEB_IN_MEMORY_WORKSPACE_PROJECTION_SPACE_DATA_V1) as WebInMemoryWorkspaceProjectionSpaceData_V1), rel8ns);
+        this.backingSpace = backingSpace;
+    }
+
+    // #region Implementation of Abstract Extension Hooks
+
+    /**
+     * Projects an item (and its recursive child hierarchy or binary payload) onto the in-memory virtual tree.
+     */
+    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 virtual workspace...`); }
+
+            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 ? `${subPath}/${name}` : name) : subPath;
+            }
+            itemRelPath = this.normalizePath(itemRelPath);
+
+            if (fsType === 'folder') {
+                if (itemRelPath) {
+                    this._virtualFiles.set(itemRelPath, {
+                        relPath: itemRelPath,
+                        content: new Uint8Array(0),
+                        isDirectory: true,
+                        modifiedAt: Date.now(),
+                    });
+                }
+
+                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') {
+                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;
+                if (binIbGib.data instanceof Uint8Array) {
+                    fileData = binIbGib.data;
+                } else if (typeof binIbGib.data === 'string') {
+                    fileData = new TextEncoder().encode(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);
+                }
+
+                this._virtualFiles.set(itemRelPath, {
+                    relPath: itemRelPath,
+                    content: fileData,
+                    isDirectory: false,
+                    modifiedAt: Date.now(),
+                });
+            }
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    /**
+     * Scans the in-memory virtual workspace 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 in-memory virtual scan...`); }
+
+            const vcsFolderName = this.data?.vcsFolderName || '.vcsgib';
+            let patterns = filterPatterns ?? this.data?.filterPatterns;
+
+            if (!patterns || patterns.length === 0) {
+                const ignoreEntry = this._virtualFiles.get('.ibgibignore');
+                if (ignoreEntry && !ignoreEntry.isDirectory) {
+                    const ignoreContent = new TextDecoder('utf8').decode(ignoreEntry.content);
+                    patterns = parseFilterFileContent(ignoreContent);
+                } else {
+                    patterns = [];
+                }
+            }
+
+            const normalizedSubPath = subPath ? this.normalizePath(subPath) : '';
+            const files = new Map<string, WorkspaceFileObservation>();
+            const pendingComments: PendingCommentObservation[] = [];
+
+            for (const [relPath, entry] of this._virtualFiles.entries()) {
+                if (normalizedSubPath && !relPath.startsWith(normalizedSubPath)) {
+                    continue;
+                }
+
+                // 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 (isPathFiltered({ relativePath: relPath, isDirectory: entry.isDirectory, filterPatterns: patterns })) {
+                    continue;
+                }
+
+                const filename = relPath.split('/').pop() || relPath;
+
+                if (entry.isDirectory) {
+                    files.set(relPath, {
+                        relPath,
+                        fullPath: relPath,
+                        isDirectory: true,
+                    });
+                } else {
+                    if (this.isCommentMetadataFilename(filename)) {
+                        const pathParts = relPath.split('/');
+                        pathParts.pop();
+                        const parentRelPath = pathParts.join('/');
+                        const content = new TextDecoder('utf8').decode(entry.content);
+                        const topicName = this.extractCommentTopicName(filename);
+                        const targetRelPath = parentRelPath ? `${parentRelPath}/${topicName}` : topicName;
+
+                        pendingComments.push({
+                            commentRelPath: relPath,
+                            commentFullPath: relPath,
+                            targetRelPath,
+                            targetType: filename.startsWith('.ib.') ? 'file' : 'folder',
+                            topicName,
+                            content,
+                        });
+                    } else {
+                        const digestBuf = await crypto.subtle.digest('SHA-256', entry.content as any);
+                        const digestBytes = new Uint8Array(digestBuf);
+                        let fileHash = '';
+                        for (let i = 0; i < digestBytes.length; i++) {
+                            fileHash += digestBytes[i].toString(16).padStart(2, '0');
+                        }
+
+                        files.set(relPath, {
+                            relPath,
+                            fullPath: relPath,
+                            isDirectory: false,
+                            fileHash,
+                            size: entry.content.length,
+                        });
+                    }
+                }
+            }
+
+            return {
+                files,
+                pendingComments,
+            };
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    /**
+     * Deletes a virtual file, folder, or comment entry from the in-memory tree.
+     */
+    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 virtual workspace...`); }
+
+            const targetRelPath = this.normalizePath(relPath || (ibGib?.data as any)?.name);
+            if (!targetRelPath) {
+                throw new Error(`${lc} relPath or item name required for deletion (E: genuuid)`);
+            }
+
+            // Remove target path and any nested children
+            const keysToDelete: string[] = [];
+            for (const key of this._virtualFiles.keys()) {
+                if (key === targetRelPath || key.startsWith(`${targetRelPath}/`)) {
+                    keysToDelete.push(key);
+                }
+            }
+
+            for (const key of keysToDelete) {
+                this._virtualFiles.delete(key);
+            }
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)} (E: genuuid)`);
+            throw error;
+        }
+    }
+
+    /**
+     * Reads raw bytes of a virtual file from in-memory map.
+     */
+    protected override async getFileBytesImpl({
+        relPath,
+    }: {
+        relPath: string;
+    }): Promise<Uint8Array | undefined> {
+        return this.getVirtualFile(relPath);
+    }
+
+    // #endregion
+
+    // #region In-Memory Virtual File Accessors
+
+    /**
+     * Gets raw byte content for a virtual file.
+     */
+    public getVirtualFile(relPath: string): Uint8Array | undefined {
+        const normalized = this.normalizePath(relPath);
+        const entry = this._virtualFiles.get(normalized);
+        if (!entry || entry.isDirectory) { return undefined; }
+        return entry.content;
+    }
+
+    /**
+     * Gets UTF-8 text content for a virtual file.
+     */
+    public getVirtualText(relPath: string): string | undefined {
+        const bytes = this.getVirtualFile(relPath);
+        if (bytes === undefined) { return undefined; }
+        return new TextDecoder('utf8').decode(bytes);
+    }
+
+    /**
+     * Sets or updates a virtual file's content directly in memory.
+     */
+    public setVirtualFile(relPath: string, content: Uint8Array | string): void {
+        const normalized = this.normalizePath(relPath);
+        const data = typeof content === 'string' ? new TextEncoder().encode(content) : content;
+
+        // Ensure parent directories exist
+        const parts = normalized.split('/');
+        for (let i = 1; i < parts.length; i++) {
+            const parentPath = parts.slice(0, i).join('/');
+            if (!this._virtualFiles.has(parentPath)) {
+                this._virtualFiles.set(parentPath, {
+                    relPath: parentPath,
+                    content: new Uint8Array(0),
+                    isDirectory: true,
+                    modifiedAt: Date.now(),
+                });
+            }
+        }
+
+        this._virtualFiles.set(normalized, {
+            relPath: normalized,
+            content: data,
+            isDirectory: false,
+            modifiedAt: Date.now(),
+        });
+    }
+
+    /**
+     * Lists all virtual file and folder paths currently stored in memory.
+     */
+    public listVirtualPaths(): string[] {
+        return Array.from(this._virtualFiles.keys()).sort();
+    }
+
+    /**
+     * Clears all virtual files from memory.
+     */
+    public clearVirtualFiles(): void {
+        this._virtualFiles.clear();
+    }
+
+    // #endregion
+
+    // #region Private Helpers
+
+    private normalizePath(p: string): string {
+        return p.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '');
+    }
+
+    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);
+    }
+
+    /**
+     * 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
+}