git.py

import argparse
import getpass
import hashlib
import logging
import os
import re
import stat
import struct
import time
import urllib.error
import urllib.request
import zlib
from configparser import ConfigParser
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple, Union

# Set up basic logging configuration
logging.basicConfig(level=logging.INFO, format="%(message)s")
logger = logging.getLogger(__name__)


def object_exists(hash_sha1: str, repo_path: Path) -> bool:
    """
    Checks if a Git object with the given hash exists in the repository.

    Args:
        hash_sha1 (str): The SHA-1 hash of the Git object to check.
        repo_path (Path): Path to the repository root directory.

    Returns:
        bool: True if the object exists, False otherwise.
    """
    object_dir = repo_path / ".git" / "objects" / hash_sha1[:2]
    object_path = object_dir / hash_sha1[2:]
    return object_path.is_file()


def write_git_object(sha1: str, content_compressed: bytes, repo_path: Path) -> Path:
    """
    Writes compressed Git object content to the .git/objects directory.

    Args:
        sha1 (str): The SHA-1 hash of the object.
        content_compressed (bytes): The compressed object content.
        repo_path (Path): Path to the repository root directory.

    Returns:
        Path: Path to the written object file.
    """
    object_dir = repo_path / ".git" / "objects"
    object_dir.mkdir(parents=True, mode=0o775, exist_ok=True)

    subdir = object_dir / sha1[:2]
    subdir.mkdir(mode=0o775, exist_ok=True)

    object_path = subdir / sha1[2:]

    # Check if the file already exists before trying to open it
    if object_path.is_file():
        logger.info(f"Object {sha1} already exists. Skipping write.")
        return object_path

    with open(object_path, "wb") as f:
        f.write(content_compressed)

    object_path.chmod(0o444)

    return object_path


def hash_object(
    file_path: Union[str, Path], repo_path: Path, write_flag: bool = False
) -> Tuple[Optional[str], Optional[bytes], Optional[bytes]]:
    """
    Computes the SHA-1 hash of a file and optionally writes it as a blob object.

    Args:
        file_path (str): Path to the file to hash.
        repo_path (Path): Path to the repository root directory.
        write_flag (bool): If True, writes the object to the Git database.

    Returns:
        tuple: (sha1_hash, file_content, full_content) or (None, None, None) on error.
    """
    try:
        with open(file_path, "rb") as f:
            content = f.read()
    except FileNotFoundError:
        logger.error(f"Error: File '{file_path}' not found.")
        return None, None, None

    header = f"blob {len(content)}\x00".encode("utf-8")
    full_content = header + content
    sha1 = hashlib.sha1(full_content).hexdigest()

    if write_flag:
        compressed_content = zlib.compress(full_content)
        write_git_object(sha1, compressed_content, repo_path)

    return sha1, content, full_content


def initialize_git_repository() -> None:
    """
    Initializes a new empty Git repository in the current directory.
    Creates the .git directory structure with objects, refs, and HEAD file.
    """
    logger.info("Initializing empty Git repository...")
    git_dir = Path(".git")
    git_dir.mkdir()

    # Create standard Git directories
    (git_dir / "objects").mkdir()
    (git_dir / "refs").mkdir()
    (git_dir / "refs" / "heads").mkdir()

    # Create the HEAD file, which points to 'refs/heads/master'
    with open(git_dir / "HEAD", "w") as f:
        f.write("ref: refs/heads/master\n")

    logger.info(f"Initialized empty Git repository in {Path.cwd() / '.git'}")


def ls_tree(args: argparse.Namespace, repo_path: Path) -> None:
    """
    Lists the contents of a Git tree object.

    Args:
        args: Parsed command line arguments containing object_hash, r (recursive), and name_only flags.
        repo_path (Path): Path to the repository root directory.
    """
    object_hash = args.object_hash
    recursive = args.r
    name_only = args.name_only

    # Read the Git object and its type
    data, object_type, _ = read_git_object(object_hash, repo_path)

    if data is None:
        logger.error(f"Error: Object '{object_hash}' not found.")
        return

    # Check if the object is actually a tree
    if object_type != b"tree":
        logger.error(f"Error: Object '{object_hash}' is not a tree object.")
        return

    offset = 0
    while offset < len(data):
        # Find the end of the mode and name part (before the null byte)
        null_byte_index = data.find(b"\x00", offset)
        if null_byte_index == -1:
            # Should not happen in a well-formed tree object
            break

        # Decode the mode and name part
        mode_and_name_part = data[offset:null_byte_index].decode("utf-8")
        mode, name = mode_and_name_part.split(" ", 1)

        # The SHA-1 hash is 20 bytes long and follows the null byte
        sha1_bytes_start = null_byte_index + 1
        sha1_bytes_end = sha1_bytes_start + 20
        sha1_bytes = data[sha1_bytes_start:sha1_bytes_end]

        # Convert binary SHA-1 hash to its hexadecimal string representation
        sha1_hex = sha1_bytes.hex()

        # Check if the entry is a directory (mode 40000)
        is_tree = mode == "40000"

        # Print the output
        if not name_only:
            mode_formatted = f"0{mode}"
            if is_tree:
                logger.info(f"{mode_formatted} {object_type.decode()} {sha1_hex}\t{name}")
            else:
                logger.info(f"{mode_formatted} blob {sha1_hex}\t{name}")
        else:
            logger.info(name)

        # If the recursive flag is set and the entry is a directory, call ls_tree recursively
        if recursive and is_tree:
            logger.info(f"\n{name}/")
            ls_tree(argparse.Namespace(object_hash=sha1_hex, r=True, name_only=name_only), repo_path)

        # Update the offset for the next entry
        offset = sha1_bytes_end


def cat_file(option: str, object_hash: str, repo_path: Path) -> None:
    """
    Displays content or type information for a Git object.

    Args:
        option (str): 'p' to print content, 't' to print type.
        object_hash (str): The SHA-1 hash of the Git object.
        repo_path (Path): Path to the repository root directory.
    """
    data, object_type, _ = read_git_object(object_hash, repo_path)
    if data:
        if option == "p":
            print(data.decode("utf-8"), end="")
        elif option == "t":
            logger.info(object_type.decode("utf-8") if object_type else "unknown")
    else:
        logger.error(f"Error: Object '{object_hash}' not found.")


def read_git_object(sha1: str, repo_path: Path) -> Tuple[Optional[bytes], Optional[bytes], Optional[int]]:
    """
    Reads a Git object from disk and decompresses it.

    Args:
        sha1 (str): The SHA-1 hash of the Git object.
        repo_path (Path): Path to the repository root directory.

    Returns:
        tuple: (content, object_type, size) or (None, None, None) on error.
    """
    object_path = repo_path / ".git" / "objects" / sha1[:2] / sha1[2:]
    if not object_path.is_file():
        return None, None, None

    try:
        with open(object_path, "rb") as f:
            compressed_content = f.read()

        decompressed_content = zlib.decompress(compressed_content)
        header, content = decompressed_content.split(b"\x00", 1)
        obj_type, size_str = header.decode().split()
        size = int(size_str)

        return content, obj_type.encode(), size

    except zlib.error as e:
        return None, None, None
    except Exception as e:
        return None, None, None


def read_index(index_path: Path) -> List[Dict[str, Any]]:
    """
    Reads the Git index file and parses its entries.

    Args:
        index_path (Path): Path to the Git index file.

    Returns:
        list: List of dictionaries containing index entry information.
    """
    if not index_path.exists():
        return []

    entries = []
    with open(index_path, "rb") as f:
        data = f.read()

    idx = 0
    # Read header
    magic, version, num_entries = struct.unpack(">4sLL", data[idx : idx + 12])
    idx += 12

    if magic != b"DIRC" or version != 2:
        logger.error("Invalid index file header.")
        return []

    # Read entries
    for _ in range(num_entries):
        entry_data = data[idx : idx + 62]
        ctime_s, ctime_n, mtime_s, mtime_n, dev, ino, mode, uid, gid, size, sha1_bytes, flags = struct.unpack(
            ">LLLLLLLLLL20sH", entry_data
        )
        idx += 62

        path_end = data.find(b"\x00", idx)
        path = data[idx:path_end].decode("utf-8", errors="surrogateescape")
        idx = path_end + 1

        # Adjust index for padding
        padding = (8 - ((62 + len(path) + 1) % 8)) % 8
        idx += padding

        entries.append(
            {
                "ctime_s": ctime_s,
                "ctime_n": ctime_n,
                "mtime_s": mtime_s,
                "mtime_n": mtime_n,
                "dev": dev,
                "ino": ino,
                "mode": mode,
                "uid": uid,
                "gid": gid,
                "size": size,
                "sha1": sha1_bytes.hex(),
                "flags": flags,
                "path": path,
            }
        )

    return entries


