gitx.do 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# gitx.do
+
+Git on Cloudflare Durable Objects - A complete Git reimplementation for the edge.
+
+## Features
+
+- **Pack Files** - Full Git packfile v2/v3 support with delta compression
+- **Wire Protocol** - Smart HTTP protocol implementation for fetch/push operations
+- **MCP Tools** - Model Context Protocol integration for AI-assisted git operations
+- **Tiered Storage** - Hot/warm/cold storage tiers with automatic promotion
+  - Hot: Durable Object SQLite (low latency)
+  - Warm: R2 object storage (packed objects)
+  - Cold: Analytics/Parquet (cold storage)
+
+## Installation
+
+```bash
+npm install gitx.do
+```
+
+## Quick Start
+
+### Pack Index Operations
+
+```typescript
+import { parsePackIndex, createPackIndex, lookupObject } from 'gitx.do/pack'
+
+// Parse an existing pack index
+const index = parsePackIndex(indexData)
+console.log(`Pack contains ${index.objectCount} objects`)
+
+// Look up an object by SHA
+const entry = lookupObject(index, 'abc123...')
+if (entry) {
+  console.log(`Object at offset ${entry.offset}`)
+}
+
+// Create a new pack index
+const newIndex = createPackIndex({ packData })
+```
+
+### Smart HTTP Protocol
+
+```typescript
+import { handleInfoRefs, handleUploadPack, handleReceivePack } from 'gitx.do/wire/smart-http'
+
+// Handle ref discovery
+const response = await handleInfoRefs(request, repository, {
+  sideBand64k: true,
+  ofsDelta: true
+})
+
+// Handle fetch
+const packResponse = await handleUploadPack(request, repository)
+
+// Handle push
+const pushResponse = await handleReceivePack(request, repository)
+```
+
+### MCP Tools
+
+```typescript
+import { gitTools, invokeTool, registerTool } from 'gitx.do/mcp/tools'
+
+// List available git tools
+console.log(gitTools.map(t => t.name))
+// ['git_status', 'git_log', 'git_diff', 'git_commit', ...]
+
+// Invoke a tool
+const result = await invokeTool('git_status', { path: '/repo', short: true })
+
+// Register a custom tool
+registerTool({
+  name: 'my_tool',
+  description: 'Custom git operation',
+  inputSchema: { type: 'object', properties: {} },
+  handler: async (params) => ({ content: [{ type: 'text', text: 'Done' }] })
+})
+```
+
+### Tiered Storage
+
+```typescript
+import { TieredReader } from 'gitx.do/tiered/read-path'
+
+const reader = new TieredReader(hotBackend, warmBackend, coldBackend, {
+  hot: { enabled: true, maxSize: 1024 * 1024 },
+  warm: { enabled: true },
+  cold: { enabled: true },
+  promotionPolicy: 'aggressive'
+})
+
+// Read with automatic tier fallback and promotion
+const result = await reader.read(sha)
+console.log(`Found in ${result.tier} tier, latency: ${result.latencyMs}ms`)
+```
+
+### R2 Pack Storage
+
+```typescript
+import { R2PackStorage } from 'gitx.do/storage/r2-pack'
+
+const storage = new R2PackStorage({ bucket, prefix: 'repos/my-repo/' })
+
+// Upload a packfile
+const result = await storage.uploadPackfile(packData, indexData)
+
+// Download with verification
+const pack = await storage.downloadPackfile(packId, { verify: true })
+
+// Use multi-pack index for cross-pack lookups
+await storage.rebuildMultiPackIndex()
+const midx = await storage.getMultiPackIndex()
+```
+
+## API Overview
+
+### Pack Module (`gitx.do/pack`)
+
+- `parsePackIndex(data)` - Parse a pack index file
+- `createPackIndex(options)` - Create a new pack index
+- `lookupObject(index, sha)` - Find object by SHA in index
+- `verifyPackIndex(data)` - Verify index integrity
+- `calculateCRC32(data)` - Compute CRC32 checksum
+
+### Wire Protocol (`gitx.do/wire`)
+
+- `handleInfoRefs()` - Ref discovery endpoint
+- `handleUploadPack()` - Fetch data transfer
+- `handleReceivePack()` - Push data transfer
+- `formatRefAdvertisement()` - Format ref list
+- `parseCapabilities()` - Parse protocol capabilities
+
+### MCP Tools (`gitx.do/mcp`)
+
+- `gitTools` - Array of available git tool definitions
+- `invokeTool(name, params)` - Execute a tool by name
+- `registerTool(tool)` - Add a custom tool
+- `validateToolInput(tool, params)` - Validate parameters
+
+### Tiered Storage (`gitx.do/tiered`)
+
+- `TieredReader` - Multi-tier read path with promotion
+- `StoredObject` - Object representation
+- `TieredStorageConfig` - Configuration options
+
+### R2 Storage (`gitx.do/storage`)
+
+- `R2PackStorage` - Packfile management for R2
+- `uploadPackfile()` - Store pack and index
+- `downloadPackfile()` - Retrieve with optional verification
+- `createMultiPackIndex()` - Build cross-pack index
+
+## License
+
+MIT

