roastbuddy 0.1.0__py3-none-any.whl

roastbuddy/core/status.py

@@ -0,0 +1,64 @@
+"""Status display for RoastBuddy."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from roastbuddy.utils.git_utils import (
+    find_git_repo,
+    get_last_commit,
+    get_recent_commits,
+    analyze_commit_patterns
+)
+from roastbuddy.utils.copilot_utils import is_copilot_available
+
+console = Console()
+
+
+def show_status():
+    """Show current RoastBuddy status."""
+    repo = find_git_repo()
+    
+    if not repo:
+        console.print("[red]❌ Not in a git repository![/red]")
+        return
+    
+    # Get commit data
+    last_commit = get_last_commit(repo)
+    recent_commits = get_recent_commits(repo, count=10)
+    patterns = analyze_commit_patterns(repo)
+    
+    # Check Copilot availability
+    copilot = "✅ Available" if is_copilot_available() else "❌ Not available"
+    
+    # Last commit info
+    if last_commit:
+        last_commit_text = (
+            f"[bold]{last_commit['short_hash']}[/bold] - {last_commit['message'][:40]}...\n"
+            f"Files: {last_commit['files_changed']} | "
+            f"Lines: +{last_commit['lines_added']} -{last_commit['lines_deleted']}"
+        )
+    else:
+        last_commit_text = "[dim]No commits yet[/dim]"
+    
+    # Statistics table
+    stats_table = Table(show_header=False, box=None)
+    stats_table.add_column("Metric", style="cyan")
+    stats_table.add_column("Value", style="green")
+    
+    stats_table.add_row("Total Commits", str(patterns["total_commits"]))
+    stats_table.add_row("Clean Commits", f"{patterns['clean_commits']} ({patterns.get('clean_ratio', 0):.0%})")
+    stats_table.add_row("Avg Files/Commit", f"{patterns['avg_files_per_commit']:.1f}")
+    stats_table.add_row("Avg Lines/Commit", f"{patterns['avg_lines_per_commit']:.0f}")
+    stats_table.add_row("GitHub Copilot", copilot)
+    
+    # Display everything
+    console.print(Panel(
+        f"[bold cyan]📊 Repository Status[/bold cyan]\n\n"
+        f"[bold]Last Commit:[/bold]\n{last_commit_text}\n\n"
+        f"[bold]Statistics (last {patterns['total_commits']} commits):[/bold]",
+        border_style="cyan"
+    ))
+    
+    console.print(stats_table)
+    
+    console.print("\n[dim]💡 Try: [bold]roastbuddy roast[/bold] or [bold]roastbuddy praise[/bold][/dim]")

roastbuddy/core/streaks.py

@@ -0,0 +1,22 @@
+"""Streak tracking functionality."""
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def show_streaks(streak_type: str = "all"):
+    """Show coding streaks."""
+    # TODO: Implement streak tracking
+    console.print(Panel.fit(
+        "[bold magenta]🔥 Your Streaks[/bold magenta]\n\n"
+        "[yellow]Streak tracking coming soon![/yellow]\n"
+        "This will track:\n"
+        "• Clean commit streaks\n"
+        "• Daily coding streaks\n"
+        "• Test passing streaks\n"
+        "• Personal records",
+        title=f"Streaks ({streak_type})",
+        border_style="magenta"
+    ))

roastbuddy/templates/__init__.py

@@ -0,0 +1 @@
+"""Templates __init__ file for roastbuddy.templates package."""

roastbuddy/templates/praise_templates.py

@@ -0,0 +1,113 @@
+"""Praise templates for fallback mode."""
+
+PRAISE_TEMPLATES = {
+    "clean_commit": [
+        "✨ Beautiful commit! Clear message, focused changes, and just the right size. You're a git wizard! 🧙‍♂️",
+        "🎯 PERFECTION! This is exactly how commits should look. Keep this standard up! 👑",
+        "💎 A gem of a commit! Clean, descriptive, and well-scoped. This is chef's kiss! 👨‍🍳💋",
+        "🌟 Outstanding work! Your commit message tells a story and your changes are surgical. Bravo! 👏",
+    ],
+    
+    "good_message": [
+        "📝 That commit message is *chef's kiss*! Clear, concise, and informative. Nice work! 🎉",
+        "✅ Love the detailed commit message! Future you will thank present you. Great practice! 🙌",
+        "💬 Your commit message game is STRONG! This is how you document changes properly! 📚",
+    ],
+    
+    "test_included": [
+        "🧪 Tests included? You absolute legend! That's how we write reliable code! 💪",
+        "✅ Testing your code like a pro! Your future self will thank you when bugs don't appear! 🛡️",
+        "🎯 Tests AND features? Now that's what I call comprehensive! Keep it up! 🚀",
+    ],
+    
+    "refactor": [
+        "♻️ Refactoring done right! Cleaning up the codebase like a true craftsperson! 🔧",
+        "✨ That refactor is *smooth*! Code quality just went up a notch! 📈",
+        "🧹 Love a good cleanup! Your codebase is looking fresher than ever! 🌟",
+    ],
+    
+    "bug_fix": [
+        "🐛 Bug squashed! Your debugging skills are on point! 💥",
+        "🔨 Fixed it! Every bug you crush makes the codebase stronger! 💪",
+        "🎯 Bug fix delivered! You're keeping the app running smooth! 🚀",
+    ],
+    
+    "feature": [
+        "🚀 New feature deployed! Innovation in action! Keep building! 🏗️",
+        "✨ Feature added! Your users are going to love this! 💝",
+        "🎉 Shipping features like a boss! This is what progress looks like! 📦",
+    ],
+    
+    "focused": [
+        "🎯 Laser-focused commit! One thing at a time, done right. This is the way! ⭐",
+        "👌 Perfect scope! You're not trying to boil the ocean in one commit. Smart! 🧠",
+        "💡 Focused and purposeful! This is textbook commit discipline! 📖",
+    ],
+    
+    "documentation": [
+        "📚 Documentation update! The unsung hero of codebases! Thank you! 🙏",
+        "✍️ Docs updated! Helping future developers understand the code. True hero! 🦸",
+        "📖 Documentation love! This makes everyone's life easier! 💚",
+    ],
+    
+    "small_improvement": [
+        "💎 Small but mighty! Every little improvement counts! Keep polishing! ✨",
+        "🎨 Nice touch! These small improvements add up to greatness! 🌟",
+        "⚡ Quick win! Small optimizations lead to big improvements over time! 📈",
+    ],
+    
+    "consistent_work": [
+        "🔥 Consistent commits! You're building momentum and it shows! 💪",
+        "📈 Steady progress! This is how successful projects are built! 🏗️",
+        "⚡ You're on a roll! Keep that coding energy flowing! 🌊",
+    ],
+    
+    "default": [
+        "👏 Good work! Every commit moves the project forward! 🚀",
+        "✅ Committed and deployed! Your contribution matters! 🌟",
+        "💪 Keep it up! Building great things one commit at a time! 🏗️",
+        "🎯 Solid work! You're making progress and that's what counts! 📈",
+    ]
+}
+
+
+def get_praise_category(commit_data: dict) -> str:
+    """Determine the praise category based on commit data."""
+    message = commit_data.get("message", "").lower()
+    lines_changed = commit_data.get("lines_added", 0) + commit_data.get("lines_deleted", 0)
+    files_changed = commit_data.get("files_changed", 0)
+    is_clean = commit_data.get("is_clean", False)
+    
+    # Check for specific keywords in message
+    if any(word in message for word in ["test", "spec", "unittest"]):
+        return "test_included"
+    
+    if any(word in message for word in ["refactor", "cleanup", "clean up"]):
+        return "refactor"
+    
+    if any(word in message for word in ["fix", "bug", "issue", "resolve"]):
+        return "bug_fix"
+    
+    if any(word in message for word in ["feat", "feature", "add", "implement"]):
+        return "feature"
+    
+    if any(word in message for word in ["doc", "readme", "comment"]):
+        return "documentation"
+    
+    # Check for clean commit characteristics
+    if is_clean and lines_changed < 200 and files_changed <= 5:
+        return "clean_commit"
+    
+    # Good message but maybe larger scope
+    if is_clean:
+        return "good_message"
+    
+    # Small improvements
+    if lines_changed < 50:
+        return "small_improvement"
+    
+    # Focused work
+    if files_changed <= 3:
+        return "focused"
+    
+    return "default"

roastbuddy/templates/roast_templates.py

@@ -0,0 +1,87 @@
+"""Roast templates for fallback mode."""
+
+ROAST_TEMPLATES = {
+    "tiny_commit": [
+        "🔥 A one-liner? What is this, a commit for ants? At least it's not breaking anything... probably. 😅",
+        "😏 One line changed. Did you forget to save the rest of your work, or is this your idea of 'moving fast'?",
+        "🤏 Congratulations on the microscopic commit! Every journey begins with a single step... but maybe take a few more? 💨",
+    ],
+    
+    "poor_message": [
+        "🙄 'fixed stuff' - ah yes, the ancient art of commit message poetry. Shakespeare would be proud... NOT! Try being specific next time. 📝",
+        "😬 That commit message though... Did you fall asleep on the keyboard? Give future you some context! 🤔",
+        "🎭 'WIP' - Working In Progress? More like 'Why Is Perfection' so hard to achieve! Clean up that message! ✨",
+        "💀 Your commit message has less detail than a tweet. And that's saying something. Be descriptive! 📖",
+    ],
+    
+    "massive_commit": [
+        "🚨 WOAH THERE! 500+ lines changed? That's not a commit, that's a novel! Break it up next time, champ. 📚",
+        "😱 This commit is MASSIVE! Did you just push your entire life's work? Smaller commits = easier debugging! 🔍",
+        "🎪 Welcome to the three-ring circus of commits! This one's doing WAY too much. Simplify, friend! 🎯",
+        "🌋 Your commit is erupting with changes! Cool feature, but try atomic commits next time. ⚛️",
+    ],
+    
+    "many_files": [
+        "🤯 You touched how many files?! Someone's been busy... or refactoring everything. Hope you tested it all! ✅",
+        "📂 Filing cabinet explosion detected! That's a lot of files for one commit. Everything still work? 🤞",
+        "🌪️ Tornado commit alert! You swept through the codebase like nobody's business. Bold move! 💪",
+    ],
+    
+    "no_tests": [
+        "🧪 No test files in sight... Living dangerously, I see! Your code might work... until it doesn't. 🎲",
+        "⚠️ Tests? Where we're going, we don't need tests! (Narrator: They definitely needed tests.) 🚀",
+        "🎰 Pushing without tests is like gambling at a casino. Feeling lucky? Add some tests! 🍀",
+    ],
+    
+    "good_commit": [
+        "✅ Now THIS is a commit! Clean message, reasonable size, proper focus. You're getting the hang of it! 🎯",
+        "👏 Not bad! This commit actually makes sense. Keep up this energy! 💯",
+        "😌 A solid commit! Clear, focused, and well-documented. This is the way! 🌟",
+    ],
+    
+    "average_commit": [
+        "🤷 Eh, it's... a commit. Not great, not terrible. Room for improvement but you're getting there! 📈",
+        "😐 Middle-of-the-road commit vibes. Does the job, could use some polish. Keep pushing! 💪",
+        "📊 This commit is like a 'C+' - passing, but you can do better! Level up that commit game! 🎮",
+    ],
+    
+    "default": [
+        "🔥 Another day, another commit! Keep the code flowing and the bugs fleeing! 🐛",
+        "💻 Commit received! Your code contribution has been noted in the annals of history. Make it count! 📜",
+        "🚀 Code committed! Now the real test: does it work in production? 🤔",
+        "⚡ Commit logged! Remember: with great commits comes great responsibility! 🦸",
+    ]
+}
+
+
+def get_roast_category(commit_data: dict) -> str:
+    """Determine the roast category based on commit data."""
+    lines_changed = commit_data.get("lines_added", 0) + commit_data.get("lines_deleted", 0)
+    files_changed = commit_data.get("files_changed", 0)
+    is_clean = commit_data.get("is_clean", False)
+    
+    # Check for poor commit message first
+    if not is_clean:
+        return "poor_message"
+    
+    # Check for tiny commits
+    if lines_changed < 5:
+        return "tiny_commit"
+    
+    # Check for massive commits
+    if lines_changed > 500:
+        return "massive_commit"
+    
+    # Check for many files changed
+    if files_changed > 15:
+        return "many_files"
+    
+    # Check commit quality
+    if is_clean and lines_changed < 200 and files_changed <= 5:
+        return "good_commit"
+    
+    # Average commit
+    if lines_changed < 200:
+        return "average_commit"
+    
+    return "default"

roastbuddy/utils/__init__.py

@@ -0,0 +1 @@
+"""Utils __init__ file for roastbuddy.utils package."""

roastbuddy/utils/code_analysis.py

@@ -0,0 +1,164 @@
+"""Code quality analysis utilities."""
+
+import os
+import re
+from pathlib import Path
+from typing import Dict, Any, List
+from git import Repo
+
+
+def count_todos_fixmes(repo_path: str) -> Dict[str, int]:
+    """Count TODO and FIXME comments in the codebase."""
+    todo_pattern = re.compile(r'#\s*(TODO|FIXME|XXX|HACK|NOTE):', re.IGNORECASE)
+    
+    counts = {"TODO": 0, "FIXME": 0, "XXX": 0, "HACK": 0, "NOTE": 0}
+    
+    # Common code extensions
+    code_extensions = {
+        ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs",
+        ".c", ".cpp", ".h", ".hpp", ".rb", ".php", ".swift", ".kt"
+    }
+    
+    try:
+        repo_path_obj = Path(repo_path)
+        for file_path in repo_path_obj.rglob("*"):
+            if file_path.is_file() and file_path.suffix in code_extensions:
+                # Skip common directories
+                if any(part in file_path.parts for part in ["node_modules", "venv", ".git", "dist", "build"]):
+                    continue
+                
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                        for line in f:
+                            match = todo_pattern.search(line)
+                            if match:
+                                keyword = match.group(1).upper()
+                                if keyword in counts:
+                                    counts[keyword] += 1
+                except Exception:
+                    continue
+    except Exception as e:
+        print(f"Error counting TODOs: {e}")
+    
+    return counts
+
+
+def detect_test_files(changed_files: List[str]) -> bool:
+    """Detect if any test files were changed."""
+    test_indicators = [
+        "test_", "_test.", "test.", ".test.", "spec.",
+        "/tests/", "/test/", "__tests__", ".spec."
+    ]
+    
+    for file_path in changed_files:
+        file_lower = file_path.lower()
+        if any(indicator in file_lower for indicator in test_indicators):
+            return True
+    
+    return False
+
+
+def analyze_file_sizes(repo_path: str) -> Dict[str, Any]:
+    """Analyze file sizes in the repository."""
+    code_extensions = {
+        ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".go", ".rs",
+        ".c", ".cpp", ".h", ".hpp", ".rb", ".php", ".swift", ".kt"
+    }
+    
+    file_sizes = []
+    total_lines = 0
+    
+    try:
+        repo_path_obj = Path(repo_path)
+        for file_path in repo_path_obj.rglob("*"):
+            if file_path.is_file() and file_path.suffix in code_extensions:
+                if any(part in file_path.parts for part in ["node_modules", "venv", ".git", "dist", "build"]):
+                    continue
+                
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                        lines = len(f.readlines())
+                        file_sizes.append(lines)
+                        total_lines += lines
+                except Exception:
+                    continue
+    except Exception as e:
+        print(f"Error analyzing file sizes: {e}")
+    
+    if not file_sizes:
+        return {
+            "total_files": 0,
+            "total_lines": 0,
+            "avg_file_size": 0,
+            "largest_file": 0,
+        }
+    
+    return {
+        "total_files": len(file_sizes),
+        "total_lines": total_lines,
+        "avg_file_size": sum(file_sizes) / len(file_sizes),
+        "largest_file": max(file_sizes),
+    }
+
+
+def categorize_commit_size(lines_changed: int) -> str:
+    """Categorize commit by size."""
+    if lines_changed < 10:
+        return "tiny"
+    elif lines_changed < 50:
+        return "small"
+    elif lines_changed < 200:
+        return "medium"
+    elif lines_changed < 500:
+        return "large"
+    else:
+        return "massive"
+
+
+def analyze_commit_quality(commit_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Analyze the quality of a commit."""
+    message = commit_data.get("message", "")
+    lines_changed = commit_data.get("lines_added", 0) + commit_data.get("lines_deleted", 0)
+    files_changed = commit_data.get("files_changed", 0)
+    
+    quality_score = 0
+    feedback = []
+    
+    # Message quality (40 points)
+    if commit_data.get("is_clean", False):
+        quality_score += 40
+        feedback.append("Good commit message")
+    else:
+        feedback.append("Improve commit message clarity")
+    
+    # Size appropriateness (30 points)
+    size_category = categorize_commit_size(lines_changed)
+    if size_category in ["small", "medium"]:
+        quality_score += 30
+        feedback.append("Appropriate commit size")
+    elif size_category == "tiny":
+        quality_score += 20
+        feedback.append("Very small commit")
+    elif size_category == "large":
+        quality_score += 15
+        feedback.append("Large commit - consider breaking it up")
+    else:  # massive
+        quality_score += 5
+        feedback.append("Massive commit - definitely break it up!")
+    
+    # Files changed (30 points)
+    if files_changed <= 5:
+        quality_score += 30
+        feedback.append("Focused file changes")
+    elif files_changed <= 15:
+        quality_score += 20
+        feedback.append("Moderate file changes")
+    else:
+        quality_score += 5
+        feedback.append("Many files changed - be careful!")
+    
+    return {
+        "quality_score": quality_score,
+        "size_category": size_category,
+        "feedback": feedback,
+    }