def write_index(index_path: Path, entries: List[Dict[str, Any]]) -> None:
    """
    Writes index entries to the Git index file in binary format.

    Args:
        index_path (Path): Path to the Git index file.
        entries (list): List of dictionaries containing index entry information.
    """
    with open(index_path, mode="wb+") as f:
        # Header
        f.write(struct.pack(">4sLL", b"DIRC", 2, len(entries)))

        # Entries
        for entry in entries:
            path_bytes = entry["path"].encode("utf-8")
            flags = entry["flags"] | len(path_bytes)

            f.write(
                struct.pack(
                    ">LLLLLLLLLL20sH",
                    entry["ctime_s"],
                    entry["ctime_n"],
                    entry["mtime_s"],
                    entry["mtime_n"],
                    entry["dev"],
                    entry["ino"],
                    entry["mode"],
                    entry["uid"],
                    entry["gid"],
                    entry["size"],
                    bytes.fromhex(entry["sha1"]),
                    flags,
                )
            )
            f.write(path_bytes)
            f.write(b"\x00")

            # Padding
            padding_len = (8 - ((62 + len(path_bytes) + 1) % 8)) % 8
            f.write(b"\x00" * padding_len)

        # SHA-1 checksum
        f.seek(0)
        checksum = hashlib.sha1(f.read()).digest()
        f.write(checksum)


def set_object_permissions(repo_path: Path) -> None:
    """
    Sets file permissions to 444 (read-only) for all Git object files.
    Prevents 'badFilemode' errors by ensuring correct file permissions.

    Args:
        repo_path (Path): Path to the repository root directory.
    """
    objects_path = repo_path / ".git" / "objects"
    if not objects_path.is_dir():
        logger.error("Error: .git/objects directory not found.")
        return

    logger.info("Setting object file permissions to 444...")

    for root, dirs, files in os.walk(objects_path):
        for file_name in files:
            file_path = Path(root) / file_name
            # Check if the file is an object file (e.g., not a packfile index)
            if len(file_name) == 38 and len(Path(root).name) == 2:
                try:
                    os.chmod(file_path, 0o444)
                except OSError as e:
                    logger.error(f"Error changing permissions for {file_path}: {e}")

    logger.info("Permissions updated successfully.")


def ls_files(repo_path: Path) -> None:
    """
    Lists all files currently staged in the Git index.

    Args:
        repo_path (Path): Path to the repository root directory.
    """
    index_path = repo_path / ".git" / "index"
    entries = read_index(index_path)
    for entry in entries:
        logger.info(entry["path"])


def add(file_path: Union[str, Path], repo_path: Path) -> None:
    """
    Adds a file to the Git index (staging area).

    Args:
        file_path (str): Path to the file to add.
        repo_path (Path): Path to the repository root directory.
    """
    file_path = Path(file_path)
    if not file_path.is_file():
        logger.error(f"Error: File '{file_path}' not found.")
        return

    # Hash the file content
    content = file_path.read_bytes()
    header = f"blob {len(content)}\x00".encode()
    sha1 = hashlib.sha1(header + content).hexdigest()

    # Write object to disk
    object_exists_flag = object_exists(sha1, repo_path)
    if not object_exists_flag:
        write_git_object(sha1, zlib.compress(header + content), repo_path)
    else:
        logger.info(f"Object {sha1} already exists. Skipping write.")

    # Read existing index entries
    index_path = repo_path / ".git" / "index"
    entries = read_index(index_path)

    # Create new index entry
    st = os.stat(file_path)

    # CORRECTION: This section ensures the file mode is correct for Git.
    # The original approach of using `st.st_mode` directly could lead to
    # the 'badFilemode' warning because `os.stat` returns platform-specific
    # bits that Git does not recognize or support.
    # By explicitly setting the mode to either 100644 (regular file)
    # or 100755 (executable file), we ensure the mode is always valid
    # for Git's index format.
    mode = st.st_mode

    if stat.S_ISREG(mode):
        if (mode & stat.S_IXUSR) or (mode & stat.S_IXGRP) or (mode & stat.S_IXOTH):
            mode = 0o100755
        else:
            mode = 0o100644
    elif stat.S_ISLNK(mode):
        mode = 0o120000
    else:
        logger.error(f"Unsupported file type for '{file_path}'. Skipping.")
        return

    new_entry = {
        "ctime_s": int(st.st_ctime),
        "ctime_n": 0,
        "mtime_s": int(st.st_mtime),
        "mtime_n": 0,
        "dev": st.st_dev,
        "ino": st.st_ino,
        "mode": mode,  # Use the corrected mode
        "uid": st.st_uid,
        "gid": st.st_gid,
        "size": st.st_size,
        "sha1": sha1,
        "flags": 0,
        "path": str(file_path),
    }

    # Add or update the entry
    new_entries = {entry["path"]: entry for entry in entries}
    new_entries[str(file_path)] = new_entry
    sorted_entries = sorted(new_entries.values(), key=lambda x: x["path"])

    # Write the new index file
    write_index(index_path, sorted_entries)
    logger.info(f"Files to add to the index: - {file_path}")


def write_tree_command(repo_path: Path) -> str:
    """
    Creates a tree object from the current index entries.

    Args:
        repo_path (Path): Path to the repository root directory.

    Returns:
        str: SHA-1 hash of the created tree object.
    """
    entries = read_index(repo_path)
    tree_hash = write_tree(entries, repo_path)
    logger.info(tree_hash)
    return tree_hash


def write_tree(entries: List[Dict[str, Any]], repo_path: Path) -> str:
    """
    Recursively creates tree objects from index entries.

    Args:
        entries (list): List of index entries to create tree from.
        repo_path (Path): Path to the repository root directory.

    Returns:
        str: SHA-1 hash of the created tree object.
    """
    if not entries:
        return ""

    # Sort entries by path
    entries.sort(key=lambda x: x["path"])

    # Group entries into subtrees based on the directory
    tree_entries = {}
    for entry in entries:
        parts = entry["path"].split("/", 1)
        if len(parts) == 1:
            # File at the current tree level
            tree_entries[parts[0]] = {"mode": entry["mode"], "sha1": entry["sha1"], "path": entry["path"]}
        else:
            dirname, rest = parts
            if dirname not in tree_entries:
                tree_entries[dirname] = {"mode": 0o40000, "path": dirname, "children": []}  # Directory mode
            tree_entries[dirname]["children"].append({"path": rest, "sha1": entry["sha1"], "mode": entry["mode"]})

    # Create tree content
    tree_content = b""
    for name, data in tree_entries.items():
        mode = data["mode"]

        if "children" in data:
            # The entry is a subtree, call recursively
            subtree_sha1 = write_tree(data["children"], repo_path)
            sha1_bytes = bytes.fromhex(subtree_sha1)
        else:
            # The entry is a file, use the hash from the index
            sha1_bytes = bytes.fromhex(data["sha1"])

        mode_str = f"{mode:o}".encode("ascii")

        tree_content += mode_str + b" " + name.encode("utf-8") + b"\x00" + sha1_bytes

    header = f"tree {len(tree_content)}\x00".encode("utf-8")
    full_content = header + tree_content
    sha1 = hashlib.sha1(full_content).hexdigest()

    # Write the tree object
    compressed_content = zlib.compress(full_content)
    write_git_object(sha1, compressed_content, repo_path)

    return sha1