package/dist/durable-object/object-store.d.ts

@@ -0,0 +1,113 @@
+/**
+ * ObjectStore - Git object storage implementation
+ *
+ * Handles CRUD operations for git objects (blob, tree, commit, tag)
+ * with SHA-1 hash computation and proper git object format.
+ */
+import { DurableObjectStorage } from './schema';
+import { ObjectType, BlobObject, TreeObject, CommitObject, TagObject, TreeEntry, Author } from '../types/objects';
+/**
+ * Stored object record in SQLite
+ */
+export interface StoredObject {
+    sha: string;
+    type: ObjectType;
+    size: number;
+    data: Uint8Array;
+    createdAt: number;
+}
+/**
+ * ObjectStore class for managing git objects in SQLite storage
+ */
+export declare class ObjectStore {
+    private storage;
+    constructor(storage: DurableObjectStorage);
+    /**
+     * Store a raw object and return its SHA
+     */
+    putObject(type: ObjectType, data: Uint8Array): Promise<string>;
+    /**
+     * Store a tree object with entries
+     */
+    putTreeObject(entries: TreeEntry[]): Promise<string>;
+    /**
+     * Store a commit object
+     */
+    putCommitObject(commit: {
+        tree: string;
+        parents: string[];
+        author: Author;
+        committer: Author;
+        message: string;
+    }): Promise<string>;
+    /**
+     * Store a tag object
+     */
+    putTagObject(tag: {
+        object: string;
+        objectType: ObjectType;
+        tagger: Author;
+        message: string;
+        name: string;
+    }): Promise<string>;
+    /**
+     * Retrieve an object by SHA
+     */
+    getObject(sha: string): Promise<StoredObject | null>;
+    /**
+     * Delete an object by SHA
+     */
+    deleteObject(sha: string): Promise<boolean>;
+    /**
+     * Check if an object exists
+     */
+    hasObject(sha: string): Promise<boolean>;
+    /**
+     * Verify an object's integrity by recomputing its hash
+     */
+    verifyObject(sha: string): Promise<boolean>;
+    /**
+     * Get object type by SHA
+     */
+    getObjectType(sha: string): Promise<ObjectType | null>;
+    /**
+     * Get object size by SHA
+     */
+    getObjectSize(sha: string): Promise<number | null>;
+    /**
+     * Store multiple objects in a batch
+     */
+    putObjects(objects: {
+        type: ObjectType;
+        data: Uint8Array;
+    }[]): Promise<string[]>;
+    /**
+     * Retrieve multiple objects by SHA
+     */
+    getObjects(shas: string[]): Promise<(StoredObject | null)[]>;
+    /**
+     * Get a blob object with parsed content
+     */
+    getBlobObject(sha: string): Promise<BlobObject | null>;
+    /**
+     * Get a tree object with parsed entries
+     */
+    getTreeObject(sha: string): Promise<TreeObject | null>;
+    /**
+     * Get a commit object with parsed fields
+     */
+    getCommitObject(sha: string): Promise<CommitObject | null>;
+    /**
+     * Get a tag object with parsed fields
+     */
+    getTagObject(sha: string): Promise<TagObject | null>;
+    /**
+     * Get raw serialized object with git header
+     */
+    getRawObject(sha: string): Promise<Uint8Array | null>;
+    /**
+     * Log operation to WAL
+     */
+    private logToWAL;
+}
+//# sourceMappingURL=object-store.d.ts.map

