feat: create git repository explorer app with diff, tree, and README viewing capabilities

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

app.py

@@ -0,0 +1,187 @@
+import gradio as gr
+import sys
+from git_diff_utils import get_latest_commit_diff
+from git_tree_utils import get_repo_tree_structure, print_tree
+from git_readme_utils import get_repo_readme
+
+def get_diff(repo_source, commit_depth=1):
+    """
+    Get the diff of a specific commit from a git repository.
+    
+    Args:
+        repo_source (str): Path to local repository or URL to remote repository
+        commit_depth (int, optional): How many commits back to check (default=1 for latest commit)
+    
+    Returns:
+        str: The git diff output formatted as text
+    """
+    try:
+        commit_depth = int(commit_depth)
+        if commit_depth < 1:
+            return "Error: commit_depth must be a positive integer"
+    except ValueError:
+        return "Error: commit_depth must be an integer"
+    
+    print(f"Getting diff for repository: {repo_source} (commit depth: {commit_depth})")
+    diff = get_latest_commit_diff(repo_source, commit_depth)
+    return diff
+
+def get_tree(repo_source, commit_depth=1):
+    """
+    Get the tree structure of a git repository at a specific commit.
+    
+    Args:
+        repo_source (str): Path to local repository or URL to remote repository
+        commit_depth (int, optional): How many commits back to check (default=1 for latest commit)
+    
+    Returns:
+        str: The formatted tree structure as text
+    """
+    try:
+        commit_depth = int(commit_depth)
+        if commit_depth < 1:
+            return "Error: commit_depth must be a positive integer"
+    except ValueError:
+        return "Error: commit_depth must be an integer"
+    
+    print(f"Getting tree structure for repository: {repo_source} (commit depth: {commit_depth})")
+    tree = get_repo_tree_structure(repo_source, commit_depth)
+    
+    if isinstance(tree, dict):
+        # Capture the output of print_tree to a string
+        import io
+        from contextlib import redirect_stdout
+        
+        f = io.StringIO()
+        with redirect_stdout(f):
+            print("Repository Structure:")
+            print_tree(tree)
+        output = f.getvalue()
+        return output
+    else:
+        return tree  # Error message
+
+def get_readme(repo_source, commit_depth=1):
+    """
+    Get the README content from a git repository at a specific commit.
+    
+    Args:
+        repo_source (str): Path to local repository or URL to remote repository
+        commit_depth (int, optional): How many commits back to check (default=1 for latest commit)
+    
+    Returns:
+        str: The content of the README file or an error message
+    """
+    try:
+        commit_depth = int(commit_depth)
+        if commit_depth < 1:
+            return "Error: commit_depth must be a positive integer"
+    except ValueError:
+        return "Error: commit_depth must be an integer"
+    
+    print(f"Getting README for repository: {repo_source} (commit depth: {commit_depth})")
+    result = get_repo_readme(repo_source, commit_depth)
+    
+    if isinstance(result, tuple):
+        readme_file, readme_content = result
+        return f"README File: {readme_file}\n\n{readme_content}"
+    else:
+        return result  # Error message
+
+# Create the Gradio interface
+with gr.Blocks(title="Git Repository Explorer") as demo:
+    gr.Markdown("# Git Repository Explorer")
+    
+    # Feature selection
+    feature = gr.Radio(
+        choices=["View Commit Diff", "View Repository Structure", "View README"],
+        value="View Commit Diff",
+        label="Select Feature"
+    )
+    
+    # Common inputs for all features
+    with gr.Row():
+        with gr.Column():
+            repo_input = gr.Textbox(
+                label="Repository Path or URL",
+                placeholder="Enter local path or remote URL (e.g., https://github.com/username/repo.git)",
+                lines=1
+            )
+            
+            depth_input = gr.Number(
+                label="Commit Depth",
+                value=1,
+                minimum=1,
+                step=1,
+                info="How many commits back to check (1 = latest commit)"
+            )
+            
+            submit_btn = gr.Button("Execute", variant="primary")
+        
+    # Output area
+    output = gr.TextArea(
+        label="Output",
+        lines=20,
+        max_lines=50,
+        show_copy_button=True
+    )
+    
+    # Function to handle feature selection and execution
+    def process_request(feature_selection, repo_source, commit_depth):
+        if feature_selection == "View Commit Diff":
+            return get_diff(repo_source, commit_depth)
+        elif feature_selection == "View Repository Structure":
+            return get_tree(repo_source, commit_depth)
+        elif feature_selection == "View README":
+            return get_readme(repo_source, commit_depth)
+        return "Please select a feature"
+    
+    # Update button text based on feature selection
+    def update_button_text(feature_selection):
+        if feature_selection == "View Commit Diff":
+            return "Get Diff"
+        elif feature_selection == "View Repository Structure":
+            return "Get Tree Structure"
+        elif feature_selection == "View README":
+            return "Get README"
+        return "Execute"
+        
+    # Update output label based on feature selection
+    def update_output_label(feature_selection):
+        if feature_selection == "View Commit Diff":
+            return "Diff Output"
+        elif feature_selection == "View Repository Structure":
+            return "Repository Structure"
+        elif feature_selection == "View README":
+            return "README Content"
+        return "Output"
+    
+    # Set up events
+    feature.change(fn=update_button_text, inputs=feature, outputs=submit_btn)
+    feature.change(fn=update_output_label, inputs=feature, outputs=output)
+    
+    submit_btn.click(
+        fn=process_request,
+        inputs=[feature, repo_input, depth_input],
+        outputs=output
+    )
+    
+    gr.Markdown("""
+    ### Instructions:
+    1. Select the feature you want to use
+    2. Enter a git repository path or URL
+    3. Specify how many commits back to check (default: 1 for the latest commit)
+    4. Click the execute button
+    
+    This tool can handle both local repositories and remote URLs automatically.
+    
+    #### Features:
+    - **View Commit Diff**: Shows the differences made in a specific commit
+    - **View Repository Structure**: Displays the tree structure of the repository at a specific commit
+    - **View README**: Shows the content of the README file if present in the repository
+    """)
+
+# Launch the app with MCP server enabled
+if __name__ == "__main__":
+    #demo.launch(share=True, mcp_server=True)
+    demo.launch(share=False, server_name="0.0.0.0", server_port=7860, mcp_server=True)