def get_author_info(repo_path: Path) -> Tuple[str, str]:
    """
    Retrieves author information following Git's configuration hierarchy.
    Checks environment variables, local config, then global config.

    Args:
        repo_path (Path): Path to the repository root directory.

    Returns:
        tuple: (author_name, author_email)
    """
    # 1. Check environment variables
    author_name = os.getenv("GIT_AUTHOR_NAME")
    author_email = os.getenv("GIT_AUTHOR_EMAIL")

    # If not found in environment variables, check your Git configuration
    if not author_name or not author_email:
        config_local_path = repo_path / ".git" / "config"
        config_global_path = Path.home() / ".gitconfig"

        config = ConfigParser()

        # 2. Check the local configuration file
        if config_local_path.is_file():
            config.read(config_local_path)
            if "user" in config and "name" in config["user"]:
                author_name = config["user"]["name"]
            if "user" in config and "email" in config["user"]:
                author_email = config["user"]["email"]

        # 3. Check the global configuration file if the local configuration is not sufficient
        if (not author_name or not author_email) and config_global_path.is_file():
            config.read(config_global_path)
            if "user" in config and "name" in config["user"]:
                author_name = config["user"]["name"]
            if "user" in config and "email" in config["user"]:
                author_email = config["user"]["email"]

    # 4. Use default value if nothing found
    if not author_name:
        author_name = "Unknown User"
    if not author_email:
        author_email = "unknown.email@example.com"

    return author_name, author_email


def commit_tree(tree_hash: str, parent_hash: Optional[str], message: str, repo_path: Path) -> str:
    """
    Creates a new commit object with the specified tree and parent.

    Args:
        tree_hash (str): SHA-1 hash of the tree object.
        parent_hash (str): SHA-1 hash of the parent commit (can be None).
        message (str): Commit message.
        repo_path (Path): Path to the repository root directory.

    Returns:
        str: SHA-1 hash of the created commit object.
    """
    lines = [f"tree {tree_hash}"]
    if parent_hash:
        lines.append(f"parent {parent_hash}")

    # Data for the commit creation
    timestamp = int(time.time())
    timezone_offset = time.strftime("%z", time.localtime())

    author_name, author_email = get_author_info(repo_path)

    author = f"{author_name} <{author_email}> {timestamp} {timezone_offset}"
    committer = f"{author_name} <{author_email}> {timestamp} {timezone_offset}"

    lines.append(f"author {author}")
    lines.append(f"committer {committer}")
    lines.append("")
    lines.append(message + "\n")

    content = "\n".join(lines).encode("utf-8")

    header = f"commit {len(content)}\x00".encode("utf-8")
    full_content = header + content
    sha1 = hashlib.sha1(full_content).hexdigest()

    # Write the commit object
    compressed_content = zlib.compress(full_content)
    write_git_object(sha1, compressed_content, repo_path)

    logger.info(sha1)
    return sha1


def commit(args: argparse.Namespace, repo_path: Path) -> None:
    """
    Creates a new commit from staged changes in the index.

    Args:
        args: Parsed command line arguments containing the commit message.
        repo_path (Path): Path to the repository root directory.
    """
    if not (repo_path / ".git" / "index").is_file():
        logger.error("Error: No staged changes. Use 'git add' to stage files first.")
        return

    tree_hash = write_tree_command(repo_path)

    head_path = repo_path / ".git" / "HEAD"
    if head_path.is_file():
        with open(head_path, "r") as f:
            head_ref = f.read().strip()

        if head_ref.startswith("ref: "):
            branch_name = head_ref.split(": ")[1]
            branch_path = repo_path / ".git" / branch_name
            if branch_path.is_file():
                with open(branch_path, "r") as f:
                    parent_hash = f.read().strip()
            else:
                parent_hash = None
    else:
        parent_hash = None

    commit_hash = commit_tree(tree_hash, parent_hash, args.message, repo_path)

    if parent_hash is None:
        logger.info(f"[{branch_name.split('/')[-1]} (root-commit) {commit_hash[:7]}] {args.message}")
    else:
        logger.info(f"[{branch_name.split('/')[-1]} {commit_hash[:7]}] {args.message}")

    # Update the branch reference file
    with open(branch_path, "w") as f:
        f.write(commit_hash)

    # Add the fix: Reset the index to the state of the new tree.
    # This ensures `git status` correctly shows no pending changes.
    create_index_file(tree_hash, repo_path)


# def clone_repository(repo_url, directory=None):
#     """
#     Clones a remote Git repository.
#     """
#     # 1. Parse repository URL
#     match = re.match(r'https://github.com/([^/]+)/([^/]+)\.git', repo_url)
#     if not match:
#         logger.error("Error: Invalid GitHub repository URL.")
#         return

#     owner, repo_name = match.groups()
#     if directory is None:
#         directory = repo_name

#     logger.info(f"Starting to clone repository from {repo_url}...")

#     # 2. Get initial refs from the server
#     git_service_url = f"https://github.com/{owner}/{repo_name}.git/info/refs?service=git-upload-pack"
#     try:
#         response = requests.get(git_service_url)
#         response.raise_for_status()
#     except requests.exceptions.RequestException as e:
#         logger.error(f"Error while fetching refs from the server: {e}")
#         return

#     # 3. Find HEAD commit hash from server response
#     head_hash = None
#     head_ref = None
#     data_str = response.text

#     # Show data from the server (like in your log)
#     logger.info("--- Data from server ---")
#     logger.info(data_str)
#     logger.info("------------------------")

#     # Look for the symbolic HEAD reference, e.g., "symref=HEAD:refs/heads/master"
#     symref_match = re.search(r'symref=HEAD:(\S+)', data_str)
#     if symref_match:
#         head_ref = symref_match.group(1)
#         logger.info(f"Found symbolic HEAD reference pointing to: '{head_ref}'")
#     else:
#         # If there's no symref, try to find "HEAD" directly
#         head_match = re.search(r'([0-9a-f]{40})\s+HEAD', data_str)
#         if head_match:
#             head_hash = head_match.group(1)
#             logger.info(f"Found HEAD commit hash: {head_hash}")

#     # If a symbolic reference was found, find its hash
#     if head_ref:
#         ref_match = re.search(fr'([0-9a-f]{{40}})\s+{re.escape(head_ref)}', data_str)
#         if ref_match:
#             head_hash = ref_match.group(1)
#             logger.info(f"Found commit hash for '{head_ref}': {head_hash}")
#         else:
#             logger.error(f"Error: Could not find commit hash for branch '{head_ref}'.")
#             return

#     if not head_hash:
#         logger.error("Error: Could not find HEAD commit hash.")
#         return

#     # 4. Create the new directory and initialize a Git repository
#     if Path(directory).exists():
#         logger.error(f"Error: Directory '{directory}' already exists.")
#         return

#     logger.info(f"Creating directory '{directory}'...")
#     os.makedirs(directory)
#     os.chdir(directory)

#     logger.info("Initializing local repository...")
#     initialize_git_repository()

#     # 5. Update the .git/HEAD file
#     head_file_path = Path('.git/HEAD')
#     with open(head_file_path, 'w') as f:
#         f.write(f"ref: {head_ref}\n")

#     logger.info(f"Set local HEAD file to: {head_ref}")

#     # 6. The rest of the cloning logic, e.g., fetching objects from the server, goes here
#     logger.info(f"Fetching objects, starting from commit: {head_hash}")

#     # Logic for fetching the commit and its tree is omitted here,
#     # as it was not part of your original problem.

#     logger.info("Cloning completed successfully!")


def setup_git_config(
    repo_path: Path, remote_url: str, branch_name: str = "master", remote_name: str = "origin"
) -> None:
    """
    Creates or updates the Git configuration file with repository settings.

    Args:
        repo_path (Path): Path to the repository root directory.
        remote_url (str): URL of the remote repository.
        branch_name (str): Name of the default branch (default: 'master').
        remote_name (str): Name of the remote (default: 'origin').
    """
    config = ConfigParser()
    config_path = repo_path / ".git" / "config"

    # Read the existing file if it exists
    if config_path.is_file():
        config.read(config_path)

    # Set up the [core] section
    if "core" not in config:
        config["core"] = {
            "repositoryformatversion": "0",
            "filemode": "true",
            "bare": "false",
            "logallrefupdates": "true",
        }

    # Set up the [remote "origin"] section
    remote_section = f'remote "{remote_name}"'
    if not config.has_section(remote_section):
        config[remote_section] = {"url": remote_url, "fetch": "+refs/heads/*:refs/remotes/origin/*"}

    # Set up the [branch "master"] section
    branch_section = f'branch "{branch_name}"'
    if not config.has_section(branch_section):
        config[branch_section] = {"remote": remote_name, "merge": f"refs/heads/{branch_name}"}

    # Write the changes to the file
    with open(config_path, "w") as configfile:
        config.write(configfile)


