gitx.do 0.0.1

package/dist/ops/tree-builder.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Tree Builder - builds git tree objects from index entries
+ *
+ * Supports:
+ * - File modes (100644 regular, 100755 executable, 040000 directory, 120000 symlink, 160000 submodule)
+ * - Proper tree entry format (mode + space + name + null + sha)
+ * - Sorted entries (git requires lexicographic ordering)
+ * - Nested tree building for directory hierarchies
+ * - Tree SHA computation
+ * - Tree deduplication
+ */
+import { TreeEntry } from '../types/objects';
+import type { BasicObjectStore as ObjectStore } from '../types/storage';
+/**
+ * Index entry from git index file
+ */
+export interface IndexEntry {
+    path: string;
+    sha: string;
+    mode: string;
+    flags: number;
+    size: number;
+    mtime: number;
+    ctime: number;
+}
+/**
+ * ObjectStore interface for tree builder operations.
+ * Re-exported from storage types for convenience.
+ */
+export type { ObjectStore };
+/**
+ * Tree node for building hierarchy
+ */
+export interface TreeNode {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    children: Map<string, TreeNode>;
+    entry?: IndexEntry;
+}
+/**
+ * Result of building a tree
+ */
+export interface BuildTreeResult {
+    sha: string;
+    entries: TreeEntry[];
+    treeCount: number;
+    uniqueTreeCount: number;
+    deduplicatedCount: number;
+    subtrees?: Record<string, BuildTreeResult>;
+}
+/**
+ * Build a tree hierarchy from index entries
+ */
+export declare function buildTreeHierarchy(entries: IndexEntry[]): TreeNode;
+/**
+ * Sort tree entries according to git conventions
+ * Directories are sorted as if they have a trailing slash
+ */
+export declare function sortTreeEntries(entries: TreeEntry[]): TreeEntry[];
+/**
+ * Create a tree object and store it
+ */
+export declare function createTreeObject(store: ObjectStore, entries: TreeEntry[]): Promise<{
+    sha: string;
+    type: 'tree';
+    data: Uint8Array;
+}>;
+/**
+ * Deduplicate trees based on their content hash
+ * Returns a map of canonical tree content to path, and mapping of paths to canonical paths
+ */
+export declare function deduplicateTrees(trees: Map<string, TreeEntry[]>): {
+    deduplicated: Map<string, TreeEntry[]>;
+    mapping: Map<string, string>;
+};
+/**
+ * Build tree from index entries
+ * This is the main entry point for tree building
+ */
+export declare function buildTreeFromIndex(store: ObjectStore, entries: IndexEntry[]): Promise<BuildTreeResult>;
+//# sourceMappingURL=tree-builder.d.ts.map

package/dist/ops/tree-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-builder.d.ts","sourceRoot":"","sources":["../../src/ops/tree-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,KAAK,EAAE,gBAAgB,IAAI,WAAW,EAAE,MAAM,kBAAkB,CAAA;AASvE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;GAGG;AACH,YAAY,EAAE,WAAW,EAAE,CAAA;AAE3B;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC/B,KAAK,CAAC,EAAE,UAAU,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;CAC3C;AAsCD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,QAAQ,CAsClE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAUjE;AAgCD;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,SAAS,EAAE,GACnB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAI1D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,GAC9B;IAAE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAsB1E;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,UAAU,EAAE,GACpB,OAAO,CAAC,eAAe,CAAC,CAkG1B"}

package/dist/ops/tree-builder.js

