gitx.do 0.1.0 → 0.1.2

package/dist/utils/hash.js

@@ -1,268 +0,0 @@
-/**
- * @fileoverview SHA Hashing Utilities for Git Objects
- *
- * This module provides cryptographic hashing functions used for Git object
- * identification and verification. Git uses SHA-1 as its primary hash algorithm,
- * with SHA-256 available as an optional newer algorithm (Git v2.29+).
- *
- * Core hash primitives are re-exported from fsx.do, with gitx-specific
- * utilities like HashCache and hashObject defined here.
- *
- * @module utils/hash
- *
- * @example
- * ```typescript
- * import { sha1, hashObject, hexToBytes, bytesToHex } from './utils/hash'
- *
- * // Hash raw data
- * const hash = await sha1('Hello, World!')
- *
- * // Hash as a Git object (includes type header)
- * const content = new TextEncoder().encode('file content')
- * const blobSha = await hashObject('blob', content)
- * console.log(`blob ${blobSha}`)
- * ```
- */
-// Re-export core hash primitives from fsx.do
-export { sha1, sha256, hexToBytes, bytesToHex } from '../../../fsx/src/cas/hash';
-// Import for internal use
-import { sha1, bytesToHex } from '../../../fsx/src/cas/hash';
-/**
- * Hash a Git object with its type header.
- *
- * @description
- * Computes the SHA-1 hash of a Git object including its header.
- * The header format is: "{type} {size}\0" followed by the content.
- *
- * This matches the output of `git hash-object` command and is the
- * standard way Git computes object identifiers.
- *
- * @param type - Object type ('blob', 'tree', 'commit', 'tag')
- * @param data - Object content as binary data (without header)
- * @returns 40-character lowercase hexadecimal SHA-1 hash
- *
- * @example
- * ```typescript
- * // Hash a blob (equivalent to `echo -n "hello" | git hash-object --stdin`)
- * const content = new TextEncoder().encode('hello')
- * const sha = await hashObject('blob', content)
- * console.log(sha) // 'b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0'
- *
- * // Verify with git:
- * // $ echo -n "hello" | git hash-object --stdin
- * // b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0
- * ```
- */
-export async function hashObject(type, data) {
-    const header = `${type} ${data.length}\0`;
-    const headerBytes = new TextEncoder().encode(header);
-    const combined = new Uint8Array(headerBytes.length + data.length);
-    combined.set(headerBytes, 0);
-    combined.set(data, headerBytes.length);
-    return sha1(combined);
-}
-// ============================================================================
-// Hash Caching
-// ============================================================================
-/**
- * LRU cache for storing computed hashes.
- *
- * @description
- * A Least Recently Used (LRU) cache implementation for caching SHA-1 hashes.
- * This is useful when the same data is hashed multiple times, such as during
- * pack file operations or object store lookups.
- *
- * **Key Strategy**: The cache key is derived from the first few bytes of the
- * data combined with its length, which provides a fast key generation while
- * avoiding collisions for different data.
- *
- * **Thread Safety**: This implementation is NOT thread-safe. In multi-threaded
- * environments, external synchronization is required.
- *
- * @class HashCache
- *
- * @example
- * ```typescript
- * const cache = new HashCache(1000) // Cache up to 1000 hashes
- *
- * // Use with getOrCompute for automatic caching
- * const hash1 = await cache.getOrCompute(data, async () => sha1(data))
- * const hash2 = await cache.getOrCompute(data, async () => sha1(data)) // Returns cached
- *
- * // Check stats
- * console.log(`Hit rate: ${cache.hitRate}%`)
- * ```
- */
-export class HashCache {
-    cache;
-    maxSize;
-    hits = 0;
-    misses = 0;
-    /**
-     * Creates a new HashCache with the specified maximum size.
-     *
-     * @param {number} maxSize - Maximum number of hashes to cache (default: 10000)
-     */
-    constructor(maxSize = 10000) {
-        this.cache = new Map();
-        this.maxSize = maxSize;
-    }
-    /**
-     * Generates a cache key for the given data.
-     *
-     * @description Uses length + first 32 bytes (if available) to create a unique key.
-     * This is fast while providing good collision resistance.
-     *
-     * @param {Uint8Array} data - Data to generate key for
-     * @returns {string} Cache key
-     * @internal
-     */
-    generateKey(data) {
-        // Use length + first 32 bytes as key (fast and reasonably unique)
-        const prefix = data.length <= 32
-            ? bytesToHex(data)
-            : bytesToHex(data.subarray(0, 32));
-        return `${data.length}:${prefix}`;
-    }
-    /**
-     * Gets a cached hash if available.
-     *
-     * @param {Uint8Array} data - Data to look up
-     * @returns {string | undefined} Cached hash or undefined if not cached
-     */
-    get(data) {
-        const key = this.generateKey(data);
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-            this.hits++;
-            // Move to end (most recently used)
-            this.cache.delete(key);
-            this.cache.set(key, value);
-            return value;
-        }
-        this.misses++;
-        return undefined;
-    }
-    /**
-     * Stores a hash in the cache.
-     *
-     * @param {Uint8Array} data - Original data
-     * @param {string} hash - Computed hash to cache
-     */
-    set(data, hash) {
-        const key = this.generateKey(data);
-        // Remove oldest entry if at capacity
-        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined) {
-                this.cache.delete(firstKey);
-            }
-        }
-        this.cache.set(key, hash);
-    }
-    /**
-     * Gets a hash from cache or computes and caches it.
-     *
-     * @description This is the recommended way to use the cache. It automatically
-     * handles cache lookup, computation, and storage.
-     *
-     * @param {Uint8Array} data - Data to hash
-     * @param {() => Promise<string> | string} compute - Function to compute hash if not cached
-     * @returns {Promise<string>} The hash (from cache or newly computed)
-     *
-     * @example
-     * ```typescript
-     * const hash = await cache.getOrCompute(data, () => sha1(data))
-     * ```
-     */
-    async getOrCompute(data, compute) {
-        const cached = this.get(data);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const hash = await compute();
-        this.set(data, hash);
-        return hash;
-    }
-    /**
-     * Synchronous version of getOrCompute for use with synchronous hash functions.
-     *
-     * @param {Uint8Array} data - Data to hash
-     * @param {() => string} compute - Function to compute hash if not cached
-     * @returns {string} The hash (from cache or newly computed)
-     *
-     * @example
-     * ```typescript
-     * import { sha1Hex } from './sha1'
-     * const hash = cache.getOrComputeSync(data, () => sha1Hex(data))
-     * ```
-     */
-    getOrComputeSync(data, compute) {
-        const cached = this.get(data);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const hash = compute();
-        this.set(data, hash);
-        return hash;
-    }
-    /**
-     * Clears all entries from the cache.
-     */
-    clear() {
-        this.cache.clear();
-        this.hits = 0;
-        this.misses = 0;
-    }
-    /**
-     * Gets the current number of cached entries.
-     */
-    get size() {
-        return this.cache.size;
-    }
-    /**
-     * Gets the cache hit rate as a percentage.
-     */
-    get hitRate() {
-        const total = this.hits + this.misses;
-        return total === 0 ? 0 : (this.hits / total) * 100;
-    }
-    /**
-     * Gets cache statistics.
-     *
-     * @returns {{ hits: number; misses: number; size: number; hitRate: number }}
-     */
-    getStats() {
-        return {
-            hits: this.hits,
-            misses: this.misses,
-            size: this.cache.size,
-            hitRate: this.hitRate
-        };
-    }
-}
-/**
- * Global hash cache instance for common use cases.
- *
- * @description
- * A shared cache instance that can be used across the application for
- * caching object hashes. This is particularly useful for pack file
- * operations where the same objects are hashed multiple times.
- *
- * **Memory Management**: The cache has a default limit of 10,000 entries.
- * For applications with different requirements, create a custom HashCache
- * instance with appropriate size.
- *
- * @example
- * ```typescript
- * import { globalHashCache, sha1 } from './utils/hash'
- *
- * // Use the global cache
- * const hash = await globalHashCache.getOrCompute(data, () => sha1(data))
- *
- * // Check cache stats
- * console.log(globalHashCache.getStats())
- * ```
- */
-export const globalHashCache = new HashCache();
-//# sourceMappingURL=hash.js.map