def clone(repo_url: str, directory: Optional[str] = None) -> None:
    """
    Clones a remote Git repository using the Smart HTTP protocol.

    Args:
        repo_url (str): URL of the repository to clone.
        directory (str, optional): Directory name for the cloned repository.
    """
    repo_url = repo_url if ".git" in repo_url else repo_url + ".git"
    repo_name = directory if directory else repo_url.split("/")[-1].split(".git")[0]
    logger.info(f"Cloning into '{repo_name}'...")

    # 1. Discover refs (get the latest commit hash for the main branch)
    logger.info("Fetching references...")
    try:
        request = urllib.request.Request(
            url=f"{repo_url}/info/refs?service=git-upload-pack",
            method="GET",
        )
        refs_response = urllib.request.urlopen(request)
        if refs_response.getcode() >= 400:
            raise urllib.error.HTTPError(
                f"{repo_url}/info/refs?service=git-upload-pack",
                refs_response.getcode(),
                "HTTP Error",
                refs_response.headers,
                None,
            )
    except urllib.error.URLError as e:
        logger.error(f"Error while fetching references: {e.reason}")
        return
    except urllib.error.HTTPError as e:
        logger.error(f"HTTP Error while fetching references: {e.code} - {e.reason}")
        return

    logger.info("Full response from info/refs:")
    data = refs_response.read().decode("utf-8")

    head_commit_hash = find_head_commit(data)
    if not head_commit_hash:
        logger.error("Could not find HEAD commit hash. Exiting.")
        return
    logger.info(f"Fetched HEAD commit hash: {head_commit_hash}")

    # 2. Request the packfile
    logger.info("Sending request for packfile...")

    want_line = f"want {head_commit_hash}\n"
    want_payload = f"{len(want_line) + 4:04x}{want_line}".encode("utf-8")

    flush_packet = b"0000"

    done_line = "done\n"
    done_payload = f"{len(done_line) + 4:04x}{done_line}".encode("utf-8")

    full_payload = want_payload + flush_packet + done_payload

    logger.debug(f"Constructed data sent in POST request: {full_payload!r}")

    headers = {"Content-Type": "application/x-git-upload-pack-request"}
    try:
        req = urllib.request.Request(f"{repo_url}/git-upload-pack", data=full_payload, headers=headers, method="POST")
        with urllib.request.urlopen(req) as response:
            packfile_data = parse_packfile_response(response)
            logger.info(f"Received response from server: {response.getcode()} {response.reason}")
            if response.getcode() >= 400:
                raise urllib.error.HTTPError(
                    f"HTTP Error: {response.getcode()}", response.getcode(), response.reason, response.headers, None
                )
    except urllib.error.HTTPError as e:
        logger.error(f"HTTP Error: {e.code} {e.reason}")
        return
    except urllib.error.URLError as e:
        logger.error(f"URL Error while requesting packfile: {e.reason}")
        return

    if not packfile_data:
        logger.error("No packfile data found in the response.")
        return

    # 3. Unpack the packfile
    logger.info("Unpacking the packfile...")
    repo_path = Path(repo_name)
    repo_path.mkdir(parents=True, mode=0o775, exist_ok=True)

    git_dir = repo_path / ".git"
    git_objests = git_dir / "objects"

    git_pack = git_objests / "pack"
    git_pack.mkdir(parents=True, mode=0o775, exist_ok=True)

    git_info = git_objests / "info"
    git_info.mkdir(parents=True, mode=0o775, exist_ok=True)

    pack_path = git_pack / "pack-temp.pack"
    with open(pack_path, "wb") as f:
        f.write(packfile_data)

    unpack_packfile(pack_path, repo_path)

    set_object_permissions(repo_path)

    # 4. Checkout the commit
    logger.info(f"Checking out commit {head_commit_hash}...")

    with open(git_dir / "HEAD", "w") as f:
        f.write(f"ref: refs/heads/master\n")

    refs_path = git_dir / "refs" / "heads"
    refs_path.mkdir(parents=True, mode=0o775, exist_ok=True)

    with open(refs_path / "master", "w") as f:
        f.write(head_commit_hash + "\n")

    remotes_dir = git_dir / "refs" / "remotes"
    remotes_dir.mkdir(parents=True, mode=0o775, exist_ok=True)
    origin_dir = remotes_dir / "origin"
    origin_dir.mkdir(parents=True, mode=0o775, exist_ok=True)

    with open(origin_dir / "master", "w") as f:
        f.write(head_commit_hash + "\n")

    checkout(head_commit_hash, repo_path)

    setup_git_config(repo_path, repo_url)

    logger.info("Cloning completed successfully!")


def find_head_commit(refs_text: str) -> Optional[str]:
    """
    Parses Git references to find the HEAD commit hash.

    Args:
        refs_text (str): Raw text containing Git references.

    Returns:
        str: SHA-1 hash of the HEAD commit, or None if not found.
    """
    lines = refs_text.strip().split("\n")
    for line in lines:
        parts = line.split()
        if len(parts) == 2 and parts[1] == "refs/heads/main":
            return parts[0][-40:]

    for line in lines:
        parts = line.split()
        if len(parts) == 2 and parts[1] == "refs/heads/master":
            return parts[0][-40:]

    return None


def parse_packfile_response(response: Any) -> bytes:
    """
    Extracts packfile data from a Git upload-pack response stream.

    Args:
        response: HTTP response object from git-upload-pack request.

    Returns:
        bytes: Raw packfile data, or empty bytes on error.
    """
    packfile_data = b""
    while response.readable() is True:
        try:
            chunk = response.read(8192)
            if not chunk:
                break  # End of stream

            # Check for the PACK header to find the start of the packfile
            pack_header_start = chunk.find(b"PACK")
            if pack_header_start != -1:
                packfile_data += chunk[pack_header_start:]

                # Once we find the header, the rest of the stream is the packfile
                # so we can break the loop
                while response.readable():
                    try:
                        remaining_chunk = response.read(8192)
                        if not remaining_chunk:
                            break  # End of stream
                        packfile_data += remaining_chunk
                    except Exception as e:
                        logger.error(f"Error while reading the response stream: {e}")
                        return b""  # Return empty stream on error
                break
        except Exception as e:
            logger.error(f"Error while reading the response stream: {e}")
            return b""  # Return empty stream on error

    return packfile_data


