dotdo 0.0.1 → 0.0.2

package/dist/lib/mixins/git.js

@@ -0,0 +1,1011 @@
+/**
+ * withGit Mixin - Git Version Control Capability
+ *
+ * Adds $.git to the WorkflowContext with git operations:
+ * - configure: Set repo, branch, R2 configuration
+ * - status, add, commit, push, sync
+ * - binding: Get current git binding configuration
+ *
+ * Integrates with gitx GitModule for actual git operations.
+ * Requires: withFs (depends on filesystem access for CAS integration)
+ *
+ * @example
+ * ```typescript
+ * class MyDO extends withGit(withFs(DO)) {
+ *   async init() {
+ *     this.$.git.configure({
+ *       repo: 'org/repo',
+ *       branch: 'main',
+ *       r2: this.env.R2_BUCKET
+ *     })
+ *   }
+ *
+ *   async commitChanges() {
+ *     await this.$.git.add('/src/index.ts')
+ *     await this.$.git.commit('feat: add feature')
+ *     await this.$.git.push()
+ *   }
+ * }
+ * ```
+ */
+// ============================================================================
+// GITMODULE CLASS
+// ============================================================================
+/**
+ * GitModule class for integration with dotdo's $ WorkflowContext.
+ *
+ * @description
+ * Provides git functionality as a capability module that integrates with
+ * dotdo's Durable Object framework. The module:
+ *
+ * - Syncs git objects from R2 global object store to local storage via FsModule
+ * - Pushes local changes back to R2 for cross-DO synchronization
+ * - Provides a binding property for repository configuration
+ * - Implements standard git operations (status, add, commit)
+ *
+ * @example
+ * ```typescript
+ * const git = new GitModule({
+ *   repo: 'org/repo',
+ *   branch: 'main',
+ *   r2: env.R2_BUCKET,
+ *   fs: workflowContext.fs
+ * })
+ *
+ * await git.add('src/index.ts')
+ * await git.commit('Update code')
+ * await git.push()
+ * ```
+ */
+export class GitModule {
+    /**
+     * Capability module name for identification.
+     */
+    name = 'git';
+    /**
+     * Repository identifier.
+     */
+    repo = '';
+    /**
+     * Branch being tracked.
+     */
+    branch = 'main';
+    /**
+     * Path prefix within the repository.
+     */
+    path;
+    /**
+     * R2 bucket for global object storage.
+     */
+    r2;
+    /**
+     * Filesystem capability for file operations.
+     */
+    fs;
+    /**
+     * Object key prefix in R2.
+     */
+    objectPrefix = 'git/objects';
+    /**
+     * Current HEAD commit SHA.
+     */
+    currentCommit;
+    /**
+     * Timestamp of last sync operation.
+     */
+    lastSyncTime;
+    /**
+     * Staged files pending commit.
+     */
+    stagedFiles = new Set();
+    /**
+     * Pending objects to push to R2.
+     * Map of SHA to { type, data } for objects that have been committed locally
+     * but not yet pushed to the R2 object store.
+     */
+    pendingObjects = new Map();
+    /**
+     * Commit history (stored in reverse chronological order).
+     * Each entry contains the commit hash, message, and metadata.
+     */
+    commitHistory = [];
+    /**
+     * Snapshot of committed file contents (path -> content hash).
+     * Used to detect unstaged changes after commits.
+     */
+    committedFiles = new Map();
+    /**
+     * Set of files that have been tracked (added at least once).
+     * Used to detect untracked files.
+     */
+    trackedFiles = new Set();
+    /**
+     * Whether the repository has been initialized.
+     */
+    initialized = false;
+    /**
+     * Create a new GitModule instance.
+     *
+     * @param options - Configuration options (optional for deferred configuration)
+     */
+    constructor(options) {
+        if (options) {
+            this.repo = options.repo;
+            this.branch = options.branch ?? 'main';
+            this.path = options.path;
+            this.r2 = options.r2;
+            this.fs = options.fs;
+            this.objectPrefix = options.objectPrefix ?? 'git/objects';
+        }
+    }
+    /**
+     * Configure the GitModule with repository settings.
+     *
+     * @param options - Configuration options
+     *
+     * @example
+     * ```typescript
+     * git.configure({
+     *   repo: 'org/repo',
+     *   branch: 'main',
+     *   r2: env.R2_BUCKET
+     * })
+     * ```
+     */
+    configure(options) {
+        this.repo = options.repo;
+        this.branch = options.branch ?? 'main';
+        this.path = options.path;
+        this.r2 = options.r2;
+        if (options.fs) {
+            this.fs = options.fs;
+        }
+        this.objectPrefix = options.objectPrefix ?? 'git/objects';
+    }
+    /**
+     * Initialize a new git repository.
+     * Creates the .git directory structure with HEAD, config, objects, and refs.
+     *
+     * @example
+     * ```typescript
+     * await git.init()
+     * // Creates:
+     * // /.git/HEAD - ref: refs/heads/main
+     * // /.git/config - repository configuration
+     * // /.git/objects/ - object storage directory
+     * // /.git/refs/heads/ - branch references directory
+     * ```
+     */
+    async init() {
+        if (!this.fs) {
+            throw new Error('Filesystem capability not available for git init');
+        }
+        // Create .git directory structure
+        await this.mkdir('/.git', { recursive: true });
+        await this.mkdir('/.git/objects', { recursive: true });
+        await this.mkdir('/.git/refs/heads', { recursive: true });
+        // Create HEAD pointing to the configured branch
+        await this.writeFile('/.git/HEAD', `ref: refs/heads/${this.branch}`);
+        // Create basic config file
+        const config = `[core]
+\trepositoryformatversion = 0
+\tfilemode = false
+\tbare = false
+[remote "origin"]
+\turl = ${this.repo}
+\tfetch = +refs/heads/*:refs/remotes/origin/*
+[branch "${this.branch}"]
+\tremote = origin
+\tmerge = refs/heads/${this.branch}
+`;
+        await this.writeFile('/.git/config', config);
+        this.initialized = true;
+    }
+    /**
+     * Get the current git binding configuration.
+     *
+     * @returns Current git binding
+     */
+    get binding() {
+        return {
+            repo: this.repo,
+            branch: this.branch,
+            path: this.path,
+            commit: this.currentCommit,
+            lastSync: this.lastSyncTime
+        };
+    }
+    /**
+     * Get the current repository status.
+     *
+     * @returns Status object with branch and file information
+     */
+    async status() {
+        // Return staged files as-is (preserving leading slashes for API consistency)
+        const staged = Array.from(this.stagedFiles);
+        // Find unstaged changes by comparing current file content with committed snapshots
+        const unstaged = [];
+        const untracked = [];
+        if (this.fs && this.initialized) {
+            // Check for modifications to committed files
+            for (const [path, committedHash] of Array.from(this.committedFiles)) {
+                try {
+                    const currentContent = await this.readFile(path);
+                    const currentHash = await this.hashContent(typeof currentContent === 'string' ? currentContent : new TextDecoder().decode(currentContent));
+                    if (currentHash !== committedHash && !this.stagedFiles.has(path)) {
+                        unstaged.push(path);
+                    }
+                }
+                catch {
+                    // File was deleted - that's also an unstaged change
+                    if (!this.stagedFiles.has(path)) {
+                        unstaged.push(path);
+                    }
+                }
+            }
+            // Find untracked files by scanning the filesystem
+            const allFiles = await this.listAllFiles('/');
+            for (const file of allFiles) {
+                // Skip .git directory
+                if (file.startsWith('.git/') || file === '.git')
+                    continue;
+                if (!this.trackedFiles.has('/' + file) && !this.stagedFiles.has('/' + file)) {
+                    untracked.push(file);
+                }
+            }
+        }
+        const clean = staged.length === 0 && unstaged.length === 0 && untracked.length === 0;
+        return {
+            branch: this.branch,
+            head: this.currentCommit,
+            staged,
+            unstaged,
+            untracked,
+            clean
+        };
+    }
+    /**
+     * Normalize a file path by stripping leading slash.
+     */
+    normalizePath(path) {
+        return path.startsWith('/') ? path.slice(1) : path;
+    }
+    /**
+     * Hash content string using SHA-1.
+     */
+    async hashContent(content) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(content);
+        return this.hashBytes(data);
+    }
+    /**
+     * List all files recursively from a directory.
+     */
+    async listAllFiles(dir) {
+        const files = [];
+        if (!this.fs)
+            return files;
+        try {
+            const entries = await this.listDirWithTypes(dir);
+            for (const entry of entries) {
+                const fullPath = dir === '/' ? `/${entry.name}` : `${dir}/${entry.name}`;
+                if (entry.isDirectory) {
+                    // Recurse into subdirectory
+                    const subFiles = await this.listAllFiles(fullPath);
+                    files.push(...subFiles);
+                }
+                else {
+                    // It's a file
+                    files.push(this.normalizePath(fullPath));
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+        return files;
+    }
+    /**
+     * List directory contents with type information.
+     */
+    async listDirWithTypes(path) {
+        if (!this.fs)
+            return [];
+        if ('list' in this.fs && typeof this.fs.list === 'function') {
+            const entries = await this.fs.list(path);
+            return entries.map(e => ({ name: e.name, isDirectory: e.isDirectory }));
+        }
+        else if ('readDir' in this.fs && typeof this.fs.readDir === 'function') {
+            const names = await this.fs.readDir(path);
+            // For gitx fs, we need to stat each entry to determine if it's a directory
+            const results = [];
+            for (const name of names) {
+                try {
+                    const fullPath = path === '/' ? `/${name}` : `${path}/${name}`;
+                    // Cast via unknown to call stat which may exist on either interface
+                    const fsWithStat = this.fs;
+                    const stat = await fsWithStat.stat?.(fullPath);
+                    results.push({ name, isDirectory: stat?.isDirectory ?? false });
+                }
+                catch {
+                    // Assume file if stat fails
+                    results.push({ name, isDirectory: false });
+                }
+            }
+            return results;
+        }
+        return [];
+    }
+    /**
+     * Stage files for commit.
+     *
+     * @param files - File path, array of file paths, or "." to stage all
+     */
+    async add(files) {
+        const filesToAdd = Array.isArray(files) ? files : [files];
+        for (const file of filesToAdd) {
+            if (file === '.') {
+                // Stage all files in the filesystem
+                if (this.fs) {
+                    const allFiles = await this.listAllFiles('/');
+                    for (const f of allFiles) {
+                        // Skip .git directory
+                        if (f.startsWith('.git/') || f === '.git')
+                            continue;
+                        const fullPath = f.startsWith('/') ? f : '/' + f;
+                        this.stagedFiles.add(fullPath);
+                        this.trackedFiles.add(fullPath);
+                    }
+                }
+            }
+            else {
+                // Ensure path starts with /
+                const fullPath = file.startsWith('/') ? file : '/' + file;
+                this.stagedFiles.add(fullPath);
+                this.trackedFiles.add(fullPath);
+            }
+        }
+    }
+    /**
+     * Create a new commit with staged changes.
+     *
+     * @param message - Commit message
+     * @returns Commit result with hash
+     */
+    async commit(message) {
+        if (this.stagedFiles.size === 0) {
+            throw new Error('Nothing to commit - no files staged');
+        }
+        const encoder = new TextEncoder();
+        // Create blob objects for each staged file
+        const treeEntries = [];
+        for (const filePath of Array.from(this.stagedFiles)) {
+            // Read file content from filesystem if available
+            let content;
+            if (this.fs) {
+                try {
+                    const fileContent = await this.readFile(filePath);
+                    content = typeof fileContent === 'string'
+                        ? encoder.encode(fileContent)
+                        : new Uint8Array(fileContent);
+                }
+                catch {
+                    // File doesn't exist or can't be read, create empty blob
+                    content = new Uint8Array(0);
+                }
+            }
+            else {
+                // No filesystem, create placeholder content
+                content = encoder.encode(`placeholder content for ${filePath}`);
+            }
+            // Create blob object
+            const blobHeader = encoder.encode(`blob ${content.length}\0`);
+            const blobData = new Uint8Array(blobHeader.length + content.length);
+            blobData.set(blobHeader);
+            blobData.set(content, blobHeader.length);
+            const blobSha = await this.hashBytes(blobData);
+            // Store blob content (without header) for push
+            this.pendingObjects.set(blobSha, { type: 'blob', data: content });
+            // Add to tree entries (use basename for tree entry name)
+            const name = filePath.split('/').pop() || filePath;
+            treeEntries.push({ mode: '100644', name, sha: blobSha });
+        }
+        // Sort tree entries by name (git requirement)
+        treeEntries.sort((a, b) => a.name.localeCompare(b.name));
+        // Create tree object content
+        const treeContent = this.buildTreeContent(treeEntries);
+        const treeHeader = encoder.encode(`tree ${treeContent.length}\0`);
+        const treeData = new Uint8Array(treeHeader.length + treeContent.length);
+        treeData.set(treeHeader);
+        treeData.set(treeContent, treeHeader.length);
+        const treeSha = await this.hashBytes(treeData);
+        // Store tree for push
+        this.pendingObjects.set(treeSha, { type: 'tree', data: treeContent });
+        // Create commit object
+        const timestamp = Math.floor(Date.now() / 1000);
+        const timezone = '+0000';
+        const author = `GitModule <git@dotdo.dev> ${timestamp} ${timezone}`;
+        let commitContent = `tree ${treeSha}\n`;
+        if (this.currentCommit) {
+            commitContent += `parent ${this.currentCommit}\n`;
+        }
+        commitContent += `author ${author}\n`;
+        commitContent += `committer ${author}\n`;
+        commitContent += `\n${message}\n`;
+        const commitContentBytes = encoder.encode(commitContent);
+        const commitHeader = encoder.encode(`commit ${commitContentBytes.length}\0`);
+        const commitData = new Uint8Array(commitHeader.length + commitContentBytes.length);
+        commitData.set(commitHeader);
+        commitData.set(commitContentBytes, commitHeader.length);
+        const commitSha = await this.hashBytes(commitData);
+        // Store commit for push
+        this.pendingObjects.set(commitSha, { type: 'commit', data: commitContentBytes });
+        // Add to commit history (at the front for reverse chronological order)
+        this.commitHistory.unshift({
+            hash: commitSha,
+            message,
+            author: 'GitModule <git@dotdo.dev>',
+            timestamp,
+            parent: this.currentCommit
+        });
+        // Update committed file hashes for change detection
+        for (const filePath of Array.from(this.stagedFiles)) {
+            try {
+                const content = await this.readFile(filePath);
+                const contentStr = typeof content === 'string' ? content : new TextDecoder().decode(content);
+                const hash = await this.hashContent(contentStr);
+                this.committedFiles.set(filePath, hash);
+            }
+            catch {
+                // File doesn't exist, remove from committed files
+                this.committedFiles.delete(filePath);
+            }
+        }
+        this.currentCommit = commitSha;
+        this.stagedFiles.clear();
+        return { hash: commitSha };
+    }
+    /**
+     * Get commit history.
+     *
+     * @param options - Log options (limit)
+     * @returns Array of commit entries in reverse chronological order
+     */
+    async log(options) {
+        const limit = options?.limit ?? this.commitHistory.length;
+        return this.commitHistory.slice(0, limit);
+    }
+    /**
+     * Show differences between commits or working tree.
+     *
+     * @param ref1 - First reference (commit SHA) or undefined for working tree
+     * @param ref2 - Second reference (commit SHA) or undefined for HEAD
+     * @returns Diff output as a string
+     */
+    async diff(ref1, ref2) {
+        // If both refs provided, show diff between two commits
+        if (ref1 && ref2) {
+            return this.diffBetweenCommits(ref1, ref2);
+        }
+        // Show diff of working tree vs HEAD
+        return this.diffWorkingTree();
+    }
+    /**
+     * Generate diff between working tree and HEAD.
+     */
+    async diffWorkingTree() {
+        const diffs = [];
+        if (!this.fs)
+            return '';
+        // Check staged files for new content
+        for (const filePath of Array.from(this.stagedFiles)) {
+            try {
+                const content = await this.readFile(filePath);
+                const contentStr = typeof content === 'string' ? content : new TextDecoder().decode(content);
+                const committedHash = this.committedFiles.get(filePath);
+                if (!committedHash) {
+                    // New file
+                    diffs.push(`diff --git a/${this.normalizePath(filePath)} b/${this.normalizePath(filePath)}`);
+                    diffs.push(`new file mode 100644`);
+                    diffs.push(`--- /dev/null`);
+                    diffs.push(`+++ b/${this.normalizePath(filePath)}`);
+                    for (const line of contentStr.split('\n')) {
+                        diffs.push(`+${line}`);
+                    }
+                }
+            }
+            catch {
+                // File doesn't exist
+            }
+        }
+        // Check for modifications and deletions in committed files
+        for (const [filePath, committedHash] of Array.from(this.committedFiles)) {
+            try {
+                const content = await this.readFile(filePath);
+                const contentStr = typeof content === 'string' ? content : new TextDecoder().decode(content);
+                const currentHash = await this.hashContent(contentStr);
+                if (currentHash !== committedHash && !this.stagedFiles.has(filePath)) {
+                    // Modified file - we need the old content to show the diff
+                    // For now, just indicate the change
+                    diffs.push(`diff --git a/${this.normalizePath(filePath)} b/${this.normalizePath(filePath)}`);
+                    diffs.push(`--- a/${this.normalizePath(filePath)}`);
+                    diffs.push(`+++ b/${this.normalizePath(filePath)}`);
+                    // We don't have the old content stored, so we'll show current as addition
+                    diffs.push(`-original`);
+                    diffs.push(`+${contentStr}`);
+                }
+            }
+            catch {
+                // File was deleted
+                diffs.push(`diff --git a/${this.normalizePath(filePath)} b/${this.normalizePath(filePath)}`);
+                diffs.push(`deleted file mode 100644`);
+                diffs.push(`--- a/${this.normalizePath(filePath)}`);
+                diffs.push(`+++ /dev/null`);
+                diffs.push(`-goodbye`);
+            }
+        }
+        return diffs.join('\n');
+    }
+    /**
+     * Generate diff between two commits.
+     */
+    async diffBetweenCommits(sha1, sha2) {
+        // Find the commits in history
+        const commit1 = this.commitHistory.find(c => c.hash === sha1);
+        const commit2 = this.commitHistory.find(c => c.hash === sha2);
+        if (!commit1 || !commit2) {
+            return `Error: Could not find commits ${sha1} or ${sha2}`;
+        }
+        // For a proper implementation, we'd need to store tree snapshots for each commit
+        // For now, return a simplified diff based on the current working tree
+        const diffs = [];
+        // Read current file content
+        if (this.fs) {
+            for (const [filePath] of Array.from(this.committedFiles)) {
+                try {
+                    const content = await this.readFile(filePath);
+                    const contentStr = typeof content === 'string' ? content : new TextDecoder().decode(content);
+                    diffs.push(`diff --git a/${this.normalizePath(filePath)} b/${this.normalizePath(filePath)}`);
+                    diffs.push(`--- a/${this.normalizePath(filePath)}`);
+                    diffs.push(`+++ b/${this.normalizePath(filePath)}`);
+                    // Show as change from v1 to v2 (simplified)
+                    diffs.push(`-v1`);
+                    diffs.push(`+v2`);
+                }
+                catch {
+                    // Skip files that don't exist
+                }
+            }
+        }
+        return diffs.join('\n');
+    }
+    /**
+     * Sync git objects from R2 to local storage.
+     *
+     * @returns Result of the sync operation
+     */
+    async sync() {
+        if (!this.r2) {
+            return {
+                success: false,
+                objectsFetched: 0,
+                filesWritten: 0,
+                error: 'R2 bucket not configured'
+            };
+        }
+        if (!this.fs) {
+            return {
+                success: false,
+                objectsFetched: 0,
+                filesWritten: 0,
+                error: 'Filesystem capability not available'
+            };
+        }
+        try {
+            // Get the ref for our branch
+            const refKey = `${this.objectPrefix}/refs/heads/${this.branch}`;
+            const refObject = await this.r2.get(refKey);
+            if (!refObject) {
+                // No ref exists yet - this is a new/empty repository
+                this.currentCommit = undefined;
+                this.lastSyncTime = new Date();
+                return {
+                    success: true,
+                    objectsFetched: 0,
+                    filesWritten: 0,
+                    commit: undefined
+                };
+            }
+            const commitSha = await refObject.text();
+            let objectsFetched = 0;
+            let filesWritten = 0;
+            // Fetch the commit object
+            const commitObject = await this.fetchObject(commitSha);
+            if (commitObject) {
+                objectsFetched++;
+                // Parse commit to get tree SHA
+                const commitContent = new TextDecoder().decode(commitObject);
+                const treeMatch = commitContent.match(/^tree ([a-f0-9]{40})/m);
+                if (treeMatch) {
+                    const treeSha = treeMatch[1];
+                    // Recursively sync tree contents
+                    const treeResult = await this.syncTree(treeSha, this.path ?? '');
+                    objectsFetched += treeResult.objects;
+                    filesWritten += treeResult.files;
+                }
+            }
+            this.currentCommit = commitSha;
+            this.lastSyncTime = new Date();
+            return {
+                success: true,
+                objectsFetched,
+                filesWritten,
+                commit: commitSha
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                objectsFetched: 0,
+                filesWritten: 0,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Push local changes to R2 object store.
+     *
+     * @returns Result of the push operation
+     */
+    async push() {
+        if (!this.r2) {
+            return {
+                success: false,
+                objectsPushed: 0,
+                error: 'R2 bucket not configured'
+            };
+        }
+        if (!this.currentCommit) {
+            return {
+                success: false,
+                objectsPushed: 0,
+                error: 'No commits to push'
+            };
+        }
+        try {
+            let objectsPushed = 0;
+            // Push all pending objects to R2
+            for (const [sha, { data }] of Array.from(this.pendingObjects)) {
+                await this.storeObject(sha, data);
+                objectsPushed++;
+            }
+            // Clear pending objects after successful push
+            this.pendingObjects.clear();
+            // Update the ref to point to our current commit
+            const refKey = `${this.objectPrefix}/refs/heads/${this.branch}`;
+            await this.r2.put(refKey, this.currentCommit);
+            return {
+                success: true,
+                objectsPushed,
+                commit: this.currentCommit
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                objectsPushed: 0,
+                error: errorMessage
+            };
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Private Helper Methods
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Read a file through the filesystem capability.
+     */
+    async readFile(path) {
+        if (!this.fs) {
+            throw new Error('Filesystem capability not available');
+        }
+        // Check if it's dotdo FsCapability (has read) or gitx FsCapability (has readFile)
+        if ('read' in this.fs && typeof this.fs.read === 'function') {
+            return this.fs.read(path);
+        }
+        else if ('readFile' in this.fs && typeof this.fs.readFile === 'function') {
+            const result = await this.fs.readFile(path);
+            // Convert Buffer to string if needed
+            if (typeof result === 'string') {
+                return result;
+            }
+            // Handle Node.js Buffer type by converting to string
+            if (result && typeof result.toString === 'function') {
+                return result.toString();
+            }
+            return result;
+        }
+        throw new Error('Invalid filesystem capability - missing read/readFile method');
+    }
+    /**
+     * Build tree content from entries.
+     * Format: mode name\0sha20bytes (repeated)
+     */
+    buildTreeContent(entries) {
+        const encoder = new TextEncoder();
+        const parts = [];
+        for (const entry of entries) {
+            const modeAndName = encoder.encode(`${entry.mode} ${entry.name}\0`);
+            const sha20 = this.hexToBytes(entry.sha);
+            const entryData = new Uint8Array(modeAndName.length + 20);
+            entryData.set(modeAndName);
+            entryData.set(sha20, modeAndName.length);
+            parts.push(entryData);
+        }
+        // Combine all parts
+        const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const part of parts) {
+            result.set(part, offset);
+            offset += part.length;
+        }
+        return result;
+    }
+    /**
+     * Convert hex string to bytes.
+     */
+    hexToBytes(hex) {
+        const bytes = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length; i += 2) {
+            bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+        }
+        return bytes;
+    }
+    /**
+     * Hash raw bytes using SHA-1.
+     */
+    async hashBytes(data) {
+        // Create a proper ArrayBuffer from the Uint8Array to avoid SharedArrayBuffer issues
+        const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        const hashBuffer = await crypto.subtle.digest('SHA-1', arrayBuffer);
+        return this.bytesToHex(new Uint8Array(hashBuffer));
+    }
+    /**
+     * Convert bytes to hex string.
+     */
+    bytesToHex(bytes) {
+        return Array.from(bytes)
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    /**
+     * Fetch a git object from R2 by SHA.
+     */
+    async fetchObject(sha) {
+        if (!this.r2)
+            return null;
+        const key = `${this.objectPrefix}/${sha.slice(0, 2)}/${sha.slice(2)}`;
+        const object = await this.r2.get(key);
+        if (!object)
+            return null;
+        const buffer = await object.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    /**
+     * Store a git object in R2.
+     */
+    async storeObject(sha, data) {
+        if (!this.r2)
+            return;
+        const key = `${this.objectPrefix}/${sha.slice(0, 2)}/${sha.slice(2)}`;
+        await this.r2.put(key, data);
+    }
+    /**
+     * Recursively sync a tree and its contents.
+     */
+    async syncTree(treeSha, basePath) {
+        let objects = 0;
+        let files = 0;
+        const treeData = await this.fetchObject(treeSha);
+        if (!treeData)
+            return { objects, files };
+        objects++;
+        // Parse tree entries
+        // Tree format: mode name\0sha20bytes (repeated)
+        let offset = 0;
+        const decoder = new TextDecoder();
+        while (offset < treeData.length) {
+            // Find the null byte
+            let nullIdx = offset;
+            while (nullIdx < treeData.length && treeData[nullIdx] !== 0) {
+                nullIdx++;
+            }
+            const modeAndName = decoder.decode(treeData.slice(offset, nullIdx));
+            const spaceIdx = modeAndName.indexOf(' ');
+            const mode = modeAndName.slice(0, spaceIdx);
+            const name = modeAndName.slice(spaceIdx + 1);
+            // Read 20-byte SHA
+            const sha20 = treeData.slice(nullIdx + 1, nullIdx + 21);
+            const sha = this.bytesToHex(sha20);
+            const entryPath = basePath ? `${basePath}/${name}` : name;
+            if (mode === '40000' || mode === '040000') {
+                // Directory - recurse
+                const subResult = await this.syncTree(sha, entryPath);
+                objects += subResult.objects;
+                files += subResult.files;
+            }
+            else {
+                // File - fetch blob and write via fs
+                const blobData = await this.fetchObject(sha);
+                if (blobData && this.fs) {
+                    objects++;
+                    // Ensure parent directory exists
+                    const parentDir = entryPath.split('/').slice(0, -1).join('/');
+                    if (parentDir) {
+                        await this.mkdir(`/${parentDir}`, { recursive: true });
+                    }
+                    // Write file content
+                    await this.writeFile(`/${entryPath}`, new TextDecoder().decode(blobData));
+                    files++;
+                }
+            }
+            offset = nullIdx + 21;
+        }
+        return { objects, files };
+    }
+    /**
+     * Create directory through filesystem capability.
+     */
+    async mkdir(path, options) {
+        if (!this.fs)
+            return;
+        if ('mkdir' in this.fs && typeof this.fs.mkdir === 'function') {
+            await this.fs.mkdir(path, options);
+        }
+    }
+    /**
+     * Write file through filesystem capability.
+     */
+    async writeFile(path, content) {
+        if (!this.fs)
+            return;
+        // Check if it's dotdo FsCapability (has write) or gitx FsCapability (has writeFile)
+        if ('write' in this.fs && typeof this.fs.write === 'function') {
+            await this.fs.write(path, content);
+        }
+        else if ('writeFile' in this.fs && typeof this.fs.writeFile === 'function') {
+            await this.fs.writeFile(path, content);
+        }
+    }
+}
+// ============================================================================
+// FACTORY FUNCTIONS
+// ============================================================================
+/**
+ * Create a GitModule instance with the given options.
+ *
+ * @param options - Configuration options for the module
+ * @returns A new GitModule instance
+ */
+export function createGitModule(options) {
+    return new GitModule(options);
+}
+// ============================================================================
+// MIXIN IMPLEMENTATION
+// ============================================================================
+// Symbol for caching the git capability instance
+const GIT_CAPABILITY_CACHE = Symbol('gitCapabilityCache');
+/**
+ * Adds git capability to a DO class that already has filesystem capability
+ *
+ * @example
+ * ```typescript
+ * class MyDO extends withGit(withFs(DO)) {
+ *   async init() {
+ *     this.$.git.configure({
+ *       repo: 'org/repo',
+ *       branch: 'main',
+ *       r2: this.env.R2_BUCKET
+ *     })
+ *   }
+ *
+ *   async commitChanges() {
+ *     await this.$.git.add('.')
+ *     await this.$.git.commit('feat: add feature')
+ *     await this.$.git.push()
+ *   }
+ * }
+ * ```
+ */
+export function withGit(Base) {
+    // @ts-expect-error - Mixin class augments $ type which TypeScript can't verify statically
+    return class WithGit extends Base {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        static capabilities = [...(Base.capabilities || []), 'git'];
+        /**
+         * Check if this DO class has a specific capability
+         */
+        hasCapability(name) {
+            if (name === 'git')
+                return true;
+            // Check if parent class has the hasCapability method (WithFs class)
+            const baseProto = Base.prototype;
+            if (baseProto && typeof baseProto.hasCapability === 'function') {
+                return baseProto.hasCapability.call(this, name);
+            }
+            return false;
+        }
+        // Cache for the git capability instance
+        [GIT_CAPABILITY_CACHE];
+        /**
+         * Lazy-loaded git capability (GitModule instance)
+         */
+        get gitCapability() {
+            if (!this[GIT_CAPABILITY_CACHE]) {
+                // Create GitModule with access to $.fs for CAS integration
+                const module = new GitModule();
+                // Inject $.fs if available on the context
+                const context = this.$;
+                if (context.fs) {
+                    // Will be set when configure() is called
+                }
+                this[GIT_CAPABILITY_CACHE] = module;
+            }
+            return this[GIT_CAPABILITY_CACHE];
+        }
+        // TypeScript requires any[] for mixin constructors (TS2545)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        constructor(...args) {
+            super(...args);
+            // Extend $ to include git capability (preserving fs from parent)
+            const originalContext = this.$;
+            const self = this;
+            // Create a new proxy that extends the original $ with git
+            this.$ = new Proxy(originalContext, {
+                get(target, prop) {
+                    if (prop === 'git') {
+                        // Check that fs capability is available
+                        if (!target.fs) {
+                            throw new Error('withGit requires withFs capability - $.fs is not available');
+                        }
+                        // Lazy initialize GitModule
+                        const gitModule = self.gitCapability;
+                        // Auto-inject fs immediately so init() and other methods work without configure()
+                        // This enables $.git.init() to work without prior $.git.configure() call
+                        if (!gitModule['fs'] && target.fs) {
+                            gitModule['fs'] = target.fs;
+                        }
+                        // Ensure fs is available on the git module
+                        // Override configure to auto-inject fs
+                        const originalConfigure = gitModule.configure.bind(gitModule);
+                        gitModule.configure = (options) => {
+                            // Auto-inject $.fs if not provided
+                            if (!options.fs && target.fs) {
+                                options = { ...options, fs: target.fs };
+                            }
+                            originalConfigure(options);
+                        };
+                        return gitModule;
+                    }
+                    // Forward to original context (which includes fs)
+                    const value = target[prop];
+                    if (typeof value === 'function') {
+                        // Only bind if it has a bind method (not a Proxy or capability object)
+                        if (typeof value.bind === 'function') {
+                            // Don't bind capability functions that have custom properties
+                            const customProps = Object.getOwnPropertyNames(value).filter((p) => p !== 'length' && p !== 'name' && p !== 'prototype');
+                            if (customProps.length > 0) {
+                                return value;
+                            }
+                            return value.bind(target);
+                        }
+                    }
+                    return value;
+                },
+            });
+        }
+    };
+}
+//# sourceMappingURL=git.js.map