git_diff_utils.py

@@ -0,0 +1,101 @@
+import subprocess
+import tempfile
+import shutil
+import os
+from typing import Optional, Union, Dict, List
+
+
+def get_latest_commit_diff(repo_source: str, commit_depth: int = 1) -> Union[str, Dict[str, List[str]]]:
+    """
+    Returns the differences made in a specified commit of a git repository.
+    
+    Args:
+        repo_source: Path to the git repository or URL to a remote repository.
+                     Function automatically detects if it's a local path or remote URL.
+        commit_depth: How many commits back to check (default=1 for the latest commit).
+                      For example, 2 would return the diff for the second-to-last commit.
+        
+    Returns:
+        A string containing the git diff output or a dictionary with structured diff information
+    """
+    temp_dir = None
+    try:
+        # Determine if repo_source is a remote URL or local path
+        is_remote = repo_source.startswith(('http://', 'https://', 'git://', 'ssh://')) or repo_source.endswith('.git')
+        
+        # If it's a remote repository, clone it to a temporary directory
+        if is_remote:
+            temp_dir = tempfile.mkdtemp()
+            print(f"Cloning remote repository: {repo_source}")
+            clone_cmd = ["git", "clone", repo_source, temp_dir]
+            subprocess.check_output(clone_cmd)
+            repo_path = temp_dir
+        else:
+            repo_path = repo_source
+            
+        # Validate commit_depth parameter
+        if commit_depth < 1:
+            return "Error: commit_depth must be a positive integer"
+            
+        # Get the commit hash for the specified depth
+        if commit_depth == 1:
+            # For the latest commit
+            commit_ref = "HEAD"
+        else:
+            # For earlier commits: HEAD~1, HEAD~2, etc. (0-indexed in git, so we subtract 1)
+            commit_ref = f"HEAD~{commit_depth-1}"
+            
+        # Get the commit hash
+        commit_cmd = ["git", "-C", repo_path, "rev-parse", commit_ref]
+        try:
+            commit_hash = subprocess.check_output(commit_cmd).decode('utf-8').strip()
+        except subprocess.CalledProcessError:
+            return f"Error: Could not find commit at depth {commit_depth}"
+        
+        # Get the diff from the commit
+        diff_cmd = ["git", "-C", repo_path, "show", "--name-status", commit_hash]
+        diff_output = subprocess.check_output(diff_cmd).decode('utf-8')
+        
+        # For more detailed content diff including the changes
+        content_diff_cmd = ["git", "-C", repo_path, "show", commit_hash]
+        content_diff = subprocess.check_output(content_diff_cmd).decode('utf-8')
+        
+        return content_diff
+        
+    except subprocess.CalledProcessError as e:
+        return f"Error executing git command: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+    finally:
+        # Clean up temporary directory if it was created
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+
+# Example usage
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Usage: python main.py <repo_path_or_url> [commit_depth]")
+        print("  repo_path_or_url: Path to local repository or URL to remote repository")
+        print("  commit_depth: Optional - How many commits back to check (default=1 for latest commit)")
+        sys.exit(1)
+        
+    repo_source = sys.argv[1]
+    commit_depth = 1  # Default to latest commit
+    
+    # Check if commit_depth was provided
+    if len(sys.argv) > 2:
+        try:
+            commit_depth = int(sys.argv[2])
+            if commit_depth < 1:
+                print("Error: commit_depth must be a positive integer")
+                sys.exit(1)
+        except ValueError:
+            print("Error: commit_depth must be an integer")
+            sys.exit(1)
+    
+    print(f"Getting diff for repository: {repo_source} (commit depth: {commit_depth})")
+    diff = get_latest_commit_diff(repo_source, commit_depth)
+    print(diff)