def unpack_packfile(pack_path: Path, repo_path: Path) -> None:
    """
    Unpacks a Git packfile and writes objects to the repository.
    Handles base objects and resolves delta objects iteratively.

    Args:
        pack_path (Path): Path to the packfile to unpack.
        repo_path (Path): Path to the repository root directory.
    """
    unpacked_objects = {}
    delta_objects = []

    with open(pack_path, "rb") as f:
        data = f.read()

    pack_header = data[:12]
    if pack_header[:4] != b"PACK":
        raise ValueError("Invalid packfile header.")

    num_objects = int.from_bytes(pack_header[8:12], byteorder="big")
    logger.info(f"Packfile contains {num_objects} objects.")

    cursor = 12
    # First pass: identify all objects and unpack non-deltas
    for _ in range(num_objects):
        obj_type, size, header_end_pos = read_header(data, cursor)

        if obj_type in [1, 2, 3, 4]:  # Non-delta object
            compressed_data_start = header_end_pos
            decompressor = zlib.decompressobj()
            decompressed_data = decompressor.decompress(data[compressed_data_start:])
            bytes_read = len(data[compressed_data_start:]) - len(decompressor.unused_data)

            obj_type_str = get_obj_type_str(obj_type)
            header = f"{obj_type_str} {len(decompressed_data)}\x00".encode()
            store_data = header + decompressed_data
            obj_hash = hashlib.sha1(store_data).hexdigest()

            unpacked_objects[obj_hash] = {
                "type": obj_type,
                "data": decompressed_data,
                "offset": cursor,
            }
            cursor = compressed_data_start + bytes_read
        elif obj_type == 6:  # OFS_DELTA
            offset_bytes, base_offset = read_offset(data, header_end_pos)
            compressed_data_start = header_end_pos + offset_bytes

            decompressor = zlib.decompressobj()
            decompressed_data = decompressor.decompress(data[compressed_data_start:])
            bytes_read = len(data[compressed_data_start:]) - len(decompressor.unused_data)

            delta_objects.append(
                {"type": obj_type, "base_ref": cursor - base_offset, "delta_data": decompressed_data, "offset": cursor}
            )
            cursor = compressed_data_start + bytes_read
        elif obj_type == 7:  # REF_DELTA:
            base_sha = data[header_end_pos : header_end_pos + 20].hex()
            compressed_data_start = header_end_pos + 20

            decompressor = zlib.decompressobj()
            decompressed_data = decompressor.decompress(data[compressed_data_start:])
            bytes_read = len(data[compressed_data_start:]) - len(decompressor.unused_data)

            delta_objects.append(
                {"type": obj_type, "base_ref": base_sha, "delta_data": decompressed_data, "offset": cursor}
            )
            cursor = compressed_data_start + bytes_read
        else:
            raise ValueError(f"Unknown object type: {obj_type}")

    # Iterative unpacking of deltas
    unpacked_count = 0
    while delta_objects:
        initial_len = len(delta_objects)
        unresolved_deltas = []

        for delta in delta_objects:
            base_object = None
            if delta["type"] == 6:
                # OFS_DELTA: Find the base object by its offset
                base_object = next(
                    (obj for obj in unpacked_objects.values() if obj.get("offset") == delta["base_ref"]), None
                )
            elif delta["type"] == 7:
                # REF_DELTA: Find the base object by its SHA-1 hash
                base_object = unpacked_objects.get(delta["base_ref"])

            if base_object:
                full_data = apply_delta(base_object["data"], delta["delta_data"])

                obj_type_str = get_obj_type_str(base_object["type"])
                header = f"{obj_type_str} {len(full_data)}\x00".encode()
                store_data = header + full_data
                obj_hash = hashlib.sha1(store_data).hexdigest()

                unpacked_objects[obj_hash] = {
                    "type": base_object["type"],
                    "data": full_data,
                    "offset": delta["offset"] if "offset" in delta else None,  # Store original delta's offset
                }
                unpacked_count += 1
            else:
                unresolved_deltas.append(delta)

        if len(unresolved_deltas) == initial_len:
            raise ValueError(f"Error: Could not unpack {initial_len} delta objects due to missing base objects.")

        delta_objects = unresolved_deltas

    logger.info(f"Successfully unpacked {unpacked_count} delta objects.")

    # Writing all unpacked objects to disk
    logger.info("Writing objects to disk...")
    for obj_hash, obj_info in unpacked_objects.items():
        obj_data = obj_info["data"]
        obj_type_str = get_obj_type_str(obj_info["type"])

        header = f"{obj_type_str} {len(obj_data)}\x00".encode()
        store_data = header + obj_data

        dir_name = obj_hash[:2]
        file_name = obj_hash[2:]
        obj_dir = repo_path / ".git" / "objects" / dir_name
        os.makedirs(obj_dir, exist_ok=True)
        with open(obj_dir / file_name, "wb") as f:
            f.write(zlib.compress(store_data))


def read_object(object_hash: str, repo_path: Path) -> Tuple[str, bytes]:
    """
    Reads and decompresses a Git object from the object database.

    Args:
        object_hash (str): SHA-1 hash of the Git object.
        repo_path (Path): Path to the repository root directory.

    Returns:
        tuple: (object_type, object_data)
    """
    dir_name = object_hash[:2]
    file_name = object_hash[2:]
    obj_path = repo_path / ".git" / "objects" / dir_name / file_name

    with open(obj_path, "rb") as f:
        compressed_data = f.read()

    decompressed_data = zlib.decompress(compressed_data)

    null_byte_index = decompressed_data.find(b"\x00")
    header = decompressed_data[:null_byte_index].decode()
    obj_type, size = header.split()

    return obj_type, decompressed_data[null_byte_index + 1 :]


def checkout(commit_hash: str, repo_path: Path) -> None:
    """
    Checks out a commit by extracting its tree to the working directory.

    Args:
        commit_hash (str): SHA-1 hash of the commit to checkout.
        repo_path (Path): Path to the repository root directory.
    """
    logger.info(f"Extracting files from commit: {commit_hash}...")

    commit_type, commit_data = read_object(commit_hash, repo_path)
    if commit_type != "commit":
        raise ValueError(f"Expected object type 'commit', but got '{commit_type}'")

    lines = commit_data.decode().split("\n")
    tree_hash = None
    for line in lines:
        if line.startswith("tree "):
            tree_hash = line.split()[1]
            break

    if not tree_hash:
        raise ValueError("No tree hash found in the commit object.")

    read_tree(tree_hash, repo_path, repo_path)

    logger.info("Creating index file...")
    create_index_file(tree_hash, repo_path)


def read_tree(tree_hash: str, parent_path: Path, repo_path: Path) -> None:
    """
    Recursively extracts files and directories from a tree object.

    Args:
        tree_hash (str): SHA-1 hash of the tree object.
        parent_path (Path): Parent directory path for extraction.
        repo_path (Path): Path to the repository root directory.
    """
    tree_type, tree_data = read_object(tree_hash, repo_path)
    if tree_type != "tree":
        raise ValueError(f"Expected object type 'tree', but got '{tree_type}'")

    cursor = 0
    while cursor < len(tree_data):
        # Read mode
        mode_end = tree_data.find(b" ", cursor)
        mode = tree_data[cursor:mode_end].decode()
        cursor = mode_end + 1

        # Read filename
        name_end = tree_data.find(b"\x00", cursor)
        name = tree_data[cursor:name_end].decode()
        cursor = name_end + 1

        # Read hash
        obj_hash = tree_data[cursor : cursor + 20].hex()
        cursor += 20

        file_path = parent_path / name

        if mode == "40000":
            # It's a directory (tree)
            os.makedirs(file_path, exist_ok=True)
            read_tree(obj_hash, file_path, repo_path)
        else:
            # It's a file (blob)
            obj_type, obj_data = read_object(obj_hash, repo_path)
            if obj_type != "blob":
                raise ValueError(f"Expected object type 'blob', but got '{obj_type}'")
            with open(file_path, "wb") as f:
                f.write(obj_data)


def create_index_file(tree_hash: str, repo_path: Path) -> None:
    """
    Creates a Git index file from a tree object.

    Args:
        tree_hash (str): SHA-1 hash of the tree object.
        repo_path (Path): Path to the repository root directory.
    """
    git_dir = repo_path / ".git"
    index_path = git_dir / "index"

    # DIRC header (version 2, number of entries will be added later)
    header = b"DIRC" + (2).to_bytes(4, "big") + (0).to_bytes(4, "big")

    entries_list: List[bytes] = []
    create_index_entries_from_tree(tree_hash, "", entries_list, repo_path)

    # Update number of entries in header
    header = b"DIRC" + (2).to_bytes(4, "big") + len(entries_list).to_bytes(4, "big")

    entries_data = b"".join(entries_list)

    # Calculate SHA1 checksum of the index content
    index_checksum = hashlib.sha1(header + entries_data).digest()

    with open(index_path, "wb") as f:
        f.write(header + entries_data + index_checksum)

    logger.info("Index file has been created.")


def create_index_entries_from_tree(tree_hash: str, prefix: str, entries_list: List[bytes], repo_path: Path) -> None:
    """
    Recursively creates index entries from a tree object.

    Args:
        tree_hash (str): SHA-1 hash of the tree object.
        prefix (str): Path prefix for entries.
        entries_list (list): List to append index entries to.
        repo_path (Path): Path to the repository root directory.
    """
    tree_type, tree_data = read_object(tree_hash, repo_path)
    if tree_type != "tree":
        raise ValueError("Invalid object type. Expected 'tree'.")

    cursor = 0
    while cursor < len(tree_data):
        mode_end = tree_data.find(b" ", cursor)
        mode = tree_data[cursor:mode_end].decode()
        cursor = mode_end + 1

        name_end = tree_data.find(b"\x00", cursor)
        name = tree_data[cursor:name_end].decode()
        cursor = name_end + 1

        obj_hash_raw = tree_data[cursor : cursor + 20]
        cursor += 20

        file_path = Path(prefix) / name if prefix else Path(name)

        logger.debug("\n--- Starting to create index entry for file: ---")
        logger.debug(f"File path: {file_path}")

        if mode == "40000":
            # It's a directory, recurse
            logger.debug(f"This is a directory, recursing into: {file_path}")
            create_index_entries_from_tree(obj_hash_raw.hex(), str(file_path), entries_list, repo_path)
        else:
            # It's a file
            stats = os.stat(repo_path / file_path)

            # Extract and print numerical values
            ctime_s = int(stats.st_ctime)
            ctime_ns = int(stats.st_ctime_ns % 1_000_000_000)
            mtime_s = int(stats.st_mtime)
            mtime_ns = int(stats.st_mtime_ns % 1_000_000_000)
            dev = stats.st_dev
            ino = stats.st_ino
            uid = stats.st_uid
            gid = stats.st_gid
            size = stats.st_size

            logger.debug(f"Mode: {mode}")
            logger.debug(f"ctime_s: {ctime_s}")
            logger.debug(f"ctime_ns: {ctime_ns}")
            logger.debug(f"mtime_s: {mtime_s}")
            logger.debug(f"mtime_ns: {mtime_ns}")
            logger.debug(f"dev: {dev}")
            logger.debug(f"ino: {ino}")
            logger.debug(f"uid: {uid}")
            logger.debug(f"gid: {gid}")
            logger.debug(f"size: {size}")
            logger.debug(f"hash: {obj_hash_raw.hex()}")

            # Build the binary entry
            entry = b""
            entry += ctime_s.to_bytes(4, "big")
            entry += ctime_ns.to_bytes(4, "big")
            entry += mtime_s.to_bytes(4, "big")
            entry += mtime_ns.to_bytes(4, "big")
            entry += dev.to_bytes(4, "big")
            entry += ino.to_bytes(4, "big")
            entry += int(mode, 8).to_bytes(4, "big")
            entry += uid.to_bytes(4, "big")
            entry += gid.to_bytes(4, "big")
            entry += size.to_bytes(4, "big")
            entry += obj_hash_raw

            # Flags (2 bytes)
            path_bytes = str(file_path).encode("utf-8")
            path_len = len(path_bytes)
            flags = path_len & 0xFFF
            entry += flags.to_bytes(2, "big")

            entry += path_bytes

            # Pad to a multiple of 8 bytes
            padding = 8 - (len(entry) % 8)
            entry += b"\x00" * padding

            entries_list.append(entry)