package/dist/durable-object/object-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-store.d.ts","sourceRoot":"","sources":["../../src/durable-object/object-store.ts"],"names":[],"mappings":"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"}

package/dist/durable-object/object-store.js

@@ -0,0 +1,387 @@
+/**
+ * ObjectStore - Git object storage implementation
+ *
+ * Handles CRUD operations for git objects (blob, tree, commit, tag)
+ * with SHA-1 hash computation and proper git object format.
+ */
+import { hashObject } from '../utils/hash';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * ObjectStore class for managing git objects in SQLite storage
+ */
+export class ObjectStore {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Store a raw object and return its SHA
+     */
+    async putObject(type, data) {
+        // Compute SHA-1 hash using git object format: "type size\0content"
+        const sha = await hashObject(type, data);
+        // Log to WAL first
+        await this.logToWAL('PUT', sha, type, data);
+        // Store the object
+        this.storage.sql.exec('INSERT OR REPLACE INTO objects (sha, type, size, data, created_at) VALUES (?, ?, ?, ?, ?)', sha, type, data.length, data, Date.now());
+        // Update object index
+        this.storage.sql.exec('INSERT OR REPLACE INTO object_index (sha, tier, location, size, type) VALUES (?, ?, ?, ?, ?)', sha, 'hot', 'local', data.length, type);
+        return sha;
+    }
+    /**
+     * Store a tree object with entries
+     */
+    async putTreeObject(entries) {
+        // Sort entries by name (directories get trailing / for sorting)
+        const sortedEntries = [...entries].sort((a, b) => {
+            const aName = a.mode === '040000' ? a.name + '/' : a.name;
+            const bName = b.mode === '040000' ? b.name + '/' : b.name;
+            return aName.localeCompare(bName);
+        });
+        // Build tree content (without header)
+        const entryParts = [];
+        for (const entry of sortedEntries) {
+            const modeName = encoder.encode(`${entry.mode} ${entry.name}\0`);
+            const sha20 = hexToBytes(entry.sha);
+            const entryData = new Uint8Array(modeName.length + 20);
+            entryData.set(modeName);
+            entryData.set(sha20, modeName.length);
+            entryParts.push(entryData);
+        }
+        // Combine all entry parts
+        const contentLength = entryParts.reduce((sum, part) => sum + part.length, 0);
+        const content = new Uint8Array(contentLength);
+        let offset = 0;
+        for (const part of entryParts) {
+            content.set(part, offset);
+            offset += part.length;
+        }
+        return this.putObject('tree', content);
+    }
+    /**
+     * Store a commit object
+     */
+    async putCommitObject(commit) {
+        // Build commit content (without header)
+        const lines = [];
+        lines.push(`tree ${commit.tree}`);
+        for (const parent of commit.parents) {
+            lines.push(`parent ${parent}`);
+        }
+        lines.push(`author ${commit.author.name} <${commit.author.email}> ${commit.author.timestamp} ${commit.author.timezone}`);
+        lines.push(`committer ${commit.committer.name} <${commit.committer.email}> ${commit.committer.timestamp} ${commit.committer.timezone}`);
+        lines.push('');
+        lines.push(commit.message);
+        const content = encoder.encode(lines.join('\n'));
+        return this.putObject('commit', content);
+    }
+    /**
+     * Store a tag object
+     */
+    async putTagObject(tag) {
+        // Build tag content (without header)
+        const lines = [];
+        lines.push(`object ${tag.object}`);
+        lines.push(`type ${tag.objectType}`);
+        lines.push(`tag ${tag.name}`);
+        lines.push(`tagger ${tag.tagger.name} <${tag.tagger.email}> ${tag.tagger.timestamp} ${tag.tagger.timezone}`);
+        lines.push('');
+        lines.push(tag.message);
+        const content = encoder.encode(lines.join('\n'));
+        return this.putObject('tag', content);
+    }
+    /**
+     * Retrieve an object by SHA
+     */
+    async getObject(sha) {
+        if (!sha || sha.length < 4) {
+            return null;
+        }
+        const result = this.storage.sql.exec('SELECT sha, type, size, data, created_at as createdAt FROM objects WHERE sha = ?', sha);
+        const rows = result.toArray();
+        if (rows.length === 0) {
+            return null;
+        }
+        return rows[0];
+    }
+    /**
+     * Delete an object by SHA
+     */
+    async deleteObject(sha) {
+        // Check if object exists first
+        const exists = await this.hasObject(sha);
+        if (!exists) {
+            return false;
+        }
+        // Log to WAL
+        await this.logToWAL('DELETE', sha, 'blob', new Uint8Array(0));
+        // Delete from objects table
+        this.storage.sql.exec('DELETE FROM objects WHERE sha = ?', sha);
+        // Delete from object index
+        this.storage.sql.exec('DELETE FROM object_index WHERE sha = ?', sha);
+        return true;
+    }
+    /**
+     * Check if an object exists
+     */
+    async hasObject(sha) {
+        if (!sha || sha.length < 4) {
+            return false;
+        }
+        // Use getObject and check for null - this works better with the mock
+        const obj = await this.getObject(sha);
+        return obj !== null;
+    }
+    /**
+     * Verify an object's integrity by recomputing its hash
+     */
+    async verifyObject(sha) {
+        const obj = await this.getObject(sha);
+        if (!obj) {
+            return false;
+        }
+        const computedSha = await hashObject(obj.type, obj.data);
+        return computedSha === sha;
+    }
+    /**
+     * Get object type by SHA
+     */
+    async getObjectType(sha) {
+        const obj = await this.getObject(sha);
+        return obj?.type ?? null;
+    }
+    /**
+     * Get object size by SHA
+     */
+    async getObjectSize(sha) {
+        const obj = await this.getObject(sha);
+        return obj?.size ?? null;
+    }
+    /**
+     * Store multiple objects in a batch
+     */
+    async putObjects(objects) {
+        const shas = [];
+        for (const obj of objects) {
+            const sha = await this.putObject(obj.type, obj.data);
+            shas.push(sha);
+        }
+        return shas;
+    }
+    /**
+     * Retrieve multiple objects by SHA
+     */
+    async getObjects(shas) {
+        const results = [];
+        for (const sha of shas) {
+            const obj = await this.getObject(sha);
+            results.push(obj);
+        }
+        return results;
+    }
+    /**
+     * Get a blob object with parsed content
+     */
+    async getBlobObject(sha) {
+        const obj = await this.getObject(sha);
+        if (!obj || obj.type !== 'blob') {
+            return null;
+        }
+        return {
+            type: 'blob',
+            data: obj.data
+        };
+    }
+    /**
+     * Get a tree object with parsed entries
+     */
+    async getTreeObject(sha) {
+        const obj = await this.getObject(sha);
+        if (!obj || obj.type !== 'tree') {
+            return null;
+        }
+        // Parse tree entries from raw data
+        const entries = [];
+        let offset = 0;
+        const data = obj.data;
+        while (offset < data.length) {
+            // Find the null byte after mode+name
+            let nullIndex = offset;
+            while (nullIndex < data.length && data[nullIndex] !== 0) {
+                nullIndex++;
+            }
+            const modeNameStr = decoder.decode(data.slice(offset, nullIndex));
+            const spaceIndex = modeNameStr.indexOf(' ');
+            const mode = modeNameStr.slice(0, spaceIndex);
+            const name = modeNameStr.slice(spaceIndex + 1);
+            // Read 20-byte SHA
+            const sha20 = data.slice(nullIndex + 1, nullIndex + 21);
+            const entrySha = bytesToHex(sha20);
+            entries.push({ mode, name, sha: entrySha });
+            offset = nullIndex + 21;
+        }
+        return {
+            type: 'tree',
+            data: obj.data,
+            entries
+        };
+    }
+    /**
+     * Get a commit object with parsed fields
+     */
+    async getCommitObject(sha) {
+        const obj = await this.getObject(sha);
+        if (!obj || obj.type !== 'commit') {
+            return null;
+        }
+        const content = decoder.decode(obj.data);
+        const lines = content.split('\n');
+        let tree = '';
+        const parents = [];
+        let author = null;
+        let committer = null;
+        let messageStartIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line === '') {
+                messageStartIndex = i + 1;
+                break;
+            }
+            if (line.startsWith('tree ')) {
+                tree = line.slice(5);
+            }
+            else if (line.startsWith('parent ')) {
+                parents.push(line.slice(7));
+            }
+            else if (line.startsWith('author ')) {
+                author = parseAuthorLine(line);
+            }
+            else if (line.startsWith('committer ')) {
+                committer = parseAuthorLine(line);
+            }
+        }
+        if (!author || !committer) {
+            return null;
+        }
+        const message = lines.slice(messageStartIndex).join('\n');
+        return {
+            type: 'commit',
+            data: obj.data,
+            tree,
+            parents,
+            author,
+            committer,
+            message
+        };
+    }
+    /**
+     * Get a tag object with parsed fields
+     */
+    async getTagObject(sha) {
+        const obj = await this.getObject(sha);
+        if (!obj || obj.type !== 'tag') {
+            return null;
+        }
+        const content = decoder.decode(obj.data);
+        const lines = content.split('\n');
+        let object = '';
+        let objectType = 'commit';
+        let name = '';
+        let tagger = null;
+        let messageStartIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line === '') {
+                messageStartIndex = i + 1;
+                break;
+            }
+            if (line.startsWith('object ')) {
+                object = line.slice(7);
+            }
+            else if (line.startsWith('type ')) {
+                objectType = line.slice(5);
+            }
+            else if (line.startsWith('tag ')) {
+                name = line.slice(4);
+            }
+            else if (line.startsWith('tagger ')) {
+                tagger = parseAuthorLine(line);
+            }
+        }
+        if (!tagger) {
+            return null;
+        }
+        const message = lines.slice(messageStartIndex).join('\n');
+        return {
+            type: 'tag',
+            data: obj.data,
+            object,
+            objectType,
+            name,
+            tagger,
+            message
+        };
+    }
+    /**
+     * Get raw serialized object with git header
+     */
+    async getRawObject(sha) {
+        const obj = await this.getObject(sha);
+        if (!obj) {
+            return null;
+        }
+        // Build git object format: "type size\0content"
+        const header = encoder.encode(`${obj.type} ${obj.data.length}\0`);
+        const result = new Uint8Array(header.length + obj.data.length);
+        result.set(header);
+        result.set(obj.data, header.length);
+        return result;
+    }
+    /**
+     * Log operation to WAL
+     */
+    async logToWAL(operation, sha, type, _data) {
+        // Create payload with operation details
+        const payload = encoder.encode(JSON.stringify({
+            sha,
+            type,
+            timestamp: Date.now()
+        }));
+        this.storage.sql.exec('INSERT INTO wal (operation, payload, created_at, flushed) VALUES (?, ?, ?, 0)', operation, payload, Date.now());
+    }
+}
+/**
+ * Helper: Convert hex string to bytes
+ */
+function 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;
+}
+/**
+ * Helper: Convert bytes to hex string
+ */
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * Helper: Parse author/committer/tagger line
+ */
+function parseAuthorLine(line) {
+    const match = line.match(/^(?:author|committer|tagger) (.+) <(.+)> (\d+) ([+-]\d{4})$/);
+    if (!match) {
+        throw new Error(`Invalid author line: ${line}`);
+    }
+    return {
+        name: match[1],
+        email: match[2],
+        timestamp: parseInt(match[3], 10),
+        timezone: match[4]
+    };
+}
+//# sourceMappingURL=object-store.js.map