git-lfs-advisor-cli 0.1.0__py3-none-any.whl

get_lfs_advisor_cli/cli.py

@@ -0,0 +1,162 @@
+import os
+import sys
+import configparser
+import pathlib
+
+# --- Configuration ---
+SIZE_LIMIT_MB = 25
+# A set of common binary file extensions. Add more as needed for your project.
+BINARY_EXTENSIONS = {
+    # Images
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg',
+    # Documents
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    # Archives
+    '.zip', '.rar', '.7z', '.gz', '.tar',
+    # Compiled code and libraries
+    '.exe', '.dll', '.so', '.a', '.lib',
+    # Media
+    '.mp3', '.wav', '.ogg', '.mp4', '.mov', '.avi',
+    # Databases
+    '.db', '.sqlite', '.sqlite3',
+    # Other
+    '.jar', '.bin', '.dat',
+}
+# --- End Configuration ---
+
+
+SIZE_LIMIT_BYTES = SIZE_LIMIT_MB * 1024 * 1024
+
+
+def is_binary_file(filepath, chunk_size=1024):
+    """
+    Heuristically determines if a file is binary by checking for null bytes
+    in the first chunk of the file.
+    """
+    try:
+        with open(filepath, 'rb') as f:
+            return b'\0' in f.read(chunk_size)
+    except IOError:
+        return False  # Could not read, assume not binary for safety.
+
+
+def get_submodule_paths():
+    """Parses .gitmodules and returns a set of submodule paths."""
+    submodules = set()
+    gitmodules_path = '.gitmodules'
+    if not os.path.exists(gitmodules_path):
+        return submodules
+
+    print("Found .gitmodules, parsing for submodule paths...")
+    config = configparser.ConfigParser()
+    try:
+        config.read(gitmodules_path)
+        for section in config.sections():
+            if config.has_option(section, 'path'):
+                path_str = config.get(section, 'path')
+                # Normalize path for the current OS (e.g., using '\' on Windows)
+                normalized_path = str(pathlib.Path(path_str))
+                submodules.add(normalized_path)
+    except configparser.Error as e:
+        print(f"Warning: Could not parse .gitmodules file: {e}", file=sys.stderr)
+
+    if submodules:
+        print("The following submodule paths will be ignored:")
+        for path in sorted(list(submodules)):
+            print(f"  - {path}")
+    return submodules
+
+
+def scan_repo_files(submodule_paths):
+    """Walks the repo, yielding file paths to be analyzed."""
+    for root, dirs, files in os.walk('.', topdown=True):
+        if '.git' in dirs:
+            dirs.remove('.git')
+
+        for d in dirs[:]:
+            dir_path = str(pathlib.Path(root) / d)
+            if dir_path in submodule_paths:
+                print(f"Ignoring submodule directory: '{dir_path}'")
+                dirs.remove(d)
+
+        for filename in files:
+            yield os.path.join(root, filename)
+
+
+def analyze_file(file_path):
+    """Analyzes a single file and returns an LFS pattern if it matches criteria."""
+    try:
+        normalized_path = str(pathlib.Path(file_path).as_posix())
+        file_size = os.path.getsize(file_path)
+        is_large = file_size > SIZE_LIMIT_BYTES
+        is_bin = False
+
+        if not is_large:
+            _, ext = os.path.splitext(file_path)
+            if ext.lower() in BINARY_EXTENSIONS:
+                is_bin = True
+            else:
+                is_bin = is_binary_file(file_path)
+
+        if is_large or is_bin:
+            if is_large:
+                size_in_mb = file_size / (1024 * 1024)
+                print(f"Found large file: '{normalized_path}' (Size: {size_in_mb:.2f}MB)")
+            else:
+                print(f"Found binary file: '{normalized_path}' (Reason: Binary content)")
+
+            if '.' in os.path.basename(file_path):
+                _, ext = os.path.splitext(file_path)
+                return f"*{ext.lower()}"
+            else:
+                return normalized_path
+
+    except FileNotFoundError:
+        print(f"Warning: Could not access '{file_path}'. Skipping.", file=sys.stderr)
+
+    return None
+
+
+def print_lfs_suggestions(lfs_patterns):
+    """Prints the suggested LFS commands based on found patterns."""
+    if not lfs_patterns:
+        print(f"No files found exceeding {SIZE_LIMIT_MB}MB or detected as binary.")
+        return
+
+    print("\n--- Suggested git lfs track commands (for .gitattributes) ---")
+    print("# Run these commands to update your .gitattributes file.")
+    sorted_patterns = sorted(list(lfs_patterns))
+    for pattern in sorted_patterns:
+        print(f'git lfs track "{pattern}"')
+
+    print("\n--- Suggested git lfs migrate command (for rewriting history) ---")
+    include_arg = ",".join(sorted_patterns)
+    print("\n# WARNING: The following commands rewrite the history of your repository.")
+    print("# It is STRONGLY RECOMMENDED to run this on a fresh clone or to backup your repository first.")
+    print("\n# --- Option 1: Migrate ONLY the CURRENT branch (most common) ---")
+    print(f'git lfs migrate import --include="{include_arg}"')
+    print("\n# --- Option 2: Migrate a SPECIFIC branch (e.g., 'main') ---")
+    print(f'# git lfs migrate import --include="{include_arg}" main')
+    print("\n# --- Option 3: Migrate ALL local and remote branches ---")
+    print(f'# git lfs migrate import --include="{include_arg}" --everything')
+
+
+def main():
+    """Finds large or binary files and generates .gitattributes LFS rules."""
+    print(f"Scanning for files larger than {SIZE_LIMIT_MB}MB or binary files...")
+    submodule_paths = get_submodule_paths()
+    print("----------------------------------------")
+
+    lfs_patterns = set()
+    for file_path in scan_repo_files(submodule_paths):
+        pattern = analyze_file(file_path)
+        if pattern:
+            lfs_patterns.add(pattern)
+
+    print("----------------------------------------")
+    print("Scan complete.")
+    print_lfs_suggestions(lfs_patterns)
+
+
+if __name__ == "__main__":
+    main()