def read_header(data: bytes, cursor: int) -> Tuple[int, int, int]:
    """
    Reads packfile object header to extract type and size information.

    Args:
        data (bytes): Packfile data.
        cursor (int): Current position in the data.

    Returns:
        tuple: (object_type, size, new_cursor_position)
    """
    header_byte = data[cursor]
    obj_type = (header_byte >> 4) & 0x7
    size = header_byte & 0xF
    cursor += 1

    shift = 4
    while header_byte & 0x80:
        header_byte = data[cursor]
        size |= (header_byte & 0x7F) << shift
        cursor += 1
        shift += 7

    return obj_type, size, cursor


def read_offset(data: bytes, cursor: int) -> Tuple[int, int]:
    """
    Reads variable-length offset from packfile data.

    Args:
        data (bytes): Packfile data.
        cursor (int): Current position in the data.

    Returns:
        tuple: (bytes_read, offset_value)
    """
    offset = 0
    shift = 0
    bytes_read = 0
    while True:
        byte = data[cursor + bytes_read]
        offset |= (byte & 0x7F) << shift
        bytes_read += 1
        if not (byte & 0x80):
            break
        shift += 7
        offset += 1
    return bytes_read, offset


def apply_delta(base_data: bytes, delta_data: bytes) -> bytes:
    """
    Applies delta instructions to reconstruct an object from its base.

    Args:
        base_data (bytes): Data of the base object.
        delta_data (bytes): Delta instructions.

    Returns:
        bytes: Reconstructed object data.
    """
    cursor = 0
    source_size, cursor = read_delta_size(delta_data, cursor)
    dest_size, cursor = read_delta_size(delta_data, cursor)

    new_data = bytearray()

    while cursor < len(delta_data):
        command = delta_data[cursor]
        cursor += 1

        if command & 0x80:
            # Copy command (1xxxxxxx)
            offset = 0
            if command & 0x01:
                offset |= delta_data[cursor] << 0
                cursor += 1
            if command & 0x02:
                offset |= delta_data[cursor] << 8
                cursor += 1
            if command & 0x04:
                offset |= delta_data[cursor] << 16
                cursor += 1
            if command & 0x08:
                offset |= delta_data[cursor] << 24
                cursor += 1

            size = 0
            if command & 0x10:
                size |= delta_data[cursor] << 0
                cursor += 1
            if command & 0x20:
                size |= delta_data[cursor] << 8
                cursor += 1
            if command & 0x40:
                size |= delta_data[cursor] << 16
                cursor += 1

            if size == 0:
                size = 0x10000

            new_data.extend(base_data[offset : offset + size])
        else:
            # Insert command (0xxxxxxx)
            size = command & 0x7F
            new_data.extend(delta_data[cursor : cursor + size])
            cursor += size

    if len(new_data) != dest_size:
        logger.error(f"ERROR: Final size ({len(new_data)}) does not match destination size ({dest_size}).")

    return bytes(new_data)


def read_delta_size(data: bytes, cursor: int) -> Tuple[int, int]:
    """
    Reads variable-length size from delta data.

    Args:
        data (bytes): Delta data.
        cursor (int): Current position in the data.

    Returns:
        tuple: (size, new_cursor_position)
    """
    size = 0
    shift = 0
    while True:
        byte = data[cursor]
        size |= (byte & 0x7F) << shift
        cursor += 1
        if not (byte & 0x80):
            break
        shift += 7
    return size, cursor


def get_obj_type_str(obj_type: int) -> str:
    """
    Converts numeric object type to string representation.

    Args:
        obj_type (int): Numeric Git object type.

    Returns:
        str: String representation of the object type.
    """
    types = {1: "commit", 2: "tree", 3: "blob", 4: "tag"}
    return types.get(obj_type, "unknown")


def process_files(files_or_dir: Union[str, List[str]]) -> List[Path]:
    """
    Processes file paths for Git operations, handling files and directories.

    Args:
        files_or_dir: Single file path, list of paths, or '.' for all files.

    Returns:
        list: List of Path objects for files to process.
    """
    paths_to_process = []
    if files_or_dir == ".":
        # Use glob to find all files in the current directory and subdirectories
        # **/* means recursive search from the current directory
        paths_to_process = [Path(f) for f in Path(".").glob("**/*") if Path(f).is_file()]
    elif isinstance(files_or_dir, list):
        # Process the given list of paths
        for item in files_or_dir:
            p = Path(item)
            if p.is_file():
                paths_to_process.append(p)
            elif p.is_dir():
                # If a directory is provided, add all files from that directory recursively
                paths_to_process.extend([Path(f) for f in p.glob("**/*") if Path(f).is_file()])
            else:
                logger.warning(f"Warning: Path '{item}' does not exist or is not a file/directory.")
    else:
        # Handle a single file
        p = Path(files_or_dir)
        if p.is_file():
            paths_to_process.append(p)
        else:
            logger.warning(f"Warning: Path '{files_or_dir}' does not exist or is not a file.")

    # Here you can add the logic for adding files to the Git index
    # For the purpose of this example, we will just print the paths
    if paths_to_process:
        logger.info("Files to add to the index:")
        for path in paths_to_process:
            logger.info(f"- {path}")
        return paths_to_process
    else:
        logger.info("No files found to process.")


def ls_remote(url: str) -> Optional[Dict[str, str]]:
    """
    Lists references from a remote Git repository.

    Args:
        url (str): URL of the remote repository.

    Returns:
        dict: Dictionary mapping reference names to SHA-1 hashes, or None on error.
    """
    logger.info(f"From {url}")

    # Git uses a special URL to get information about references
    url = url.replace("git://", "https://")
    refs_url = f"{url}/info/refs?service=git-upload-pack"

    try:
        # Performing the HTTP request
        with urllib.request.urlopen(refs_url) as response:
            data = response.read()

            # Use regex to find all hashes and their corresponding refs
            references = {}
            # Regex to find hash followed by a reference, and optional capabilities separated by a null byte
            matches = re.findall(r"([0-9a-f]{40})\s+(\S+)(?:\x00|\s.*)?", data.decode("utf-8"))

            for sha1, ref_name in matches:
                # Remove any trailing data or capabilities
                clean_ref_name = ref_name.split("\x00")[0]
                references[clean_ref_name.strip()] = sha1.strip()

            for reference, sha in references.items():
                logger.info(f"{sha}\t{reference}")
            return references
    except urllib.error.HTTPError as e:
        logger.error(f"HTTP error: {e.code} - {e.reason}")
        logger.error("Please make sure the URL is correct and the repository is public.")
        return None
    except urllib.error.URLError as e:
        logger.error(f"URL error: {e.reason}")
        logger.error("Connection or server issue.")
        return None
    except Exception as e:
        logger.error(f"An unexpected error occurred: {e}")
        return None