git_readme_utils.py

@@ -0,0 +1,141 @@
+import subprocess
+import tempfile
+import shutil
+import os
+from typing import Optional, Union, Dict, List, Tuple
+
+
+def get_repo_readme(repo_source: str, commit_depth: int = 1) -> Union[Tuple[str, str], str]:
+    """
+    Returns the README content of a git repository at a specific commit.
+    
+    Args:
+        repo_source: Path to the git repository or URL to a remote repository.
+                     Function automatically detects if it's a local path or remote URL.
+        commit_depth: How many commits back to check (default=1 for the latest commit).
+                      For example, 2 would return the README from the second-to-last commit.
+        
+    Returns:
+        A tuple containing (readme_filename, readme_content) if README is found,
+        or an error string if something fails or no README is found
+    """
+    temp_dir = None
+    try:
+        # Determine if repo_source is a remote URL or local path
+        is_remote = repo_source.startswith(('http://', 'https://', 'git://', 'ssh://')) or repo_source.endswith('.git')
+        
+        # If it's a remote repository, clone it to a temporary directory
+        if is_remote:
+            temp_dir = tempfile.mkdtemp()
+            print(f"Cloning remote repository: {repo_source}")
+            clone_cmd = ["git", "clone", repo_source, temp_dir]
+            subprocess.check_output(clone_cmd)
+            repo_path = temp_dir
+        else:
+            repo_path = repo_source
+            
+        # Validate commit_depth parameter
+        if commit_depth < 1:
+            return "Error: commit_depth must be a positive integer"
+            
+        # Get the commit hash for the specified depth
+        if commit_depth == 1:
+            # For the latest commit
+            commit_ref = "HEAD"
+        else:
+            # For earlier commits: HEAD~1, HEAD~2, etc. (0-indexed in git, so we subtract 1)
+            commit_ref = f"HEAD~{commit_depth-1}"
+            
+        # Get the commit hash
+        commit_cmd = ["git", "-C", repo_path, "rev-parse", commit_ref]
+        try:
+            commit_hash = subprocess.check_output(commit_cmd).decode('utf-8').strip()
+        except subprocess.CalledProcessError:
+            return f"Error: Could not find commit at depth {commit_depth}"
+        
+        # Common README file patterns to check
+        readme_patterns = [
+            "README.md",
+            "README.txt",
+            "README",
+            "readme.md",
+            "Readme.md",
+            "ReadMe.md",
+            "readme.txt",
+            "README.markdown",
+            "readme.markdown"
+        ]
+        
+        # Check for the existence of README files
+        ls_files_cmd = ["git", "-C", repo_path, "ls-tree", "--name-only", commit_hash]
+        files = subprocess.check_output(ls_files_cmd).decode('utf-8').strip().split('\n')
+        
+        readme_file = None
+        for pattern in readme_patterns:
+            if pattern in files:
+                readme_file = pattern
+                break
+        
+        # Also check in the root directory
+        if not readme_file:
+            for pattern in readme_patterns:
+                if any(f == pattern or f.endswith(f"/{pattern}") for f in files):
+                    readme_file = next((f for f in files if f == pattern or f.endswith(f"/{pattern}")), None)
+                    break
+        
+        if not readme_file:
+            return "No README file found in the repository"
+        
+        # Get the content of the README file at the specified commit
+        show_cmd = ["git", "-C", repo_path, "show", f"{commit_hash}:{readme_file}"]
+        try:
+            readme_content = subprocess.check_output(show_cmd).decode('utf-8')
+            return (readme_file, readme_content)
+        except subprocess.CalledProcessError:
+            return f"Error: Could not read {readme_file} at commit {commit_hash}"
+        
+    except subprocess.CalledProcessError as e:
+        return f"Error executing git command: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+    finally:
+        # Clean up temporary directory if it was created
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+
+# Example usage
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Usage: python git_readme_utils.py <repo_path_or_url> [commit_depth]")
+        print("  repo_path_or_url: Path to local repository or URL to remote repository")
+        print("  commit_depth: Optional - How many commits back to check (default=1 for latest commit)")
+        sys.exit(1)
+        
+    repo_source = sys.argv[1]
+    commit_depth = 1  # Default to latest commit
+    
+    # Check if commit_depth was provided
+    if len(sys.argv) > 2:
+        try:
+            commit_depth = int(sys.argv[2])
+            if commit_depth < 1:
+                print("Error: commit_depth must be a positive integer")
+                sys.exit(1)
+        except ValueError:
+            print("Error: commit_depth must be an integer")
+            sys.exit(1)
+    
+    print(f"Getting README for repository: {repo_source} (commit depth: {commit_depth})")
+    result = get_repo_readme(repo_source, commit_depth)
+    
+    if isinstance(result, tuple):
+        readme_file, readme_content = result
+        print(f"\nFound README file: {readme_file}\n")
+        print("=" * 80)
+        print(readme_content)
+        print("=" * 80)
+    else:
+        print(result)  # Error message