roastbuddy/utils/copilot_utils.py

@@ -0,0 +1,106 @@
+"""Copilot CLI detection and integration."""
+
+import subprocess
+from typing import Optional, Dict, Any
+from rich.console import Console
+
+console = Console()
+
+
+def is_copilot_available() -> bool:
+    """Check if GitHub Copilot CLI is available."""
+    try:
+        result = subprocess.run(
+            ["gh", "copilot", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+        return False
+
+
+def get_copilot_suggestion(prompt: str, system_prompt: Optional[str] = None) -> Optional[str]:
+    """Get a suggestion from GitHub Copilot CLI."""
+    if not is_copilot_available():
+        return None
+    
+    try:
+        # Build the command
+        cmd = ["gh", "copilot", "suggest", "-t", "shell"]
+        
+        full_prompt = prompt
+        if system_prompt:
+            full_prompt = f"{system_prompt}\n\n{prompt}"
+        
+        # Run the command
+        result = subprocess.run(
+            cmd + [full_prompt],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        if result.returncode == 0:
+            return result.stdout.strip()
+        else:
+            return None
+            
+    except Exception as e:
+        console.print(f"[yellow]Copilot CLI error: {e}[/yellow]")
+        return None
+
+
+def generate_roast_with_copilot(commit_data: Dict[str, Any]) -> Optional[str]:
+    """Generate a roast using Copilot CLI."""
+    if not is_copilot_available():
+        return None
+    
+    system_prompt = """You are RoastBuddy, a witty but supportive coding companion. 
+Your job is to roast code commits in a humorous way that's funny but never mean-spirited.
+Keep roasts short (2-3 sentences), use emojis, and end with a constructive tip.
+Be playful, sarcastic, but ultimately encouraging."""
+    
+    commit_info = (
+        f"Commit: {commit_data.get('message', 'No message')}\n"
+        f"Files changed: {commit_data.get('files_changed', 0)}\n"
+        f"Lines: +{commit_data.get('lines_added', 0)} -{commit_data.get('lines_deleted', 0)}\n"
+        f"Clean message: {commit_data.get('is_clean', False)}"
+    )
+    
+    prompt = f"Generate a witty roast for this commit:\n{commit_info}"
+    
+    return get_copilot_suggestion(prompt, system_prompt)
+
+
+def generate_praise_with_copilot(commit_data: Dict[str, Any]) -> Optional[str]:
+    """Generate praise using Copilot CLI."""
+    if not is_copilot_available():
+        return None
+    
+    system_prompt = """You are RoastBuddy, a supportive coding companion.
+Your job is to genuinely praise good work and celebrate achievements.
+Keep praise short (2-3 sentences), use emojis, and be enthusiastic and specific.
+Be genuine and encouraging."""
+    
+    commit_info = (
+        f"Commit: {commit_data.get('message', 'No message')}\n"
+        f"Files changed: {commit_data.get('files_changed', 0)}\n"
+        f"Lines: +{commit_data.get('lines_added', 0)} -{commit_data.get('lines_deleted', 0)}\n"
+        f"Clean message: {commit_data.get('is_clean', False)}"
+    )
+    
+    prompt = f"Generate enthusiastic praise for this commit:\n{commit_info}"
+    
+    return get_copilot_suggestion(prompt, system_prompt)
+
+
+def suggest_copilot_install():
+    """Suggest installing GitHub Copilot CLI."""
+    console.print("\n[bold cyan]💡 GitHub Copilot CLI not found[/bold cyan]")
+    console.print("\n[yellow]RoastBuddy works best with GitHub Copilot CLI for dynamic roasts![/yellow]")
+    console.print("\n[dim]To install:[/dim]")
+    console.print("  1. Install GitHub CLI: [bold]https://cli.github.com/[/bold]")
+    console.print("  2. Install Copilot extension: [bold]gh extension install github/gh-copilot[/bold]")
+    console.print("\n[dim]Don't worry! RoastBuddy will use built-in templates for now.[/dim]\n")