def read_git_config(repo_path: Path) -> Optional[ConfigParser]:
    """
    Reads the Git configuration file and returns a ConfigParser object.

    Args:
        repo_path (Path): Path to the repository root directory.

    Returns:
        ConfigParser: Configuration object, or None if file doesn't exist.
    """
    config = ConfigParser()
    config_path = repo_path / ".git" / "config"

    if not config_path.is_file():
        return None

    config.read(config_path)
    return config


def get_credentials() -> Tuple[Optional[str], Optional[str]]:
    """
    Prompts user for authentication credentials securely.

    Returns:
        tuple: (username, password) or (None, None) on error.
    """
    try:
        username = input("Username: ")
        # getpass.getpass() hides the input as the user types
        password = getpass.getpass("Password: ")
        return username, password
    except Exception as e:
        logger.error(f"Error retrieving credentials: {e}")
        return None, None


def get_current_branch(repo_path: Path) -> Optional[str]:
    """
    Determines the current branch from the HEAD file.

    Args:
        repo_path (Path): Path to the repository root directory.

    Returns:
        str: Current branch name, 'detached HEAD', or None on error.
    """
    head_path = repo_path / ".git" / "HEAD"

    if not head_path.is_file():
        # Handle the error if the HEAD file does not exist
        return None

    with open(head_path, "r") as f:
        content = f.read().strip()

    if content.startswith("ref: "):
        # Extract the branch name from the path
        return content.split("/")[-1]

    # Handle the case where HEAD points directly to a commit (detached HEAD)
    return "detached HEAD"


def push(repo_url: Optional[str] = None, branch_name: Optional[str] = None, repo_path: Optional[Path] = None) -> None:
    """
    Pushes local commits to a remote repository using Smart HTTP protocol.

    Args:
        repo_url (str, optional): URL of the remote repository.
        branch_name (str, optional): Name of the branch to push.
        repo_path (Path, optional): Path to the repository root directory.
    """
    logger.info(f"Pushing to remote repository at {repo_url}...")
    git_config = read_git_config(repo_path or Path("."))

    repo_url = git_config['remote "origin"']["url"] if repo_url is None and git_config else repo_url
    branch_name = get_current_branch() if branch_name is None else branch_name

    auth_user, auth_password = get_credentials()
    password_manager = urllib.request.HTTPPasswordMgrWithDefaultRealm()
    password_manager.add_password(None, repo_url, auth_user, auth_password)
    auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager)
    opener = urllib.request.build_opener(auth_handler)
    urllib.request.install_opener(opener)

    # 1. Get the latest local commit hash for the branch
    branch_path = Path(".git") / "refs" / "heads" / branch_name
    if not branch_path.is_file():
        logger.error(f"Error: Local branch '{branch_name}' not found. Please commit first.")
        return

    with open(branch_path, "r") as f:
        local_commit_hash = f.read().strip()

    # 2. Discover remote refs
    try:
        remote_refs = ls_remote(repo_url or "")
        remote_commit_hash = remote_refs["HEAD"] if remote_refs else ""
    except urllib.error.URLError as e:
        logger.error(f"Error fetching remote refs: {e.reason}. Check the repository URL.")
        return
    except Exception as e:
        logger.error(f"An unexpected error occurred during remote ref discovery: {e}")
        return

    logger.info(f"Local branch '{branch_name}' points to: {local_commit_hash}")
    logger.info(f"Remote branch '{branch_name}' points to: {remote_commit_hash}")

    if local_commit_hash == remote_commit_hash:
        logger.info("Everything up-to-date.")
        return

    objects_to_send = find_objects_to_send(local_commit_hash, remote_commit_hash, repo_path or Path("."))

    if not objects_to_send:
        logger.info("No new objects to send. Pushing is not necessary.")
        return

    # 4. Create the packfile
    logger.info("Packing objects...")
    packfile_data = pack_objects(objects_to_send, repo_path or Path("."))
    logger.info(f"Created a packfile of size: {len(packfile_data)} bytes.")

    # 5. Create the push request payload
    old_hash = remote_commit_hash if remote_commit_hash else "0" * 40
    new_hash = local_commit_hash

    payload_line = f"{old_hash} {new_hash} refs/heads/{branch_name}\x00 report-status\n"
    payload_packet = f"{len(payload_line) + 4:04x}{payload_line}"

    full_payload = payload_packet.encode("utf-8") + b"0000" + packfile_data

    # 6. Send the push request
    logger.info("Sending packfile to remote...")
    try:
        req = urllib.request.Request(
            f"{repo_url}/git-receive-pack",
            data=full_payload,
            method="POST",
            headers={"Content-Type": "application/x-git-receive-pack-request"},
        )
        logger.info(f"Sending POST request to {repo_url}/git-receive-pack")
        with opener.open(req) as response:
            logger.info("Push is done! Server response below:")
            response_data = response.read()
            # Decode the server's response to a readable string for better debugging.
            try:
                decoded_response = response_data.decode("utf-8")
                logger.info(decoded_response)
            except UnicodeDecodeError:
                logger.info("Received a non-UTF-8 response from the server.")
                logger.info(response_data)

    except urllib.error.URLError as e:
        logger.error(f"Error pushing to remote: {e.reason}")
    except Exception as e:
        logger.error(f"An unexpected error occurred during push: {e}")


def find_objects_to_send(local_hash: str, remote_hash: str, repo_path: Path) -> List[str]:
    """
    Finds Git objects that need to be sent to the remote repository.

    Args:
        local_hash (str): SHA-1 hash of the local commit.
        remote_hash (str): SHA-1 hash of the remote commit.
        repo_path (Path): Path to the repository root directory.

    Returns:
        list: List of object hashes to send.
    """
    objects_to_send = set()
    queue = [local_hash]

    while queue:
        current_hash = queue.pop(0)

        if current_hash in objects_to_send or current_hash == remote_hash:
            continue

        objects_to_send.add(current_hash)

        content, object_type, object_size = read_git_object(current_hash, repo_path)

        # Add a check for None values to handle corrupted objects
        if object_type is None or content is None:
            logger.warning(f"Skipping corrupted or missing object: {current_hash}")
            continue

        if object_type == "commit":
            # Add parents and the tree to the queue
            commit_content_str = content.decode("utf-8")
            tree_match = re.search(r"tree ([0-9a-f]{40})", commit_content_str)
            tree_hash = tree_match.group(1) if tree_match else ""
            objects_to_send.add(tree_hash)

            parents = re.findall(r"parent ([0-9a-f]{40})", commit_content_str)
            for parent_hash in parents:
                queue.append(parent_hash)

        elif object_type == "tree":
            # Add all objects in the tree to the queue
            offset = 0
            while offset < len(content):
                name_end = content.find(b"\x00", offset)
                object_hash = content[name_end + 1 : name_end + 21].hex()
                queue.append(object_hash)
                offset = name_end + 21

    return list(objects_to_send)


def pack_objects(commits_to_push: List[str], repo_path: Path) -> bytes:
    """
    Creates a Git packfile from a list of objects.

    Args:
        commits_to_push (list): List of commit hashes to pack.
        repo_path (Path): Path to the repository root directory.

    Returns:
        bytes: Binary packfile data.
    """
    packfile_objects = {}
    obj_type_map = {b"commit": 1, b"tree": 2, b"blob": 3, b"tag": 4}

    def add_object_and_children(obj_hash: str) -> None:
        if obj_hash in packfile_objects:
            return

        content, obj_type, _ = read_git_object(obj_hash, repo_path)
        if obj_type is None:
            return

        packfile_objects[obj_hash] = {"type": obj_type, "content": content}

        if obj_type == b"commit":
            lines = content.split(b"\n")
            tree_hash = lines[0].split(b" ")[1].decode()
            add_object_and_children(tree_hash)

            for line in lines[1:]:
                if line.startswith(b"parent"):
                    parent_hash = line.split(b" ")[1].decode()
                    add_object_and_children(parent_hash)
        elif obj_type == b"tree":
            pos = 0
            while pos < len(content):
                name_end = content.find(b"\x00", content.find(b" ", pos) + 1)
                hash_start = name_end + 1
                obj_sha1 = content[hash_start : hash_start + 20].hex()
                add_object_and_children(obj_sha1)
                pos = hash_start + 20

    for commit_hash in commits_to_push:
        add_object_and_children(commit_hash)

    # Sort objects for consistent packfile creation
    sorted_objects = sorted(packfile_objects.keys())

    pack_header = b"PACK" + struct.pack("!LL", 2, len(sorted_objects))
    pack_content = b""

    for obj_hash in sorted_objects:
        obj = packfile_objects[obj_hash]
        obj_type = obj["type"]
        content = obj["content"]

        type_num = obj_type_map[obj_type]
        size = len(content)

        # Correctly encode the type and size using a variable-length integer format
        header_bytes = b""
        # First byte
        first_byte = (type_num << 4) | (size & 0x0F)
        size >>= 4
        if size > 0:
            first_byte |= 0x80
        header_bytes += struct.pack("B", first_byte)

        # Subsequent bytes
        while size > 0:
            next_byte = size & 0x7F
            size >>= 7
            if size > 0:
                next_byte |= 0x80
            header_bytes += struct.pack("B", next_byte)

        pack_content += header_bytes + zlib.compress(content)

    pack_checksum = hashlib.sha1(pack_header + pack_content).digest()

    return pack_header + pack_content + pack_checksum