package/dist/utils/hash.js.map

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

package/dist/utils/sha1.d.ts

@@ -1,290 +0,0 @@
-/**
- * @fileoverview Synchronous SHA-1 Utilities for Git Pack Operations
- *
- * This module provides synchronous (non-async) SHA-1 hashing needed for pack file
- * generation, verification, and streaming operations where async is impractical.
- *
- * The implementation follows the SHA-1 specification (FIPS 180-4) and processes
- * data in 512-bit (64-byte) chunks using the standard compression function.
- *
- * **When to use this vs hash.ts**:
- * - Use `utils/hash.ts` for general async hashing (uses Web Crypto API)
- * - Use this module for pack operations that need synchronous hashing
- *
- * @module utils/sha1
- *
- * @example
- * ```typescript
- * import { sha1, sha1Hex, sha1Verify } from './utils/sha1'
- *
- * // Compute SHA-1 as bytes
- * const data = new TextEncoder().encode('Hello, World!')
- * const hashBytes = sha1(data) // 20-byte Uint8Array
- *
- * // Compute SHA-1 as hex string
- * const hashHex = sha1Hex(data) // 40-char string
- *
- * // Verify data against expected hash
- * const isValid = sha1Verify(data, expectedHash)
- * ```
- */
-/**
- * Compute SHA-1 hash of data synchronously.
- *
- * @description
- * Implements the SHA-1 algorithm per FIPS 180-4. This pure JavaScript
- * implementation is used when synchronous hashing is needed, such as
- * in pack file generation or streaming operations.
- *
- * **Algorithm Details**:
- * 1. Pad message to 512-bit boundary (with 1-bit, zeros, and 64-bit length)
- * 2. Process in 64-byte chunks using 80-round compression function
- * 3. Return final 160-bit (20-byte) hash
- *
- * **Performance Note**: This is slower than Web Crypto API. Use `hash.ts`
- * for async operations where performance is critical.
- *
- * @param data - Input data to hash
- * @returns 20-byte hash as Uint8Array
- *
- * @example
- * ```typescript
- * const data = new TextEncoder().encode('test')
- * const hash = sha1(data)
- * console.log(hash.length) // 20
- *
- * // Use with pack file verification
- * const packData = readPackFile()
- * const computedHash = sha1(packData.slice(0, -20))
- * ```
- */
-export declare function sha1(data: Uint8Array): Uint8Array;
-/**
- * Compute SHA-1 hash and return as hexadecimal string.
- *
- * @description
- * Convenience wrapper that computes SHA-1 and converts the result
- * to a lowercase hexadecimal string. Equivalent to calling `sha1()`
- * followed by hex conversion.
- *
- * @param data - Input data to hash
- * @returns 40-character lowercase hexadecimal hash string
- *
- * @example
- * ```typescript
- * const data = new TextEncoder().encode('hello')
- * const hex = sha1Hex(data)
- * console.log(hex) // 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d'
- *
- * // Compare with git:
- * // $ echo -n "hello" | sha1sum
- * // aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
- * ```
- */
-export declare function sha1Hex(data: Uint8Array): string;
-/**
- * Verify data against an expected SHA-1 hash.
- *
- * @description
- * Computes the SHA-1 hash of the data and compares it byte-by-byte
- * with the expected hash. Returns true only if all 20 bytes match.
- *
- * This uses constant-time comparison to avoid timing attacks,
- * though SHA-1 is not used for security purposes in Git.
- *
- * @param data - Data to verify
- * @param expected - Expected 20-byte SHA-1 hash
- * @returns True if the computed hash matches the expected hash
- * @throws Never throws - returns false for invalid inputs
- *
- * @example
- * ```typescript
- * // Verify pack file integrity
- * const packContent = readPackFile()
- * const contentWithoutChecksum = packContent.slice(0, -20)
- * const expectedChecksum = packContent.slice(-20)
- *
- * if (sha1Verify(contentWithoutChecksum, expectedChecksum)) {
- *   console.log('Pack file integrity verified')
- * } else {
- *   console.log('Pack file corrupted!')
- * }
- *
- * // Invalid expected hash length
- * const badHash = new Uint8Array(10)
- * sha1Verify(data, badHash) // false (wrong length)
- * ```
- */
-export declare function sha1Verify(data: Uint8Array, expected: Uint8Array): boolean;
-/**
- * Streaming SHA-1 hasher for processing large data incrementally.
- *
- * @description
- * This class allows hashing data in chunks, which is essential for:
- * - Processing large files without loading everything into memory
- * - Computing hashes of data streams
- * - Pack file generation and verification
- *
- * The hasher maintains internal state and can accept data through the
- * `update()` method before finalizing with `digest()` or `digestHex()`.
- *
- * **Performance Note**: For small data (< 64 bytes), the non-streaming
- * `sha1()` function may be slightly faster due to lower overhead.
- *
- * @class StreamingSHA1
- *
- * @example
- * ```typescript
- * // Hash a large file in chunks
- * const hasher = new StreamingSHA1()
- *
- * for await (const chunk of fileStream) {
- *   hasher.update(chunk)
- * }
- *
- * const hash = hasher.digestHex()
- * console.log(`File hash: ${hash}`)
- * ```
- *
- * @example
- * ```typescript
- * // Hash Git object with header
- * const hasher = new StreamingSHA1()
- * hasher.update(new TextEncoder().encode(`blob ${size}\0`))
- * hasher.update(content)
- * const objectId = hasher.digestHex()
- * ```
- */
-export declare class StreamingSHA1 {
-    /** Hash state */
-    private h;
-    /** Working array for chunk processing */
-    private w;
-    /** Buffer for incomplete chunks */
-    private buffer;
-    /** Current position in buffer */
-    private bufferLength;
-    /** Total bytes processed */
-    private totalLength;
-    /** Whether digest has been called */
-    private finalized;
-    /**
-     * Creates a new StreamingSHA1 hasher instance.
-     */
-    constructor();
-    /**
-     * Resets the hasher to its initial state.
-     *
-     * @description Allows reusing the same hasher instance for a new hash
-     * computation without creating a new object.
-     *
-     * @example
-     * ```typescript
-     * const hasher = new StreamingSHA1()
-     * hasher.update(data1)
-     * const hash1 = hasher.digestHex()
-     *
-     * hasher.reset()
-     * hasher.update(data2)
-     * const hash2 = hasher.digestHex()
-     * ```
-     */
-    reset(): void;
-    /**
-     * Updates the hash with additional data.
-     *
-     * @description Processes the input data, updating the internal hash state.
-     * Data is buffered internally until a complete 64-byte chunk is available,
-     * then processed immediately.
-     *
-     * This method can be called multiple times before finalizing with `digest()`.
-     *
-     * @param {Uint8Array} data - Data to add to the hash computation
-     * @returns {this} The hasher instance for method chaining
-     * @throws {Error} If called after digest() without reset()
-     *
-     * @example
-     * ```typescript
-     * const hasher = new StreamingSHA1()
-     *   .update(header)
-     *   .update(content)
-     *   .update(footer)
-     * const hash = hasher.digestHex()
-     * ```
-     */
-    update(data: Uint8Array): this;
-    /**
-     * Finalizes the hash computation and returns the 20-byte digest.
-     *
-     * @description Applies SHA-1 padding to the remaining data and computes
-     * the final hash. After calling this method, the hasher cannot be updated
-     * unless `reset()` is called.
-     *
-     * @returns {Uint8Array} 20-byte SHA-1 hash
-     *
-     * @example
-     * ```typescript
-     * const hasher = new StreamingSHA1()
-     * hasher.update(data)
-     * const hashBytes = hasher.digest()
-     * console.log(hashBytes.length) // 20
-     * ```
-     */
-    digest(): Uint8Array;
-    /**
-     * Finalizes the hash computation and returns the hex string digest.
-     *
-     * @description Convenience method that calls `digest()` and converts
-     * the result to a 40-character lowercase hexadecimal string.
-     *
-     * @returns {string} 40-character lowercase hexadecimal hash string
-     *
-     * @example
-     * ```typescript
-     * const hasher = new StreamingSHA1()
-     * hasher.update(data)
-     * const hash = hasher.digestHex()
-     * console.log(hash) // 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d'
-     * ```
-     */
-    digestHex(): string;
-}
-/**
- * Hash a Git object with streaming support for large objects.
- *
- * @description
- * Uses the streaming hasher to compute the SHA-1 of a Git object with its header.
- * This is more memory-efficient than `hashObject` in `hash.ts` for large objects
- * as it doesn't require concatenating header and data.
- *
- * @param type - Object type ('blob', 'tree', 'commit', 'tag')
- * @param data - Object content as binary data
- * @returns 20-byte SHA-1 hash as Uint8Array
- *
- * @example
- * ```typescript
- * const content = new TextEncoder().encode('hello')
- * const hashBytes = hashObjectStreaming('blob', content)
- * ```
- */
-export declare function hashObjectStreaming(type: string, data: Uint8Array): Uint8Array;
-/**
- * Hash a Git object with streaming support, returning hex string.
- *
- * @description
- * Convenience wrapper that returns the hash as a 40-character hex string
- * instead of raw bytes.
- *
- * @param type - Object type ('blob', 'tree', 'commit', 'tag')
- * @param data - Object content as binary data
- * @returns 40-character lowercase hexadecimal SHA-1 hash
- *
- * @example
- * ```typescript
- * const content = new TextEncoder().encode('hello')
- * const sha = hashObjectStreamingHex('blob', content)
- * console.log(sha) // 'b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0'
- * ```
- */
-export declare function hashObjectStreamingHex(type: string, data: Uint8Array): string;
-//# sourceMappingURL=sha1.d.ts.map

package/dist/utils/sha1.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sha1.d.ts","sourceRoot":"","sources":["../../src/utils/sha1.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAwGjD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAOhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAgB1E;AA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,aAAa;IACxB,iBAAiB;IACjB,OAAO,CAAC,CAAC,CAAa;IACtB,yCAAyC;IACzC,OAAO,CAAC,CAAC,CAAa;IACtB,mCAAmC;IACnC,OAAO,CAAC,MAAM,CAAY;IAC1B,iCAAiC;IACjC,OAAO,CAAC,YAAY,CAAQ;IAC5B,4BAA4B;IAC5B,OAAO,CAAC,WAAW,CAAQ;IAC3B,qCAAqC;IACrC,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;;IAUH;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,IAAI,IAAI;IAWb;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAsC9B;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,IAAI,UAAU;IAmDpB;;;;;;;;;;;;;;;OAeG;IACH,SAAS,IAAI,MAAM;CAQpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAM9E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAM7E"}