@@ -0,0 +1,246 @@
+/**
+ * Tree Builder - builds git tree objects from index entries
+ *
+ * Supports:
+ * - File modes (100644 regular, 100755 executable, 040000 directory, 120000 symlink, 160000 submodule)
+ * - Proper tree entry format (mode + space + name + null + sha)
+ * - Sorted entries (git requires lexicographic ordering)
+ * - Nested tree building for directory hierarchies
+ * - Tree SHA computation
+ * - Tree deduplication
+ */
+import { hexToBytes } from '../utils/hash';
+// Valid file modes in git
+const VALID_MODES = new Set(['100644', '100755', '040000', '120000', '160000']);
+// Text encoder/decoder
+const encoder = new TextEncoder();
+/**
+ * Validate an index entry
+ */
+function validateEntry(entry) {
+    // Check mode
+    if (!VALID_MODES.has(entry.mode)) {
+        throw new Error(`Invalid file mode: ${entry.mode}`);
+    }
+    // Check SHA format (40 hex characters)
+    if (!/^[0-9a-f]{40}$/.test(entry.sha)) {
+        throw new Error(`Invalid SHA format: ${entry.sha}`);
+    }
+    // Check path
+    if (!entry.path || entry.path.length === 0) {
+        throw new Error('Empty path not allowed');
+    }
+    if (entry.path.startsWith('/')) {
+        throw new Error('Path must not start with /');
+    }
+    if (entry.path.includes('//')) {
+        throw new Error('Path must not contain double slashes');
+    }
+    // Check for . or .. components
+    const parts = entry.path.split('/');
+    for (const part of parts) {
+        if (part === '.' || part === '..') {
+            throw new Error(`Path must not contain . or .. components: ${entry.path}`);
+        }
+    }
+}
+/**
+ * Build a tree hierarchy from index entries
+ */
+export function buildTreeHierarchy(entries) {
+    const root = {
+        name: '',
+        path: '',
+        isDirectory: true,
+        children: new Map()
+    };
+    for (const entry of entries) {
+        const parts = entry.path.split('/');
+        let current = root;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            const currentPath = parts.slice(0, i + 1).join('/');
+            if (!current.children.has(part)) {
+                const node = {
+                    name: part,
+                    path: currentPath,
+                    isDirectory: !isLast,
+                    children: new Map(),
+                    entry: isLast ? entry : undefined
+                };
+                current.children.set(part, node);
+            }
+            else if (isLast) {
+                // Update entry for duplicate paths (last one wins)
+                const existing = current.children.get(part);
+                existing.entry = entry;
+                existing.isDirectory = false;
+            }
+            current = current.children.get(part);
+        }
+    }
+    return root;
+}
+/**
+ * Sort tree entries according to git conventions
+ * Directories are sorted as if they have a trailing slash
+ */
+export function sortTreeEntries(entries) {
+    return [...entries].sort((a, b) => {
+        // Directories sort as if they have trailing slash
+        const aName = a.mode === '040000' ? a.name + '/' : a.name;
+        const bName = b.mode === '040000' ? b.name + '/' : b.name;
+        // Use byte-wise comparison (localeCompare with raw mode)
+        if (aName < bName)
+            return -1;
+        if (aName > bName)
+            return 1;
+        return 0;
+    });
+}
+/**
+ * Create tree object data from entries
+ */
+function createTreeData(entries) {
+    // Sort entries
+    const sorted = sortTreeEntries(entries);
+    // Build entry content
+    const entryParts = [];
+    for (const entry of sorted) {
+        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 parts
+    const totalLength = entryParts.reduce((sum, part) => sum + part.length, 0);
+    const content = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const part of entryParts) {
+        content.set(part, offset);
+        offset += part.length;
+    }
+    return content;
+}
+/**
+ * Create a tree object and store it
+ */
+export async function createTreeObject(store, entries) {
+    const data = createTreeData(entries);
+    const sha = await store.storeObject('tree', data);
+    return { sha, type: 'tree', data };
+}
+/**
+ * Deduplicate trees based on their content hash
+ * Returns a map of canonical tree content to path, and mapping of paths to canonical paths
+ */
+export function deduplicateTrees(trees) {
+    const contentToPath = new Map();
+    const deduplicated = new Map();
+    const mapping = new Map();
+    for (const [path, entries] of trees) {
+        // Create a content key from sorted entries
+        const sorted = sortTreeEntries(entries);
+        const key = sorted.map(e => `${e.mode}:${e.name}:${e.sha}`).join('|');
+        if (contentToPath.has(key)) {
+            // Duplicate - map to existing path
+            mapping.set(path, contentToPath.get(key));
+        }
+        else {
+            // New unique tree
+            contentToPath.set(key, path);
+            deduplicated.set(path, entries);
+            mapping.set(path, path);
+        }
+    }
+    return { deduplicated, mapping };
+}
+/**
+ * Build tree from index entries
+ * This is the main entry point for tree building
+ */
+export async function buildTreeFromIndex(store, entries) {
+    // Validate all entries first
+    for (const entry of entries) {
+        validateEntry(entry);
+    }
+    // Build hierarchy
+    const hierarchy = buildTreeHierarchy(entries);
+    // Track stats
+    let treeCount = 0;
+    let uniqueTreeCount = 0;
+    const treeContentToSha = new Map();
+    /**
+     * Recursively build tree for a node
+     */
+    async function buildNode(node) {
+        const treeEntries = [];
+        const nodeSubtrees = {};
+        // Process children
+        const children = Array.from(node.children.values());
+        for (const child of children) {
+            if (child.isDirectory) {
+                // Recursively build subtree
+                const subtreeResult = await buildNode(child);
+                nodeSubtrees[child.name] = subtreeResult;
+                treeEntries.push({
+                    mode: '040000',
+                    name: child.name,
+                    sha: subtreeResult.sha
+                });
+            }
+            else if (child.entry) {
+                // File entry
+                treeEntries.push({
+                    mode: child.entry.mode,
+                    name: child.name,
+                    sha: child.entry.sha
+                });
+            }
+        }
+        // Sort entries
+        const sortedEntries = sortTreeEntries(treeEntries);
+        treeCount++;
+        // Check for deduplication
+        const contentKey = sortedEntries.map(e => `${e.mode}:${e.name}:${e.sha}`).join('|');
+        let sha;
+        if (treeContentToSha.has(contentKey)) {
+            // Reuse existing tree SHA
+            sha = treeContentToSha.get(contentKey);
+        }
+        else {
+            // Create new tree object
+            const treeObj = await createTreeObject(store, sortedEntries);
+            sha = treeObj.sha;
+            treeContentToSha.set(contentKey, sha);
+            uniqueTreeCount++;
+        }
+        return {
+            sha,
+            entries: sortedEntries,
+            subtrees: nodeSubtrees
+        };
+    }
+    // Build from root
+    const result = await buildNode(hierarchy);
+    // Convert BuildResult to BuildTreeResult format
+    function convertToResult(br) {
+        const subtreesConverted = {};
+        for (const [name, sub] of Object.entries(br.subtrees)) {
+            subtreesConverted[name] = convertToResult(sub);
+        }
+        return {
+            sha: br.sha,
+            entries: br.entries,
+            treeCount,
+            uniqueTreeCount,
+            deduplicatedCount: treeCount - uniqueTreeCount,
+            subtrees: Object.keys(subtreesConverted).length > 0 ? subtreesConverted : undefined
+        };
+    }
+    return convertToResult(result);
+}
+//# sourceMappingURL=tree-builder.js.map

