fancygit 1.0.0__py3-none-any.whl

src/git_insights.py

@@ -0,0 +1,304 @@
+import subprocess
+import json
+import re
+from datetime import datetime, timedelta
+from collections import defaultdict, Counter
+from typing import Dict, List, Tuple, Any
+
+class GitInsights:
+    def __init__(self, git_runner):
+        self.runner = git_runner
+    
+    def get_commit_frequency(self, days: int = 30) -> Dict[str, int]:
+        """Get commit frequency per contributor over specified days"""
+        since_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
+        returncode, stdout, stderr = self.runner.run_git_command([
+            'log', '--since', since_date, '--pretty=format:%an', '--date=short'
+        ])
+        
+        if returncode != 0:
+            return {}
+        
+        authors = stdout.strip().split('\n') if stdout.strip() else []
+        return dict(Counter(authors))
+    
+    def get_lines_changed_over_time(self, days: int = 30) -> List[Dict]:
+        """Get lines added/removed over time"""
+        since_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
+        returncode, stdout, stderr = self.runner.run_git_command([
+            'log', '--since', since_date, '--pretty=format:%H|%ad|%an', 
+            '--date=short', '--numstat'
+        ])
+        
+        if returncode != 0:
+            return []
+        
+        commits = []
+        current_commit = {}
+        
+        for line in stdout.strip().split('\n'):
+            if '|' in line and len(line.split('|')) == 3:
+                if current_commit:
+                    commits.append(current_commit)
+                hash_val, date, author = line.split('|')
+                current_commit = {
+                    'hash': hash_val,
+                    'date': date,
+                    'author': author,
+                    'files_changed': 0,
+                    'lines_added': 0,
+                    'lines_removed': 0
+                }
+            elif line.strip() and '\t' in line and current_commit:
+                # Parse numstat line: "10    5    file.py"
+                parts = line.strip().split('\t')
+                if len(parts) >= 3:
+                    try:
+                        added = int(parts[0]) if parts[0] != '-' else 0
+                        removed = int(parts[1]) if parts[1] != '-' else 0
+                        current_commit['lines_added'] += added
+                        current_commit['lines_removed'] += removed
+                        current_commit['files_changed'] += 1
+                    except ValueError:
+                        # Skip binary files
+                        continue
+        
+        if current_commit:
+            commits.append(current_commit)
+        
+        return commits
+    
+    def get_branch_analysis(self) -> Dict[str, Any]:
+        """Analyze branches - active vs stale, separating local and remote"""
+        branch_info = {}
+        now = datetime.now()
+        
+        # First, fetch latest remote data to ensure we have up-to-date branch information
+        self.runner.run_git_command(['fetch', '--all'])
+        
+        # Get local branches
+        returncode, stdout, stderr = self.runner.run_git_command(['branch'])
+        if returncode == 0:
+            for line in stdout.strip().split('\n'):
+                if line.strip():
+                    branch = line.strip().replace('* ', '')
+                    branch_name = f"local/{branch}"
+                    
+                    # Get last commit date for branch
+                    commit_returncode, commit_stdout, _ = self.runner.run_git_command([
+                        'log', '-1', '--pretty=format:%ad', '--date=iso', branch
+                    ])
+                    
+                    if commit_returncode == 0 and commit_stdout.strip():
+                        try:
+                            # Parse ISO date with timezone info
+                            date_str = commit_stdout.strip()
+                            if ' ' in date_str:
+                                # Format like "2026-03-10 02:46:15 +0300"
+                                last_commit_date = datetime.strptime(date_str.split()[0] + ' ' + date_str.split()[1], "%Y-%m-%d %H:%M:%S")
+                            else:
+                                # Format like "2026-03-10"
+                                last_commit_date = datetime.strptime(date_str, "%Y-%m-%d")
+                        except ValueError:
+                            # Fallback to simple date parsing
+                            last_commit_date = datetime.strptime(date_str.split()[0], "%Y-%m-%d")
+                        
+                        days_inactive = (now - last_commit_date).days
+                        
+                        branch_info[branch_name] = {
+                            'last_commit': commit_stdout.strip(),
+                            'days_inactive': days_inactive,
+                            'status': 'active' if days_inactive <= 30 else 'stale',
+                            'type': 'local'
+                        }
+        
+        # Get remote branches
+        returncode, stdout, stderr = self.runner.run_git_command(['branch', '-r'])
+        if returncode == 0:
+            for line in stdout.strip().split('\n'):
+                if line.strip():
+                    branch = line.strip().replace('* ', '').replace('remotes/', '')
+                    if not branch.startswith('HEAD ->'):
+                        branch_name = f"remote/{branch}"
+                        
+                        # Get last commit date for branch
+                        commit_returncode, commit_stdout, _ = self.runner.run_git_command([
+                            'log', '-1', '--pretty=format:%ad', '--date=iso', branch
+                        ])
+                        
+                        if commit_returncode == 0 and commit_stdout.strip():
+                            try:
+                                # Parse ISO date with timezone info
+                                date_str = commit_stdout.strip()
+                                if ' ' in date_str:
+                                    # Format like "2026-03-10 02:46:15 +0300"
+                                    last_commit_date = datetime.strptime(date_str.split()[0] + ' ' + date_str.split()[1], "%Y-%m-%d %H:%M:%S")
+                                else:
+                                    # Format like "2026-03-10"
+                                    last_commit_date = datetime.strptime(date_str, "%Y-%m-%d")
+                            except ValueError:
+                                # Fallback to simple date parsing
+                                last_commit_date = datetime.strptime(date_str.split()[0], "%Y-%m-%d")
+                            
+                            days_inactive = (now - last_commit_date).days
+                            
+                            branch_info[branch_name] = {
+                                'last_commit': commit_stdout.strip(),
+                                'days_inactive': days_inactive,
+                                'status': 'active' if days_inactive <= 30 else 'stale',
+                                'type': 'remote'
+                            }
+        
+        return branch_info
+    
+    def get_file_hotspots(self, days: int = 90) -> Dict[str, int]:
+        """Get files/directories with most changes"""
+        since_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
+        returncode, stdout, stderr = self.runner.run_git_command([
+            'log', '--since', since_date, '--name-only', '--pretty=format:'
+        ])
+        
+        if returncode != 0:
+            return {}
+        
+        files = []
+        for line in stdout.split('\n'):
+            if line.strip():
+                files.append(line.strip())
+        
+        return dict(Counter(files))
+    
+    def get_merge_efficiency(self, days: int = 90) -> Dict[str, Any]:
+        """Analyze merge/pull request efficiency"""
+        since_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
+        
+        # Get merge commits
+        returncode, stdout, stderr = self.runner.run_git_command([
+            'log', '--since', since_date, '--merges', '--pretty=format:%H|%ad|%s', 
+            '--date=iso'
+        ])
+        
+        if returncode != 0:
+            return {}
+        
+        merges = []
+        for line in stdout.strip().split('\n'):
+            if '|' in line:
+                hash_val, date, subject = line.split('|', 2)
+                merges.append({
+                    'hash': hash_val,
+                    'date': date,
+                    'subject': subject
+                })
+        
+        # Calculate average time between merge commits
+        if len(merges) < 2:
+            return {'total_merges': len(merges), 'avg_merge_interval_days': 0}
+        
+        merge_dates = []
+        for merge in merges:
+            try:
+                date_str = merge['date']
+                if ' ' in date_str:
+                    # Format like "2026-03-10 02:46:15 +0300"
+                    merge_date = datetime.strptime(date_str.split()[0] + ' ' + date_str.split()[1], "%Y-%m-%d %H:%M:%S")
+                else:
+                    # Format like "2026-03-10"
+                    merge_date = datetime.strptime(date_str, "%Y-%m-%d")
+                merge_dates.append(merge_date)
+            except ValueError:
+                # Skip invalid dates
+                continue
+        
+        if len(merge_dates) < 2:
+            return {'total_merges': len(merges), 'avg_merge_interval_days': 0}
+        
+        merge_dates.sort()
+        
+        intervals = []
+        for i in range(1, len(merge_dates)):
+            interval = (merge_dates[i] - merge_dates[i-1]).days
+            intervals.append(interval)
+        
+        avg_interval = sum(intervals) / len(intervals) if intervals else 0
+        
+        return {
+            'total_merges': len(merges),
+            'avg_merge_interval_days': round(avg_interval, 1),
+            'recent_merges': merges[-5:]  # Last 5 merges
+        }
+    
+    def get_contributor_stats(self) -> Dict[str, Dict]:
+        """Get comprehensive contributor statistics"""
+        returncode, stdout, stderr = self.runner.run_git_command([
+            'log', '--pretty=format:%an|%ad', '--date=iso', '--numstat'
+        ])
+        
+        if returncode != 0:
+            return {}
+        
+        contributors = defaultdict(lambda: {
+            'commits': 0,
+            'lines_added': 0,
+            'lines_removed': 0,
+            'files_changed': 0,
+            'first_commit': None,
+            'last_commit': None
+        })
+        
+        lines = stdout.strip().split('\n')
+        current_author = None
+        current_date = None
+        
+        for line in lines:
+            if '|' in line and len(line.split('|')) == 2:
+                author, date = line.split('|')
+                current_author = author.strip()
+                current_date = date.strip()
+                
+                if contributors[current_author]['first_commit'] is None:
+                    contributors[current_author]['first_commit'] = current_date
+                contributors[current_author]['last_commit'] = current_date
+                contributors[current_author]['commits'] += 1
+                
+            elif line.strip() and '\t' in line and current_author:
+                # Parse numstat line: "10    5    file.py"
+                parts = line.strip().split('\t')
+                if len(parts) >= 3:
+                    try:
+                        added = int(parts[0]) if parts[0] != '-' else 0
+                        removed = int(parts[1]) if parts[1] != '-' else 0
+                        contributors[current_author]['lines_added'] += added
+                        contributors[current_author]['lines_removed'] += removed
+                        contributors[current_author]['files_changed'] += 1
+                    except ValueError:
+                        # Skip binary files or invalid numbers
+                        continue
+        
+        return dict(contributors)
+    
+    def generate_insights_report(self, days: int = 30) -> Dict[str, Any]:
+        """Generate comprehensive insights report"""
+        report = {
+            'generated_at': datetime.now().isoformat(),
+            'analysis_period_days': days,
+            'commit_frequency': self.get_commit_frequency(days),
+            'lines_changed': self.get_lines_changed_over_time(days),
+            'branch_analysis': self.get_branch_analysis(),
+            'file_hotspots': self.get_file_hotspots(days),
+            'contributor_stats': self.get_contributor_stats()
+        }
+        
+        # Add summary statistics
+        total_commits = sum(report['commit_frequency'].values())
+        active_branches = sum(1 for b in report['branch_analysis'].values() if b['status'] == 'active')
+        
+        report['summary'] = {
+            'total_commits': total_commits,
+            'active_contributors': len(report['commit_frequency']),
+            'active_branches': active_branches,
+            'total_branches': len(report['branch_analysis']),
+            'total_files_changed': len(report['file_hotspots'])
+        }
+        
+        return report