git_lfs_advisor_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: git-lfs-advisor-cli
+Version: 0.1.0
+Summary: A script to find large/binary files and generate Git LFS commands.
+Home-page: https://github.com/taicaile/git-lfs-advisor
+Author: taicaile
+Author-email: 
+Project-URL: Bug Tracker, https://github.com/taicaile/git-lfs-advisor/issues
+Project-URL: Source Code, https://github.com/taicaile/git-lfs-advisor
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# Git LFS Advisor
+
+A simple command-line tool to scan a Git repository, find files suitable for Git LFS, and generate the necessary configuration commands.
+
+This tool helps you quickly set up Git LFS for a new or existing project without manually checking every file.
+
+## ✨ Features
+
+- **Repository Scan**: Scans the entire Git repository to find large or binary files.
+- **Custom Rules**: Define scanning rules based on file size or file extension.
+- **Command Generation**: Automatically generates `git lfs track` and `git lfs migrate` commands for you to copy and execute.
+- **Cross-Platform**: Built with Python, it runs on Windows, macOS, and Linux.
+
+## 📋 What It Does
+
+1. **Scans** your repository for large files and binary assets
+2. **Analyzes** file patterns, sizes, and repository structure
+3. **Recommends** which files should be tracked by Git LFS
+4. **Generates** `.gitattributes` configuration automatically
+5. **Provides** migration commands and best practices
+
+## 🎯 Use Cases
+
+- Setting up LFS for new repositories
+- Optimizing existing repositories with large files
+- Migrating from regular Git to Git LFS
+- Repository cleanup and size optimization
+- CI/CD pipeline integration
+
+## 📊 Example Output
+
+```txt
+🔍 Scanning repository...
+📁 Found 1,247 files (Total: 2.3 GB)
+
+💡 LFS Recommendations:
+  • *.psd files (127 files, 890 MB) → Track with LFS
+  • *.mp4 files (23 files, 1.2 GB) → Track with LFS
+  • *.zip files (8 files, 156 MB) → Track with LFS
+
+📝 Generated .gitattributes:
+  *.psd filter=lfs diff=lfs merge=lfs -text
+  *.mp4 filter=lfs diff=lfs merge=lfs -text
+  *.zip filter=lfs diff=lfs merge=lfs -text
+
+💾 Potential space savings: ~2.1 GB in Git history
+```
+
+## 🛠️ Installation
+
+```bash
+pip install git-lfs-advisor-cli
+```
+
+## 🤝 Contributing
+
+Contributions are welcome!
+
+## ⭐ Show Your Support
+
+If this tool helps you manage your Git LFS setup, please give it a star! ⭐
+
+---
+
+**Made with ❤️ for better Git workflows**

git_lfs_advisor_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+get_lfs_advisor_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+get_lfs_advisor_cli/cli.py,sha256=rTgYaEAdQSpJN3Ooc9vFeWLsmQLYe3eP_qazOW3Vup0,5690
+git_lfs_advisor_cli-0.1.0.dist-info/METADATA,sha256=kg3s0R_wtr4R_ui9H5icpdXVGyh82uX9Ru2NGUzFCMI,2854
+git_lfs_advisor_cli-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+git_lfs_advisor_cli-0.1.0.dist-info/entry_points.txt,sha256=YZzhKVbOqvEsDD_crFXeeJpNrw3MX12p0OpZru_0jj8,65
+git_lfs_advisor_cli-0.1.0.dist-info/top_level.txt,sha256=KNa-t2YpZQLVGU0rxddnP34Jb3cWBAvttoCx0ikjClE,20
+git_lfs_advisor_cli-0.1.0.dist-info/RECORD,,

git_lfs_advisor_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

git_lfs_advisor_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git-lfs-advisor = get_lfs_advisor_cli.cli:main

git_lfs_advisor_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+get_lfs_advisor_cli