package/dist/ops/tree-builder.js.map

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

package/dist/ops/tree-diff.d.ts

@@ -0,0 +1,243 @@
+/**
+ * Tree Diff Operations
+ *
+ * This module provides functionality for comparing Git trees and detecting
+ * changes between them, including added, deleted, modified, renamed, and
+ * copied files.
+ */
+import type { TreeEntry } from '../types/objects';
+import type { TreeDiffObjectStore as ObjectStore } from '../types/storage';
+/**
+ * Status of a file in a diff
+ */
+export declare enum DiffStatus {
+    /** File was added */
+    ADDED = "A",
+    /** File was deleted */
+    DELETED = "D",
+    /** File was modified */
+    MODIFIED = "M",
+    /** File was renamed */
+    RENAMED = "R",
+    /** File was copied */
+    COPIED = "C",
+    /** File type changed (e.g., file to symlink) */
+    TYPE_CHANGED = "T",
+    /** Unmerged (conflict) */
+    UNMERGED = "U"
+}
+/**
+ * File mode constants for Git objects
+ */
+export declare enum FileMode {
+    /** Regular file (not executable) */
+    REGULAR = "100644",
+    /** Executable file */
+    EXECUTABLE = "100755",
+    /** Symbolic link */
+    SYMLINK = "120000",
+    /** Git submodule (gitlink) */
+    GITLINK = "160000",
+    /** Directory (tree) */
+    TREE = "040000"
+}
+/**
+ * Represents a single entry in a diff result
+ */
+export interface DiffEntry {
+    /** Path to the file (new path for renames/copies) */
+    path: string;
+    /** Status of the change */
+    status: DiffStatus;
+    /** Old file mode (null for added files) */
+    oldMode: string | null;
+    /** New file mode (null for deleted files) */
+    newMode: string | null;
+    /** Old object SHA (null for added files) */
+    oldSha: string | null;
+    /** New object SHA (null for deleted files) */
+    newSha: string | null;
+    /** Original path (for renames/copies) */
+    oldPath?: string;
+    /** Similarity percentage (for renames/copies, 0-100) */
+    similarity?: number;
+    /** Whether the file is binary */
+    isBinary?: boolean;
+}
+/**
+ * Options for tree diff operations
+ */
+export interface DiffOptions {
+    /** Enable rename detection (default: true) */
+    detectRenames?: boolean;
+    /** Enable copy detection (default: false) */
+    detectCopies?: boolean;
+    /** Similarity threshold for rename/copy detection (0-100, default: 50) */
+    similarityThreshold?: number;
+    /** Filter paths by glob patterns (include) */
+    pathspecs?: string[];
+    /** Paths to exclude */
+    excludePaths?: string[];
+    /** Include binary file detection (default: true) */
+    detectBinary?: boolean;
+    /** Maximum file size to consider for rename/copy detection */
+    maxRenameSize?: number;
+    /** Whether to recurse into subdirectories (default: true) */
+    recursive?: boolean;
+    /** Only show names, not full diff info */
+    nameOnly?: boolean;
+    /** Show only file status, not diff content */
+    nameStatus?: boolean;
+}
+/**
+ * Result of a tree diff operation
+ */
+export interface DiffResult {
+    /** List of diff entries */
+    entries: DiffEntry[];
+    /** Statistics about the diff */
+    stats: {
+        added: number;
+        deleted: number;
+        modified: number;
+        renamed: number;
+        copied: number;
+    };
+}
+/**
+ * ObjectStore interface for tree diff operations.
+ * Re-exported from storage types for convenience.
+ */
+export type { ObjectStore };
+/**
+ * Represents an index entry for diff-to-index operations
+ */
+export interface IndexEntry {
+    path: string;
+    mode: string;
+    sha: string;
+    /** Stage number (0 = normal, 1-3 = merge conflict stages) */
+    stage: number;
+    /** File modification time */
+    mtime?: number;
+    /** File size */
+    size?: number;
+}
+/**
+ * Check if a file appears to be binary based on its content
+ *
+ * A file is considered binary if it contains null bytes in the first
+ * 8000 bytes (similar to Git's heuristic).
+ *
+ * @param content - File content to check
+ * @returns true if the file appears to be binary
+ */
+export declare function isBinaryContent(content: Uint8Array): boolean;
+/**
+ * Calculate similarity between two blobs for rename/copy detection
+ *
+ * Uses a simple heuristic based on shared content.
+ *
+ * @param store - Object store for retrieving blob contents
+ * @param oldSha - SHA of the old blob
+ * @param newSha - SHA of the new blob
+ * @returns Promise resolving to similarity percentage (0-100)
+ */
+export declare function calculateSimilarity(store: ObjectStore, oldSha: string, newSha: string): Promise<number>;
+/**
+ * Parse a file mode string and determine its type
+ *
+ * @param mode - File mode string (e.g., '100644', '040000')
+ * @returns Object with mode information
+ */
+export declare function parseMode(mode: string): {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+    isSubmodule: boolean;
+    isExecutable: boolean;
+};
+/**
+ * Check if a mode change represents a significant type change
+ *
+ * @param oldMode - Old file mode
+ * @param newMode - New file mode
+ * @returns true if the mode change is significant (e.g., file to symlink)
+ */
+export declare function isModeChangeSignificant(oldMode: string, newMode: string): boolean;
+/**
+ * Filter diff entries by pathspecs
+ *
+ * @param entries - Diff entries to filter
+ * @param pathspecs - Glob patterns to include
+ * @param excludePaths - Paths to exclude
+ * @returns Filtered entries
+ */
+export declare function filterByPathspecs(entries: DiffEntry[], pathspecs?: string[], excludePaths?: string[]): DiffEntry[];
+/**
+ * Recursively walk a tree and collect all entries with full paths
+ *
+ * @param store - Object store for retrieving tree contents
+ * @param treeSha - SHA of the tree to walk
+ * @param prefix - Path prefix for entries
+ * @returns Promise resolving to flat list of entries with full paths
+ */
+export declare function walkTree(store: ObjectStore, treeSha: string, prefix?: string): Promise<Array<TreeEntry & {
+    fullPath: string;
+}>>;
+/**
+ * Compare two trees and return the differences
+ *
+ * @param store - Object store for retrieving tree contents
+ * @param oldTreeSha - SHA of the old tree (null for initial commit comparison)
+ * @param newTreeSha - SHA of the new tree (null to compare against empty)
+ * @param options - Diff options
+ * @returns Promise resolving to diff result
+ */
+export declare function diffTrees(store: ObjectStore, oldTreeSha: string | null, newTreeSha: string | null, options?: DiffOptions): Promise<DiffResult>;
+/**
+ * Detect renames in a set of diff entries
+ *
+ * This function takes a list of added and deleted files and attempts to
+ * match them based on content similarity to detect renames.
+ *
+ * @param store - Object store for retrieving blob contents
+ * @param entries - Initial diff entries (before rename detection)
+ * @param options - Diff options (particularly similarityThreshold)
+ * @returns Promise resolving to entries with renames detected
+ */
+export declare function detectRenames(store: ObjectStore, entries: DiffEntry[], options?: DiffOptions): Promise<DiffEntry[]>;
+/**
+ * Detect copies in a set of diff entries
+ *
+ * This function takes a list of diff entries and attempts to detect
+ * if any added files are copies of existing files.
+ *
+ * @param store - Object store for retrieving blob contents
+ * @param entries - Initial diff entries
+ * @param existingPaths - Map of existing paths to their SHAs
+ * @param options - Diff options
+ * @returns Promise resolving to entries with copies detected
+ */
+export declare function detectCopies(store: ObjectStore, entries: DiffEntry[], existingPaths: Map<string, string>, options?: DiffOptions): Promise<DiffEntry[]>;
+/**
+ * Compare a tree to the index (staging area)
+ *
+ * @param store - Object store for retrieving tree contents
+ * @param treeSha - SHA of the tree to compare (typically HEAD)
+ * @param index - Index entries to compare against
+ * @param options - Diff options
+ * @returns Promise resolving to diff result
+ */
+export declare function diffTreeToIndex(store: ObjectStore, treeSha: string | null, index: IndexEntry[], options?: DiffOptions): Promise<DiffResult>;
+/**
+ * Compare a tree to working directory entries
+ *
+ * @param store - Object store for retrieving tree contents
+ * @param treeSha - SHA of the tree to compare
+ * @param workingEntries - Working directory file entries
+ * @param options - Diff options
+ * @returns Promise resolving to diff result
+ */
+export declare function diffTreeToWorktree(store: ObjectStore, treeSha: string | null, workingEntries: IndexEntry[], options?: DiffOptions): Promise<DiffResult>;
+//# sourceMappingURL=tree-diff.d.ts.map

package/dist/ops/tree-diff.d.ts.map

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