@soulcraft/brainy 3.9.0 → 3.10.0

package/dist/vfs/FSCompat.js

@@ -0,0 +1,257 @@
+/**
+ * fs-Compatible Interface for VFS
+ *
+ * Provides a drop-in replacement for Node's fs module
+ * that uses VFS for storage instead of the real filesystem.
+ *
+ * Usage:
+ *   import { FSCompat } from '@soulcraft/brainy/vfs'
+ *   const fs = new FSCompat(brain.vfs())
+ *
+ *   // Now use like Node's fs
+ *   await fs.promises.readFile('/path')
+ *   fs.createReadStream('/path').pipe(output)
+ */
+export class FSCompat {
+    constructor(vfs) {
+        this.vfs = vfs;
+        this.promises = new FSPromises(vfs);
+    }
+    readFile(path, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        this.vfs.readFile(path, options)
+            .then(data => {
+            if (options?.encoding) {
+                callback(null, data.toString(options.encoding));
+            }
+            else {
+                callback(null, data);
+            }
+        })
+            .catch(err => callback(err));
+    }
+    writeFile(path, data, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, options?.encoding || 'utf8');
+        this.vfs.writeFile(path, buffer, options)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    mkdir(path, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        this.vfs.mkdir(path, options)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    rmdir(path, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        this.vfs.rmdir(path, options)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    readdir(path, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        this.vfs.readdir(path, options)
+            .then(files => callback(null, files))
+            .catch(err => callback(err));
+    }
+    stat(path, callback) {
+        this.vfs.stat(path)
+            .then(stats => callback(null, stats))
+            .catch(err => callback(err));
+    }
+    lstat(path, callback) {
+        this.vfs.lstat(path)
+            .then(stats => callback(null, stats))
+            .catch(err => callback(err));
+    }
+    unlink(path, callback) {
+        this.vfs.unlink(path)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    rename(oldPath, newPath, callback) {
+        this.vfs.rename(oldPath, newPath)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    copyFile(src, dest, flagsOrCallback, callback) {
+        if (typeof flagsOrCallback === 'function') {
+            callback = flagsOrCallback;
+        }
+        else {
+            // flags provided but not used
+        }
+        this.vfs.copy(src, dest)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    exists(path, callback) {
+        this.vfs.exists(path)
+            .then(exists => callback(exists))
+            .catch(() => callback(false));
+    }
+    access(path, modeOrCallback, callback) {
+        if (typeof modeOrCallback === 'function') {
+            callback = modeOrCallback;
+        }
+        else {
+            // mode provided but not used
+        }
+        this.vfs.exists(path)
+            .then(exists => {
+            if (exists) {
+                callback(null);
+            }
+            else {
+                const err = new Error('ENOENT: no such file or directory');
+                err.code = 'ENOENT';
+                callback(err);
+            }
+        })
+            .catch(err => callback(err));
+    }
+    appendFile(path, data, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, options?.encoding || 'utf8');
+        this.vfs.appendFile(path, buffer, options)
+            .then(() => callback(null))
+            .catch(err => callback(err));
+    }
+    // ============= Stream methods =============
+    createReadStream(path, options) {
+        return this.vfs.createReadStream(path, options);
+    }
+    createWriteStream(path, options) {
+        return this.vfs.createWriteStream(path, options);
+    }
+    // ============= Watch methods =============
+    watch(path, listener) {
+        return this.vfs.watch(path, listener);
+    }
+    watchFile(path, listener) {
+        return this.vfs.watchFile(path, listener);
+    }
+    unwatchFile(path) {
+        return this.vfs.unwatchFile(path);
+    }
+    // ============= Additional methods =============
+    /**
+     * Import a directory from real filesystem (VFS extension)
+     */
+    async importDirectory(sourcePath, options) {
+        return this.vfs.importDirectory(sourcePath, options);
+    }
+    /**
+     * Search files semantically (VFS extension)
+     */
+    async search(query, options) {
+        return this.vfs.search(query, options);
+    }
+}
+/**
+ * Promise-based fs API (like fs.promises)
+ */
+class FSPromises {
+    constructor(vfs) {
+        this.vfs = vfs;
+    }
+    async readFile(path, options) {
+        const buffer = await this.vfs.readFile(path, options);
+        if (options?.encoding) {
+            return buffer.toString(options.encoding);
+        }
+        return buffer;
+    }
+    async writeFile(path, data, options) {
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, options?.encoding || 'utf8');
+        return this.vfs.writeFile(path, buffer, options);
+    }
+    async mkdir(path, options) {
+        return this.vfs.mkdir(path, options);
+    }
+    async rmdir(path, options) {
+        return this.vfs.rmdir(path, options);
+    }
+    async readdir(path, options) {
+        return this.vfs.readdir(path, options);
+    }
+    async stat(path) {
+        return this.vfs.stat(path);
+    }
+    async lstat(path) {
+        return this.vfs.lstat(path);
+    }
+    async unlink(path) {
+        return this.vfs.unlink(path);
+    }
+    async rename(oldPath, newPath) {
+        return this.vfs.rename(oldPath, newPath);
+    }
+    async copyFile(src, dest, flags) {
+        return this.vfs.copy(src, dest);
+    }
+    async access(path, mode) {
+        const exists = await this.vfs.exists(path);
+        if (!exists) {
+            const err = new Error('ENOENT: no such file or directory');
+            err.code = 'ENOENT';
+            throw err;
+        }
+    }
+    async appendFile(path, data, options) {
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, options?.encoding || 'utf8');
+        return this.vfs.appendFile(path, buffer, options);
+    }
+    async realpath(path) {
+        return this.vfs.realpath(path);
+    }
+    async chmod(path, mode) {
+        return this.vfs.chmod(path, mode);
+    }
+    async chown(path, uid, gid) {
+        return this.vfs.chown(path, uid, gid);
+    }
+    async utimes(path, atime, mtime) {
+        return this.vfs.utimes(path, atime, mtime);
+    }
+    async symlink(target, path) {
+        return this.vfs.symlink(target, path);
+    }
+    async readlink(path) {
+        return this.vfs.readlink(path);
+    }
+    // VFS Extensions
+    async search(query, options) {
+        return this.vfs.search(query, options);
+    }
+    async findSimilar(path, options) {
+        return this.vfs.findSimilar(path, options);
+    }
+    async importDirectory(sourcePath, options) {
+        return this.vfs.importDirectory(sourcePath, options);
+    }
+}
+// Export a convenience function to create fs replacement
+export function createFS(vfs) {
+    return new FSCompat(vfs);
+}
+//# sourceMappingURL=FSCompat.js.map

package/dist/vfs/GitBridge.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Git Bridge for VFS
+ *
+ * Provides Git import/export capabilities without Git dependencies
+ * Enables migration to/from Git repositories while preserving VFS intelligence
+ * PRODUCTION-READY: Real implementation using filesystem operations
+ */
+import { VirtualFileSystem } from './VirtualFileSystem.js';
+import { Brainy } from '../brainy.js';
+/**
+ * Git repository representation
+ */
+export interface GitRepository {
+    path: string;
+    branches: GitBranch[];
+    commits: GitCommit[];
+    files: GitFile[];
+    metadata: {
+        name: string;
+        description?: string;
+        origin?: string;
+        lastImported?: number;
+        vfsMetadata?: Record<string, any>;
+    };
+}
+/**
+ * Git branch information
+ */
+export interface GitBranch {
+    name: string;
+    commitHash: string;
+    isActive: boolean;
+}
+/**
+ * Git commit information
+ */
+export interface GitCommit {
+    hash: string;
+    message: string;
+    author: string;
+    email: string;
+    timestamp: number;
+    parent?: string;
+    files: string[];
+}
+/**
+ * Git file representation
+ */
+export interface GitFile {
+    path: string;
+    content: Buffer;
+    hash: string;
+    mode: string;
+    size: number;
+    lastModified: number;
+}
+/**
+ * Export options
+ */
+export interface ExportOptions {
+    preserveMetadata?: boolean;
+    preserveRelationships?: boolean;
+    preserveHistory?: boolean;
+    branch?: string;
+    commitMessage?: string;
+    author?: {
+        name: string;
+        email: string;
+    };
+    includeSystemFiles?: boolean;
+}
+/**
+ * Import options
+ */
+export interface ImportOptions {
+    preserveGitHistory?: boolean;
+    extractMetadata?: boolean;
+    restoreRelationships?: boolean;
+    includeSystemFiles?: boolean;
+    branch?: string;
+    since?: number;
+    author?: string;
+}
+/**
+ * Git Bridge - Import/Export between VFS and Git repositories
+ *
+ * Capabilities:
+ * - Export VFS to standard Git repository structure
+ * - Import Git repository into VFS with intelligence
+ * - Preserve VFS metadata and relationships
+ * - Convert Git history to VFS events
+ * - No Git dependencies - pure filesystem operations
+ */
+export declare class GitBridge {
+    private vfs;
+    private brain;
+    constructor(vfs: VirtualFileSystem, brain: Brainy);
+    /**
+     * Export VFS to Git repository structure
+     */
+    exportToGit(vfsPath: string, gitRepoPath: string, options?: ExportOptions): Promise<GitRepository>;
+    /**
+     * Import Git repository into VFS
+     */
+    importFromGit(gitRepoPath: string, vfsPath: string, options?: ImportOptions): Promise<{
+        filesImported: number;
+        eventsCreated: number;
+        entitiesCreated: number;
+        relationshipsCreated: number;
+    }>;
+    /**
+     * Export directory recursively
+     */
+    private exportDirectory;
+    /**
+     * Export VFS metadata to .vfs-metadata.json
+     */
+    private exportMetadata;
+    /**
+     * Export relationships to .vfs-relationships.json
+     */
+    private exportRelationships;
+    /**
+     * Export history to .vfs-history.json
+     */
+    private exportHistory;
+    /**
+     * Collect metadata recursively
+     */
+    private collectFileMetadata;
+    /**
+     * Read Git repository structure
+     */
+    private readGitRepository;
+    /**
+     * Scan Git files recursively
+     */
+    private scanGitFiles;
+    /**
+     * Import metadata from exported data
+     */
+    private importMetadata;
+    /**
+     * Import relationships
+     */
+    private importRelationships;
+    /**
+     * Import history from exported data
+     */
+    private importHistory;
+    /**
+     * Convert Git commits to VFS events
+     */
+    private convertCommitsToEvents;
+    /**
+     * Generate commit hash
+     */
+    private generateCommitHash;
+    /**
+     * Write repository metadata
+     */
+    private writeRepoMetadata;
+    /**
+     * Record Git bridge event
+     */
+    private recordGitEvent;
+}