memory-git 1.0.0

package/dist/index.js

@@ -0,0 +1,1024 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryGit = void 0;
+const isomorphic_git_1 = __importDefault(require("isomorphic-git"));
+const node_1 = __importDefault(require("isomorphic-git/http/node"));
+const memfs_1 = require("memfs");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * MemoryGit - In-memory Git implementation
+ *
+ * Loads the project into memory, executes all git operations in memory,
+ * and syncs to disk only when flush() is called.
+ *
+ * All real disk operations use async versions to not block the Node.js event loop.
+ */
+class MemoryGit {
+    /** Instance name */
+    name;
+    /** Memory filesystem */
+    fs;
+    /** Volume instance */
+    vol;
+    /** In-memory repository directory */
+    dir = '/repo';
+    /** Real disk directory (if loaded from disk) */
+    realDir = null;
+    /** Whether the repository is initialized */
+    isInitialized = false;
+    /** Author information for commits */
+    author = { name: 'Memory Git', email: 'memory@git.local' };
+    operations = [];
+    _stash = [];
+    /**
+     * Creates a new MemoryGit instance
+     * @param name - Unique name to identify the instance
+     */
+    constructor(name = 'memory-git') {
+        this.name = name;
+        this.fs = memfs_1.fs;
+        this.vol = memfs_1.vol;
+        // Clear volume to ensure clean state
+        this.vol.reset();
+    }
+    /**
+     * Logs an operation
+     * @private
+     */
+    _logOperation(operation, params, result = null, error = null) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            operation,
+            params: this._sanitizeParams(params),
+            success: error === null,
+            result: result,
+            error: error ? error.message : null
+        };
+        this.operations.push(entry);
+        return entry;
+    }
+    /**
+     * Removes large data from params for logging
+     * @private
+     */
+    _sanitizeParams(params) {
+        const sanitized = { ...params };
+        if (sanitized.content && typeof sanitized.content === 'string' && sanitized.content.length > 100) {
+            sanitized.content = `[${sanitized.content.length} bytes]`;
+        }
+        if (Buffer.isBuffer(sanitized.content)) {
+            sanitized.content = `[Buffer: ${sanitized.content.length} bytes]`;
+        }
+        return sanitized;
+    }
+    /**
+     * Checks if a path exists on real disk (async)
+     * @private
+     */
+    async _realPathExists(filepath) {
+        try {
+            await fs_1.promises.access(filepath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Sets the author for commits
+     * @param name - Author name
+     * @param email - Author email
+     */
+    setAuthor(name, email) {
+        this.author = { name, email };
+        this._logOperation('setAuthor', { name, email });
+    }
+    /**
+     * Initializes a new repository in memory
+     */
+    async init() {
+        try {
+            this.fs.mkdirSync(this.dir, { recursive: true });
+            await isomorphic_git_1.default.init({ fs: this.fs, dir: this.dir, defaultBranch: 'main' });
+            this.isInitialized = true;
+            this._logOperation('init', { dir: this.dir }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('init', { dir: this.dir }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Loads an existing repository from disk to memory
+     * @param sourcePath - Path to the repository on disk
+     * @param options - Loading options
+     * @returns Number of files loaded
+     */
+    async loadFromDisk(sourcePath, options = {}) {
+        try {
+            this.realDir = path_1.default.resolve(sourcePath);
+            const ignore = options.ignore || ['node_modules', '.pnpm-store'];
+            // Create base directory in memory
+            this.fs.mkdirSync(this.dir, { recursive: true });
+            // Copy recursively from disk to memory (async)
+            const fileCount = await this._copyToMemoryAsync(this.realDir, this.dir, ignore);
+            this.isInitialized = true;
+            this._logOperation('loadFromDisk', { sourcePath: this.realDir, ignore }, {
+                success: true,
+                filesLoaded: fileCount
+            });
+            return fileCount;
+        }
+        catch (error) {
+            this._logOperation('loadFromDisk', { sourcePath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Copies files from real disk to memory filesystem (async)
+     * @private
+     */
+    async _copyToMemoryAsync(realPath, memoryPath, ignore = []) {
+        const entries = await fs_1.promises.readdir(realPath, { withFileTypes: true });
+        // Process entries in parallel for better performance
+        const promises = entries.map(async (entry) => {
+            // Check if should ignore
+            if (ignore.includes(entry.name))
+                return 0;
+            const realEntryPath = path_1.default.join(realPath, entry.name);
+            const memoryEntryPath = path_1.default.posix.join(memoryPath, entry.name);
+            if (entry.isDirectory()) {
+                this.fs.mkdirSync(memoryEntryPath, { recursive: true });
+                return await this._copyToMemoryAsync(realEntryPath, memoryEntryPath, ignore);
+            }
+            else if (entry.isFile()) {
+                const content = await fs_1.promises.readFile(realEntryPath);
+                this.fs.writeFileSync(memoryEntryPath, content);
+                return 1;
+            }
+            return 0;
+        });
+        const results = await Promise.all(promises);
+        return results.reduce((acc, val) => acc + val, 0);
+    }
+    /**
+     * Counts files in a directory in memory
+     * @private
+     */
+    _countFiles(dir) {
+        let count = 0;
+        const entries = this.fs.readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = path_1.default.posix.join(dir, entry);
+            const stat = this.fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                count += this._countFiles(fullPath);
+            }
+            else {
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Writes a file to the in-memory repository
+     * @param filepath - Relative file path
+     * @param content - File content
+     */
+    async writeFile(filepath, content) {
+        try {
+            const fullPath = path_1.default.posix.join(this.dir, filepath);
+            const dir = path_1.default.posix.dirname(fullPath);
+            // Create directories if needed
+            this.fs.mkdirSync(dir, { recursive: true });
+            this.fs.writeFileSync(fullPath, content);
+            this._logOperation('writeFile', { filepath, content }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('writeFile', { filepath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Reads a file from the in-memory repository
+     * @param filepath - Relative file path
+     * @returns File content
+     */
+    async readFile(filepath) {
+        try {
+            const fullPath = path_1.default.posix.join(this.dir, filepath);
+            const content = this.fs.readFileSync(fullPath, 'utf8');
+            this._logOperation('readFile', { filepath }, { success: true, size: content.length });
+            return content;
+        }
+        catch (error) {
+            this._logOperation('readFile', { filepath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Checks if a file exists
+     * @param filepath - Relative file path
+     */
+    async fileExists(filepath) {
+        try {
+            const fullPath = path_1.default.posix.join(this.dir, filepath);
+            return this.fs.existsSync(fullPath);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Deletes a file from the in-memory repository
+     * @param filepath - Relative file path
+     */
+    async deleteFile(filepath) {
+        try {
+            const fullPath = path_1.default.posix.join(this.dir, filepath);
+            this.fs.unlinkSync(fullPath);
+            this._logOperation('deleteFile', { filepath }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('deleteFile', { filepath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Adds file(s) to the staging area
+     * @param filepath - Relative file path(s)
+     */
+    async add(filepath) {
+        try {
+            const files = Array.isArray(filepath) ? filepath : [filepath];
+            for (const file of files) {
+                await isomorphic_git_1.default.add({ fs: this.fs, dir: this.dir, filepath: file });
+            }
+            this._logOperation('add', { filepath: files }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('add', { filepath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Removes file(s) from the staging area and working tree
+     * @param filepath - Relative file path
+     */
+    async remove(filepath) {
+        try {
+            await isomorphic_git_1.default.remove({ fs: this.fs, dir: this.dir, filepath });
+            this._logOperation('remove', { filepath }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('remove', { filepath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Creates a commit with staged changes
+     * @param message - Commit message
+     * @returns SHA of the created commit
+     */
+    async commit(message) {
+        try {
+            const sha = await isomorphic_git_1.default.commit({
+                fs: this.fs,
+                dir: this.dir,
+                message,
+                author: this.author
+            });
+            this._logOperation('commit', { message }, { success: true, sha });
+            return sha;
+        }
+        catch (error) {
+            this._logOperation('commit', { message }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Gets repository status
+     * @returns List of files with their status
+     */
+    async status() {
+        try {
+            const statusMatrix = await isomorphic_git_1.default.statusMatrix({ fs: this.fs, dir: this.dir });
+            const result = statusMatrix.map(([filepath, head, workdir, stage]) => ({
+                filepath: filepath,
+                head: head,
+                workdir: workdir,
+                stage: stage,
+                status: this._getStatusText(head, workdir, stage)
+            }));
+            this._logOperation('status', {}, { success: true, files: result.length });
+            return result;
+        }
+        catch (error) {
+            this._logOperation('status', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Converts numeric status to readable text
+     * @private
+     */
+    _getStatusText(head, workdir, stage) {
+        if (head === 0 && workdir === 2 && stage === 0)
+            return 'new, untracked';
+        if (head === 0 && workdir === 2 && stage === 2)
+            return 'added, staged';
+        if (head === 0 && workdir === 2 && stage === 3)
+            return 'added, staged, with unstaged changes';
+        if (head === 1 && workdir === 1 && stage === 1)
+            return 'unmodified';
+        if (head === 1 && workdir === 2 && stage === 1)
+            return 'modified, unstaged';
+        if (head === 1 && workdir === 2 && stage === 2)
+            return 'modified, staged';
+        if (head === 1 && workdir === 2 && stage === 3)
+            return 'modified, staged, with unstaged changes';
+        if (head === 1 && workdir === 0 && stage === 0)
+            return 'deleted, unstaged';
+        if (head === 1 && workdir === 0 && stage === 1)
+            return 'deleted, staged';
+        if (head === 1 && workdir === 1 && stage === 0)
+            return 'deleted, staged';
+        return `unknown (${head}, ${workdir}, ${stage})`;
+    }
+    /**
+     * Gets commit log
+     * @param depth - Number of commits to return
+     * @returns List of commits
+     */
+    async log(depth = 10) {
+        try {
+            const commits = await isomorphic_git_1.default.log({ fs: this.fs, dir: this.dir, depth });
+            const result = commits.map(commit => ({
+                sha: commit.oid,
+                message: commit.commit.message,
+                author: commit.commit.author.name,
+                email: commit.commit.author.email,
+                timestamp: new Date(commit.commit.author.timestamp * 1000).toISOString()
+            }));
+            this._logOperation('log', { depth }, { success: true, commits: result.length });
+            return result;
+        }
+        catch (error) {
+            this._logOperation('log', { depth }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Creates a new branch
+     * @param branchName - Branch name
+     */
+    async createBranch(branchName) {
+        try {
+            await isomorphic_git_1.default.branch({ fs: this.fs, dir: this.dir, ref: branchName });
+            this._logOperation('createBranch', { branchName }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('createBranch', { branchName }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Deletes a branch
+     * @param branchName - Branch name
+     */
+    async deleteBranch(branchName) {
+        try {
+            await isomorphic_git_1.default.deleteBranch({ fs: this.fs, dir: this.dir, ref: branchName });
+            this._logOperation('deleteBranch', { branchName }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('deleteBranch', { branchName }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Switches to a branch
+     * @param branchName - Branch name
+     */
+    async checkout(branchName) {
+        try {
+            await isomorphic_git_1.default.checkout({ fs: this.fs, dir: this.dir, ref: branchName });
+            this._logOperation('checkout', { branchName }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('checkout', { branchName }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Lists all branches
+     * @returns List of branches
+     */
+    async listBranches() {
+        try {
+            const branches = await isomorphic_git_1.default.listBranches({ fs: this.fs, dir: this.dir });
+            const current = await isomorphic_git_1.default.currentBranch({ fs: this.fs, dir: this.dir });
+            const result = branches.map(branch => ({
+                name: branch,
+                current: branch === current
+            }));
+            this._logOperation('listBranches', {}, { success: true, branches: result });
+            return result;
+        }
+        catch (error) {
+            this._logOperation('listBranches', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Gets the current branch
+     * @returns Current branch name
+     */
+    async currentBranch() {
+        try {
+            const branch = await isomorphic_git_1.default.currentBranch({ fs: this.fs, dir: this.dir });
+            this._logOperation('currentBranch', {}, { success: true, branch });
+            return branch || undefined;
+        }
+        catch (error) {
+            this._logOperation('currentBranch', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Merges a branch into the current branch
+     * @param theirBranch - Branch name to merge
+     */
+    async merge(theirBranch) {
+        try {
+            const result = await isomorphic_git_1.default.merge({
+                fs: this.fs,
+                dir: this.dir,
+                theirs: theirBranch,
+                author: this.author
+            });
+            this._logOperation('merge', { theirBranch }, { success: true, ...result });
+            return result;
+        }
+        catch (error) {
+            this._logOperation('merge', { theirBranch }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Adds a remote
+     * @param remoteName - Remote name
+     * @param url - Remote URL
+     */
+    async addRemote(remoteName, url) {
+        try {
+            await isomorphic_git_1.default.addRemote({ fs: this.fs, dir: this.dir, remote: remoteName, url });
+            this._logOperation('addRemote', { remoteName, url }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('addRemote', { remoteName, url }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Removes a remote
+     * @param remoteName - Remote name
+     */
+    async deleteRemote(remoteName) {
+        try {
+            await isomorphic_git_1.default.deleteRemote({ fs: this.fs, dir: this.dir, remote: remoteName });
+            this._logOperation('deleteRemote', { remoteName }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('deleteRemote', { remoteName }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Lists configured remotes
+     * @returns List of remotes
+     */
+    async listRemotes() {
+        try {
+            const remotes = await isomorphic_git_1.default.listRemotes({ fs: this.fs, dir: this.dir });
+            this._logOperation('listRemotes', {}, { success: true, remotes });
+            return remotes;
+        }
+        catch (error) {
+            this._logOperation('listRemotes', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Creates a tag
+     * @param tagName - Tag name
+     * @param ref - Reference (commit SHA or branch)
+     */
+    async createTag(tagName, ref = 'HEAD') {
+        try {
+            await isomorphic_git_1.default.tag({ fs: this.fs, dir: this.dir, ref: tagName, object: ref });
+            this._logOperation('createTag', { tagName, ref }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('createTag', { tagName, ref }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Lists all tags
+     * @returns List of tags
+     */
+    async listTags() {
+        try {
+            const tags = await isomorphic_git_1.default.listTags({ fs: this.fs, dir: this.dir });
+            this._logOperation('listTags', {}, { success: true, tags });
+            return tags;
+        }
+        catch (error) {
+            this._logOperation('listTags', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Returns the history of all operations performed
+     * @returns List of operations
+     */
+    getOperationsLog() {
+        return [...this.operations];
+    }
+    /**
+     * Clears the operation log
+     */
+    clearOperationsLog() {
+        this.operations = [];
+        this._logOperation('clearOperationsLog', {}, { success: true });
+    }
+    /**
+     * Gets operation statistics
+     * @returns Statistics
+     */
+    getOperationsStats() {
+        const stats = {
+            total: this.operations.length,
+            successful: this.operations.filter(op => op.success).length,
+            failed: this.operations.filter(op => !op.success).length,
+            byOperation: {}
+        };
+        for (const op of this.operations) {
+            if (!stats.byOperation[op.operation]) {
+                stats.byOperation[op.operation] = { total: 0, successful: 0, failed: 0 };
+            }
+            stats.byOperation[op.operation].total++;
+            if (op.success) {
+                stats.byOperation[op.operation].successful++;
+            }
+            else {
+                stats.byOperation[op.operation].failed++;
+            }
+        }
+        return stats;
+    }
+    /**
+     * Exports the operation log in JSON format
+     * @returns JSON string of operations
+     */
+    exportOperationsLog() {
+        return JSON.stringify({
+            name: this.name,
+            exportedAt: new Date().toISOString(),
+            stats: this.getOperationsStats(),
+            operations: this.operations
+        }, null, 2);
+    }
+    /**
+     * Syncs all changes from memory to disk
+     * @param targetPath - Destination path (optional, uses original path if not specified)
+     * @param options - Flush options
+     * @returns Number of files flushed
+     */
+    async flush(targetPath = null, options = {}) {
+        try {
+            const destination = targetPath ? path_1.default.resolve(targetPath) : this.realDir;
+            if (!destination) {
+                throw new Error('No destination path specified and repository was not loaded from disk');
+            }
+            // Create destination directory if it doesn't exist (async)
+            const destinationExists = await this._realPathExists(destination);
+            if (!destinationExists) {
+                await fs_1.promises.mkdir(destination, { recursive: true });
+            }
+            // Copy recursively from memory to disk (async)
+            const fileCount = await this._copyToDiskAsync(this.dir, destination);
+            this._logOperation('flush', { targetPath: destination, options }, {
+                success: true,
+                filesFlushed: fileCount
+            });
+            return fileCount;
+        }
+        catch (error) {
+            this._logOperation('flush', { targetPath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Copies files from memory to disk (async)
+     * @private
+     */
+    async _copyToDiskAsync(memoryPath, realPath) {
+        const entries = this.fs.readdirSync(memoryPath);
+        // Process entries in parallel for better performance
+        const promises = entries.map(async (entry) => {
+            const memoryEntryPath = path_1.default.posix.join(memoryPath, entry);
+            const realEntryPath = path_1.default.join(realPath, entry);
+            const stat = this.fs.statSync(memoryEntryPath);
+            if (stat.isDirectory()) {
+                const dirExists = await this._realPathExists(realEntryPath);
+                if (!dirExists) {
+                    await fs_1.promises.mkdir(realEntryPath, { recursive: true });
+                }
+                return await this._copyToDiskAsync(memoryEntryPath, realEntryPath);
+            }
+            else {
+                const content = this.fs.readFileSync(memoryEntryPath);
+                await fs_1.promises.writeFile(realEntryPath, content);
+                return 1;
+            }
+        });
+        const results = await Promise.all(promises);
+        return results.reduce((acc, val) => acc + val, 0);
+    }
+    /**
+     * Lists files in the in-memory repository
+     * @param dir - Relative directory (optional)
+     * @param includeGit - Include .git folder in listing
+     * @returns List of files
+     */
+    async listFiles(dir = '', includeGit = false) {
+        try {
+            const fullPath = path_1.default.posix.join(this.dir, dir);
+            const files = this._listFilesRecursive(fullPath, '', includeGit);
+            this._logOperation('listFiles', { dir }, { success: true, files: files.length });
+            return files;
+        }
+        catch (error) {
+            this._logOperation('listFiles', { dir }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Lists files recursively
+     * @private
+     */
+    _listFilesRecursive(dir, base = '', includeGit = false) {
+        const files = [];
+        const entries = this.fs.readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = path_1.default.posix.join(dir, entry);
+            const relativePath = base ? path_1.default.posix.join(base, entry) : entry;
+            const stat = this.fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                if (entry === '.git' && !includeGit)
+                    continue;
+                files.push(...this._listFilesRecursive(fullPath, relativePath, includeGit));
+            }
+            else {
+                files.push(relativePath);
+            }
+        }
+        return files;
+    }
+    /**
+     * Gets the diff between working tree and HEAD
+     * @returns List of modified files
+     */
+    async diff() {
+        try {
+            const changes = [];
+            const statusMatrix = await isomorphic_git_1.default.statusMatrix({ fs: this.fs, dir: this.dir });
+            for (const [filepath, head, workdir, stage] of statusMatrix) {
+                if (head !== workdir || head !== stage) {
+                    changes.push({
+                        filepath: filepath,
+                        status: this._getStatusText(head, workdir, stage)
+                    });
+                }
+            }
+            this._logOperation('diff', {}, {
+                success: true,
+                changes: changes.length
+            });
+            return changes;
+        }
+        catch (error) {
+            this._logOperation('diff', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Gets file content at a specific commit
+     * @param filepath - File path
+     * @param ref - Reference (commit SHA, branch, tag)
+     * @returns File content
+     */
+    async readFileAtRef(filepath, ref = 'HEAD') {
+        try {
+            const { blob } = await isomorphic_git_1.default.readBlob({
+                fs: this.fs,
+                dir: this.dir,
+                oid: await isomorphic_git_1.default.resolveRef({ fs: this.fs, dir: this.dir, ref }),
+                filepath
+            });
+            const content = Buffer.from(blob).toString('utf8');
+            this._logOperation('readFileAtRef', { filepath, ref }, { success: true });
+            return content;
+        }
+        catch (error) {
+            this._logOperation('readFileAtRef', { filepath, ref }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Resets file changes
+     * @param filepath - File path
+     */
+    async resetFile(filepath) {
+        try {
+            await isomorphic_git_1.default.checkout({
+                fs: this.fs,
+                dir: this.dir,
+                filepaths: [filepath],
+                force: true
+            });
+            this._logOperation('resetFile', { filepath }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('resetFile', { filepath }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Stashes current changes (simulates by saving in memory)
+     * @returns Number of files saved to stash
+     */
+    async stash() {
+        try {
+            const statusMatrix = await isomorphic_git_1.default.statusMatrix({ fs: this.fs, dir: this.dir });
+            const stashedFiles = [];
+            for (const [filepath, head, workdir] of statusMatrix) {
+                if (workdir === 2 || workdir === 0) {
+                    const fullPath = path_1.default.posix.join(this.dir, filepath);
+                    try {
+                        const content = this.fs.readFileSync(fullPath);
+                        stashedFiles.push({
+                            filepath: filepath,
+                            content: content,
+                            wasNew: head === 0
+                        });
+                    }
+                    catch {
+                        // Deleted file
+                        stashedFiles.push({ filepath: filepath, deleted: true });
+                    }
+                }
+            }
+            this._stash.push(stashedFiles);
+            // Reset to HEAD
+            for (const file of stashedFiles) {
+                const fullPath = path_1.default.posix.join(this.dir, file.filepath);
+                if (file.deleted) {
+                    // Restore deleted file
+                    try {
+                        await isomorphic_git_1.default.checkout({
+                            fs: this.fs,
+                            dir: this.dir,
+                            filepaths: [file.filepath],
+                            force: true
+                        });
+                    }
+                    catch {
+                        // Ignore if didn't exist
+                    }
+                }
+                else if (file.wasNew) {
+                    // Remove new file
+                    try {
+                        this.fs.unlinkSync(fullPath);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                else {
+                    // Restore modified file
+                    await isomorphic_git_1.default.checkout({
+                        fs: this.fs,
+                        dir: this.dir,
+                        filepaths: [file.filepath],
+                        force: true
+                    });
+                }
+            }
+            this._logOperation('stash', {}, { success: true, files: stashedFiles.length });
+            return stashedFiles.length;
+        }
+        catch (error) {
+            this._logOperation('stash', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Restores from stash
+     * @returns Number of files restored
+     */
+    async stashPop() {
+        try {
+            if (this._stash.length === 0) {
+                throw new Error('No stash available');
+            }
+            const stashedFiles = this._stash.pop();
+            for (const file of stashedFiles) {
+                const fullPath = path_1.default.posix.join(this.dir, file.filepath);
+                if (file.deleted) {
+                    try {
+                        this.fs.unlinkSync(fullPath);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                else {
+                    // Create directory if needed
+                    const dir = path_1.default.posix.dirname(fullPath);
+                    this.fs.mkdirSync(dir, { recursive: true });
+                    this.fs.writeFileSync(fullPath, file.content);
+                }
+            }
+            this._logOperation('stashPop', {}, { success: true, files: stashedFiles.length });
+            return stashedFiles.length;
+        }
+        catch (error) {
+            this._logOperation('stashPop', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Lists available stashes
+     * @returns Number of stashes
+     */
+    stashList() {
+        return this._stash.length;
+    }
+    /**
+     * Clones a remote repository to memory
+     * @param url - Repository URL
+     * @param options - Clone options
+     */
+    async clone(url, options = {}) {
+        try {
+            this.fs.mkdirSync(this.dir, { recursive: true });
+            await isomorphic_git_1.default.clone({
+                fs: this.fs,
+                http: node_1.default,
+                dir: this.dir,
+                url,
+                depth: options.depth || undefined,
+                singleBranch: options.singleBranch || false,
+                ...options
+            });
+            this.isInitialized = true;
+            this._logOperation('clone', { url, options }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('clone', { url, options }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Fetches from a remote
+     * @param remote - Remote name (default: 'origin')
+     */
+    async fetch(remote = 'origin') {
+        try {
+            await isomorphic_git_1.default.fetch({
+                fs: this.fs,
+                http: node_1.default,
+                dir: this.dir,
+                remote
+            });
+            this._logOperation('fetch', { remote }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('fetch', { remote }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Pulls from a remote
+     * @param remote - Remote name (default: 'origin')
+     * @param branch - Branch name
+     */
+    async pull(remote = 'origin', branch = null) {
+        try {
+            const currentBranchName = branch || await this.currentBranch();
+            await isomorphic_git_1.default.pull({
+                fs: this.fs,
+                http: node_1.default,
+                dir: this.dir,
+                remote,
+                ref: currentBranchName,
+                author: this.author
+            });
+            this._logOperation('pull', { remote, branch: currentBranchName }, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('pull', { remote, branch }, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Clears the in-memory filesystem and reinitializes
+     */
+    async clear() {
+        try {
+            this.vol.reset();
+            this.isInitialized = false;
+            this._stash = [];
+            this._logOperation('clear', {}, { success: true });
+            return true;
+        }
+        catch (error) {
+            this._logOperation('clear', {}, null, error);
+            throw error;
+        }
+    }
+    /**
+     * Gets repository information
+     * @returns Repository information
+     */
+    async getRepoInfo() {
+        const info = {
+            initialized: this.isInitialized,
+            memoryDir: this.dir,
+            realDir: this.realDir,
+            currentBranch: null,
+            branches: [],
+            remotes: [],
+            fileCount: 0,
+            commits: 0
+        };
+        if (this.isInitialized) {
+            info.currentBranch = (await this.currentBranch()) || null;
+            info.branches = await this.listBranches();
+            info.remotes = await this.listRemotes();
+            info.fileCount = this._countFiles(this.dir);
+            try {
+                const logEntries = await isomorphic_git_1.default.log({ fs: this.fs, dir: this.dir });
+                info.commits = logEntries.length;
+            }
+            catch {
+                // Repo without commits
+            }
+        }
+        return info;
+    }
+    /**
+     * Gets estimated memory usage
+     * @returns Memory usage information
+     */
+    getMemoryUsage() {
+        const json = this.vol.toJSON();
+        const totalSize = Object.values(json).reduce((acc, content) => {
+            if (typeof content === 'string') {
+                return acc + content.length;
+            }
+            return acc;
+        }, 0);
+        return {
+            files: Object.keys(json).length,
+            estimatedSizeBytes: totalSize,
+            estimatedSizeMB: (totalSize / 1024 / 1024).toFixed(2),
+            operationsLogged: this.operations.length
+        };
+    }
+}
+exports.MemoryGit = MemoryGit;
+//# sourceMappingURL=index.js.map