git_tree_utils.py

@@ -0,0 +1,137 @@
+import subprocess
+import tempfile
+import shutil
+import os
+from typing import Optional, Union, Dict, List, Any
+
+
+def get_repo_tree_structure(repo_source: str, commit_depth: int = 1) -> Union[Dict[str, Any], str]:
+    """
+    Returns the tree structure of a git repository at a specific commit.
+    
+    Args:
+        repo_source: Path to the git repository or URL to a remote repository.
+                     Function automatically detects if it's a local path or remote URL.
+        commit_depth: How many commits back to check (default=1 for the latest commit).
+                      For example, 2 would return the tree for the second-to-last commit.
+        
+    Returns:
+        A dictionary representing the repository structure tree or error string if something fails
+    """
+    temp_dir = None
+    try:
+        # Determine if repo_source is a remote URL or local path
+        is_remote = repo_source.startswith(('http://', 'https://', 'git://', 'ssh://')) or repo_source.endswith('.git')
+        
+        # If it's a remote repository, clone it to a temporary directory
+        if is_remote:
+            temp_dir = tempfile.mkdtemp()
+            print(f"Cloning remote repository: {repo_source}")
+            clone_cmd = ["git", "clone", repo_source, temp_dir]
+            subprocess.check_output(clone_cmd)
+            repo_path = temp_dir
+        else:
+            repo_path = repo_source
+            
+        # Validate commit_depth parameter
+        if commit_depth < 1:
+            return "Error: commit_depth must be a positive integer"
+            
+        # Get the commit hash for the specified depth
+        if commit_depth == 1:
+            # For the latest commit
+            commit_ref = "HEAD"
+        else:
+            # For earlier commits: HEAD~1, HEAD~2, etc. (0-indexed in git, so we subtract 1)
+            commit_ref = f"HEAD~{commit_depth-1}"
+            
+        # Get the commit hash
+        commit_cmd = ["git", "-C", repo_path, "rev-parse", commit_ref]
+        try:
+            commit_hash = subprocess.check_output(commit_cmd).decode('utf-8').strip()
+        except subprocess.CalledProcessError:
+            return f"Error: Could not find commit at depth {commit_depth}"
+        
+        # Use git ls-tree recursively to get the repository structure
+        ls_tree_cmd = ["git", "-C", repo_path, "ls-tree", "-r", "--name-only", commit_hash]
+        file_list = subprocess.check_output(ls_tree_cmd).decode('utf-8').strip().split('\n')
+        
+        # Build a tree structure from the file paths
+        root = {}
+        for file_path in file_list:
+            if not file_path:  # Skip empty paths
+                continue
+                
+            parts = file_path.split('/')
+            current = root
+            
+            # Navigate through path components, creating nested dictionaries as needed
+            for i, part in enumerate(parts):
+                if i == len(parts) - 1:  # It's a file (last part of path)
+                    current[part] = None  # Files have None value
+                else:  # It's a directory
+                    if part not in current:
+                        current[part] = {}  # Create directory dict if it doesn't exist
+                    current = current[part]  # Move into the directory
+        
+        return root
+        
+    except subprocess.CalledProcessError as e:
+        return f"Error executing git command: {str(e)}"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+    finally:
+        # Clean up temporary directory if it was created
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+
+# Helper function to print the tree structure in a more readable format
+def print_tree(tree, indent=""):
+    """
+    Print the repository tree structure in a readable format
+    
+    Args:
+        tree: Dictionary representing the repository structure
+        indent: Current indentation level string (used in recursion)
+    """
+    for key, value in sorted(tree.items()):
+        if value is None:  # It's a file
+            print(f"{indent}├── {key}")
+        else:  # It's a directory
+            print(f"{indent}├── {key}/")
+            print_tree(value, indent + "│   ")
+
+
+# Example usage
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Usage: python git_tree_utils.py <repo_path_or_url> [commit_depth]")
+        print("  repo_path_or_url: Path to local repository or URL to remote repository")
+        print("  commit_depth: Optional - How many commits back to check (default=1 for latest commit)")
+        sys.exit(1)
+        
+    repo_source = sys.argv[1]
+    commit_depth = 1  # Default to latest commit
+    
+    # Check if commit_depth was provided
+    if len(sys.argv) > 2:
+        try:
+            commit_depth = int(sys.argv[2])
+            if commit_depth < 1:
+                print("Error: commit_depth must be a positive integer")
+                sys.exit(1)
+        except ValueError:
+            print("Error: commit_depth must be an integer")
+            sys.exit(1)
+    
+    print(f"Getting repository structure for: {repo_source} (commit depth: {commit_depth})")
+    tree = get_repo_tree_structure(repo_source, commit_depth)
+    
+    if isinstance(tree, dict):
+        print("\nRepository Structure:")
+        print_tree(tree)
+    else:
+        print(tree)  # Error message

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0
+GitPython