def git_status(repo_path: Path) -> None:
    """
    Displays the status of the working directory and staging area.

    Args:
        repo_path (Path): Path to the repository root directory.
    """
    logger.info("On branch master")

    # Read the index file to get staged files
    try:
        index_entries = read_index(repo_path / ".git" / "index")
    except (ValueError, FileNotFoundError):
        index_entries = []

    staged_files = {entry["path"]: entry["sha1"] for entry in index_entries}

    # Get the list of all files in the working directory (excluding .git)
    working_tree_files = set()
    for root, dirs, files in os.walk(repo_path):
        if ".git" in dirs:
            dirs.remove(".git")
        for file in files:
            file_path = Path(root) / file
            relative_path = file_path.relative_to(repo_path)
            working_tree_files.add(str(relative_path))

    # Compare staged files with working tree files
    staged_only = set(staged_files.keys()) - working_tree_files
    unstaged_changes = {}
    untracked_files = working_tree_files - set(staged_files.keys())

    # Check for unstaged changes (modified files)
    for path, sha1 in staged_files.items():
        full_path = repo_path / path
        if full_path.is_file():
            current_sha1, _, _ = hash_object(full_path, repo_path)
            if current_sha1 != sha1:
                unstaged_changes[path] = "modified"
        else:
            unstaged_changes[path] = "deleted"

    # Print the status output
    if unstaged_changes:
        logger.info("\nChanges not staged for commit:")
        logger.info('  (use "git add <file>..." to update what will be committed)')
        logger.info('  (use "git restore <file>..." to discard changes in working directory)')
        logger.info("")
        for path, status in unstaged_changes.items():
            if status == "modified":
                logger.info(f"\tmodified:   {path}")
            elif status == "deleted":
                logger.info(f"\tdeleted:    {path}")

    if untracked_files:
        logger.info("Untracked files:")
        logger.info('  (use "git add <file>..." to include in what will be committed)')
        logger.info("")
        for path in sorted(list(untracked_files)):
            logger.info(f"\t{path}")

    if not unstaged_changes and not untracked_files:
        logger.info("Nothing to commit, working tree clean")


def find_repo_root() -> Optional[Path]:
    """
    Locates the root directory of a Git repository by searching for .git.

    Returns:
        Path: Path to the repository root, or None if not found.
    """
    current_path = Path(".")
    while current_path != current_path.parent:
        if (current_path / ".git").is_dir():
            return current_path
        current_path = current_path.parent

    # Check if the current directory is the root
    if (current_path / ".git").is_dir():
        return current_path

    return None


def main() -> None:
    """
    Main entry point for the Git CLI application.
    Parses command line arguments and dispatches to appropriate functions.
    """
    parser = argparse.ArgumentParser(description="A Git CLI clone written in Python.")
    subparsers = parser.add_subparsers(dest="command", required=True)

    init_parser = subparsers.add_parser("init", help="Creates a new empty Git repository.")

    cat_file_parser = subparsers.add_parser(
        "cat-file", help="Provide content or type information for repository objects."
    )
    cat_file_parser.add_argument("-p", action="store_true", help="Pretty-print the contents of <object>.")
    cat_file_parser.add_argument("object_hash", help="The hash of the Git object.")

    hash_object_parser = subparsers.add_parser(
        "hash-object", help="Compute object ID and optionally create a blob from a file."
    )
    hash_object_parser.add_argument(
        "-w", action="store_true", help="Actually write the object into the object database."
    )
    hash_object_parser.add_argument("file_path", help="The path to the file to hash.")

    ls_tree_parser = subparsers.add_parser("ls-tree", help="List the contents of a tree object.")
    ls_tree_parser.add_argument("object_hash", help="The hash of the tree object.")
    ls_tree_parser.add_argument("-r", action="store_true", help="List contents of subtrees recursively.")
    ls_tree_parser.add_argument("--name-only", action="store_true", help="List only the names of the files.")

    add_parser = subparsers.add_parser("add", help="Add file contents to the index.")
    add_parser.add_argument(
        "files",
        nargs="*",  # Allows 0 or more arguments (files)
        help='The path(s) to the file(s) to add. Can be single file, a list of files, or "." for all files.',
    )

    ls_files_parser = subparsers.add_parser("ls-files", help="Show information about files in the index.")

    write_tree_parser = subparsers.add_parser("write-tree", help="Create a tree object from the current index.")

    commit_parser = subparsers.add_parser("commit", help="Record changes to the repository.")
    commit_parser.add_argument("-m", "--message", required=True, help="The commit message.")

    commit_tree_parser = subparsers.add_parser("commit-tree", help="Create a new commit object.")
    commit_tree_parser.add_argument("tree_hash", help="The hash of the tree object.")
    commit_tree_parser.add_argument("-p", "--parent_hash", help="The hash of the parent commit.")
    commit_tree_parser.add_argument("-m", "--message", required=True, help="The commit message.")

    clone_parser = subparsers.add_parser(
        "ls-remote", help="Fetching references (branches and tags) from the provided repository URL."
    )
    clone_parser.add_argument("repo_url", help="The URL of the repository to clone.")

    clone_parser = subparsers.add_parser("clone", help="Clone a repository into a new directory.")
    clone_parser.add_argument("repo_url", help="The URL of the repository to clone.")
    clone_parser.add_argument("directory", nargs="?", help="The name of the new directory to clone into.")

    push_parser = subparsers.add_parser("push", help="Push local changes to a remote repository.")
    push_parser.add_argument("--repo-url", help="The URL of the remote repository.")
    push_parser.add_argument("--branch", default="master", help="The name of the branch to push.")

    status_parser = subparsers.add_parser("status", help="Show the working tree status.")

    args = parser.parse_args()
    repo_path = find_repo_root() or Path(".")
    if args.command == "init":
        initialize_git_repository()
    elif args.command == "cat-file":
        if not args.p or not args.object_hash:
            cat_file_parser.error("The 'cat-file' command requires both '-p' and an object hash.")
        cat_file("p", args.object_hash, repo_path)
    elif args.command == "hash-object":
        file_path = Path(args.file_path)
        if not file_path.is_file():
            hash_object_parser.error(f"Error: File '{file_path}' not found.")

        sha1, _, _ = hash_object(file_path, repo_path, write_flag=args.w)
        if sha1:
            logger.info(sha1)
    elif args.command == "ls-tree":
        if not args.object_hash:
            ls_tree_parser.error("The 'ls-tree' command requires an object hash.")
        ls_tree(args, repo_path)
    elif args.command == "add":
        for file_ in process_files(args.files):
            add(file_, repo_path)
    elif args.command == "ls-files":
        ls_files(repo_path)
    elif args.command == "write-tree":
        paths_to_process = [f for f in Path(".").glob("**/*") if f.is_file() and ".git" not in str(f)]
        for file_ in paths_to_process:
            add(file_, repo_path)
        write_tree_command(repo_path)
    elif args.command == "commit":
        commit(args, repo_path)
    elif args.command == "commit-tree":
        commit_tree(args.tree_hash, args.parent_hash, args.message, repo_path)
    elif args.command == "ls-remote":
        ls_remote(args.repo_url)
    elif args.command == "clone":
        clone(args.repo_url, args.directory)
    elif args.command == "push":
        push(args.repo_url, args.branch, repo_path)
    elif args.command == "status":
        git_status(repo_path)


if __name__ == "__main__":
    main()