src/git_runner.py

@@ -0,0 +1,20 @@
+import subprocess
+
+class GitRunner:
+    def __init__(self) -> None:
+        self.git_cmd = "git"
+    
+    def run_git_command(self, args):
+        """Run git command and capture output"""
+        try:
+            cmd = [self.git_cmd] + args
+            result = subprocess.run(
+                cmd, 
+                capture_output=True, 
+                text=True, 
+                check=False
+            )
+            return result.returncode, result.stdout, result.stderr
+        except Exception as e:
+            return -1, "", str(e)
+    

src/loading_animation.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+import threading
+import time
+import sys
+import itertools
+import random
+
+
+class LoadingAnimation:
+    """ASCII loading animations for long-running operations"""
+    
+    def __init__(self):
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._last_line_length = 0
+    
+    def _clear_line(self):
+        """Clear the current line"""
+        sys.stdout.write('\r' + ' ' * self._last_line_length + '\r')
+        sys.stdout.flush()
+        self._last_line_length = 0
+    
+    def _man_running(self):
+        """Man running animation"""
+        frames = [
+            "- - - - 🏃",
+            "- - - 🏃 -", 
+            "- - 🏃 - -",
+            "- 🏃 - - -",
+            "🏃 - - - -"
+        ]
+        message = "🤖 AI is thinking"
+        
+        while not self._stop_event.is_set():
+            for frame in frames:
+                if self._stop_event.is_set():
+                    break
+                self._clear_line()
+                text = f"{message} {frame}"
+                sys.stdout.write(text)
+                sys.stdout.flush()
+                self._last_line_length = len(text)
+                time.sleep(0.3)
+    
+    def _loading_dots(self):
+        """Simple loading dots animation"""
+        dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        message = "🤖 AI is analyzing"
+        
+        while not self._stop_event.is_set():
+            for dot in dots:
+                if self._stop_event.is_set():
+                    break
+                self._clear_line()
+                text = f"{message} {dot}"
+                sys.stdout.write(text)
+                sys.stdout.flush()
+                self._last_line_length = len(text)
+                time.sleep(0.1)
+    
+    def _progress_bar(self):
+        """Progress bar animation"""
+        bar_chars = "░▒▓█"
+        message = "🤖 AI processing"
+        
+        while not self._stop_event.is_set():
+            for i in range(21):  # 0 to 20
+                if self._stop_event.is_set():
+                    break
+                filled = i // 5
+                partial = i % 5
+                bar = "█" * filled + (bar_chars[partial] if partial < 3 else "█")
+                bar = bar.ljust(4, "░")
+                self._clear_line()
+                text = f"{message} [{bar}] {i*5}%"
+                sys.stdout.write(text)
+                sys.stdout.flush()
+                self._last_line_length = len(text)
+                time.sleep(0.15)
+    
+    def _matrix_rain(self):
+        """Matrix-style falling characters"""
+        chars = "01"
+        message = "🤖 AI computing"
+        
+        while not self._stop_event.is_set():
+            for _ in range(10):
+                if self._stop_event.is_set():
+                    break
+                rain = ''.join(random.choice(chars) for _ in range(8))
+                self._clear_line()
+                text = f"{message} [{rain}]"
+                sys.stdout.write(text)
+                sys.stdout.flush()
+                self._last_line_length = len(text)
+                time.sleep(0.2)
+    
+    def _brain_activity(self):
+        """Brain activity animation"""
+        frames = [
+            "🧠💭",
+            "🧠✨", 
+            "🧠⚡",
+            "🧠💡",
+            "🧠🔮"
+        ]
+        message = "🤖 AI thinking"
+        
+        while not self._stop_event.is_set():
+            for frame in frames:
+                if self._stop_event.is_set():
+                    break
+                self._clear_line()
+                text = f"{message} {frame}"
+                sys.stdout.write(text)
+                sys.stdout.flush()
+                self._last_line_length = len(text)
+                time.sleep(0.4)
+    
+    def start(self, animation_type="run"):
+        """Start the loading animation
+        
+        Args:
+            animation_type: Type of animation ("run", "dots", "progress", "matrix", "brain")
+        """
+        if self._thread and self._thread.is_alive():
+            return
+        
+        self._stop_event.clear()
+        
+        animation_map = {
+            "run": self._man_running,
+            "dots": self._loading_dots,
+            "progress": self._progress_bar,
+            "matrix": self._matrix_rain,
+            "brain": self._brain_activity
+        }
+        
+        animation_func = animation_map.get(animation_type, self._man_running)
+        self._thread = threading.Thread(target=animation_func, daemon=True)
+        self._thread.start()
+    
+    def stop(self):
+        """Stop the loading animation and clear the line"""
+        if self._thread and self._thread.is_alive():
+            self._stop_event.set()
+            self._thread.join(timeout=0.5)
+        
+        # Clear the entire line and move to beginning
+        sys.stdout.write('\r' + ' ' * 100 + '\r')
+        sys.stdout.flush()
+
+
+# Context manager for easy usage
+class LoadingContext:
+    """Context manager for loading animations"""
+    
+    def __init__(self, animation_type="dots"):
+        self.animation = LoadingAnimation()
+        self.animation_type = animation_type
+    
+    def __enter__(self):
+        self.animation.start(self.animation_type)
+        return self.animation
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.animation.stop()

src/merge_conflict.py

@@ -0,0 +1,27 @@
+# example for this dataclass object
+# MergeConflict(
+#  file="fancygit.py",
+#  base_branch="main",
+#  incoming_branch="refactor/fancygit.py",
+#  current_code="return a + b",
+#  incoming_code="return a - b",
+#  start_line=12,
+#  end_line=34
+# )
+
+from dataclasses import dataclass
+
+@dataclass (frozen=True)
+class MergeConflict:
+    file: str
+
+    # to get hold of which branches
+    current_branch: str
+    incoming_branch: str
+
+    # to get hold of the line of code itself
+    current_code: str
+    incoming_code: str
+    
+    start_line: int
+    end_line: int