roastbuddy 0.1.0__py3-none-any.whl

roastbuddy/__init__.py

@@ -0,0 +1,5 @@
+"""RoastBuddy - Your witty coding companion."""
+
+__version__ = "0.1.0"
+__author__ = "RoastBuddy Team"
+__description__ = "A fun, interactive CLI companion that roasts and praises your code"

roastbuddy/cli.py

@@ -0,0 +1,113 @@
+"""Main CLI entry point for RoastBuddy."""
+
+import click
+from rich.console import Console
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="roastbuddy")
+def main():
+    """🔥 RoastBuddy - Your witty coding companion!
+    
+    Roasts, praises, and tracks your development journey.
+    """
+    pass
+
+
+@main.command()
+@click.option("--path", default=".", help="Path to git repository")
+def init(path):
+    """Initialize RoastBuddy in a git repository."""
+    from roastbuddy.core.initializer import initialize_roastbuddy
+    
+    console.print("[bold cyan]🔥 Initializing RoastBuddy...[/bold cyan]")
+    success = initialize_roastbuddy(path)
+    
+    if success:
+        console.print("[bold green]✅ RoastBuddy is ready to roast![/bold green]")
+        console.print("\n💡 Try: [bold]roastbuddy status[/bold]")
+    else:
+        console.print("[bold red]❌ Failed to initialize RoastBuddy[/bold red]")
+
+
+@main.command()
+def status():
+    """Show current streaks and recent activity."""
+    from roastbuddy.core.status import show_status
+    
+    console.print("[bold cyan]📊 RoastBuddy Status[/bold cyan]\n")
+    show_status()
+
+
+@main.command()
+@click.option("--last", "-l", is_flag=True, help="Roast the last commit")
+def roast(last):
+    """Roast your code with humor."""
+    from roastbuddy.core.roaster import roast_code
+    
+    console.print("[bold red]🔥 Preparing your roast...[/bold red]\n")
+    roast_code(last_commit=last)
+
+
+@main.command()
+@click.option("--last", "-l", is_flag=True, help="Praise the last commit")
+def praise(last):
+    """Get some well-deserved praise!"""
+    from roastbuddy.core.roaster import praise_code
+    
+    console.print("[bold green]✨ Preparing your praise...[/bold green]\n")
+    praise_code(last_commit=last)
+
+
+@main.command()
+@click.option("--type", "-t", type=click.Choice(["all", "clean", "daily", "test"]), 
+              default="all", help="Streak type to display")
+def streak(type):
+    """View your coding streaks."""
+    from roastbuddy.core.streaks import show_streaks
+    
+    console.print("[bold magenta]🔥 Your Coding Streaks[/bold magenta]\n")
+    show_streaks(streak_type=type)
+
+
+@main.command()
+@click.option("--limit", "-n", default=10, help="Number of entries to show")
+def history(limit):
+    """View roast and praise history."""
+    from roastbuddy.core.history import show_history
+    
+    console.print("[bold cyan]📜 RoastBuddy History[/bold cyan]\n")
+    show_history(limit=limit)
+
+
+@main.command()
+@click.option("--format", "-f", type=click.Choice(["linkedin", "twitter", "github"]), 
+              default="linkedin", help="Output format")
+def share(format):
+    """Generate shareable social media content."""
+    from roastbuddy.core.share import generate_shareable
+    
+    console.print(f"[bold cyan]📤 Generating {format} content...[/bold cyan]\n")
+    generate_shareable(format_type=format)
+
+
+@main.command()
+@click.option("--show", is_flag=True, help="Show current configuration")
+@click.option("--set", "set_value", nargs=2, help="Set config value (key value)")
+def config(show, set_value):
+    """Manage RoastBuddy configuration."""
+    from roastbuddy.core.config import show_config, set_config
+    
+    if show:
+        show_config()
+    elif set_value:
+        key, value = set_value
+        set_config(key, value)
+    else:
+        console.print("[yellow]Use --show or --set to manage configuration[/yellow]")
+
+
+if __name__ == "__main__":
+    main()

roastbuddy/core/__init__.py

@@ -0,0 +1 @@
+"""Core __init__ file for roastbuddy.core package."""

roastbuddy/core/config.py

@@ -0,0 +1,96 @@
+"""Configuration management for RoastBuddy."""
+
+import os
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+DEFAULT_CONFIG = {
+    "roast_intensity": "medium",  # light, medium, spicy
+    "auto_roast_on_commit": False,
+    "use_copilot": "auto",  # auto, always, never
+    "enable_streaks": True,
+    "show_emojis": True,
+    "color_output": True,
+}
+
+CONFIG_DIR = Path.home() / ".roastbuddy"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+
+def get_config_dir() -> Path:
+    """Get or create the RoastBuddy config directory."""
+    CONFIG_DIR.mkdir(exist_ok=True)
+    return CONFIG_DIR
+
+
+def get_config_file() -> Path:
+    """Get the config file path."""
+    return CONFIG_FILE
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from file or return defaults."""
+    if not CONFIG_FILE.exists():
+        return DEFAULT_CONFIG.copy()
+    
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            config = yaml.safe_load(f) or {}
+        return {**DEFAULT_CONFIG, **config}
+    except Exception as e:
+        console.print(f"[yellow]Warning: Failed to load config: {e}[/yellow]")
+        return DEFAULT_CONFIG.copy()
+
+
+def save_config(config: Dict[str, Any]) -> bool:
+    """Save configuration to file."""
+    try:
+        get_config_dir()
+        with open(CONFIG_FILE, "w") as f:
+            yaml.dump(config, f, default_flow_style=False)
+        return True
+    except Exception as e:
+        console.print(f"[red]Error saving config: {e}[/red]")
+        return False
+
+
+def show_config():
+    """Display current configuration."""
+    config = load_config()
+    
+    table = Table(title="RoastBuddy Configuration")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="green")
+    
+    for key, value in config.items():
+        table.add_row(key, str(value))
+    
+    console.print(table)
+    console.print(f"\n📁 Config file: [cyan]{CONFIG_FILE}[/cyan]")
+
+
+def set_config(key: str, value: str):
+    """Set a configuration value."""
+    config = load_config()
+    
+    # Type conversion
+    if value.lower() in ["true", "false"]:
+        value = value.lower() == "true"
+    
+    config[key] = value
+    
+    if save_config(config):
+        console.print(f"[green]✅ Set {key} = {value}[/green]")
+    else:
+        console.print(f"[red]❌ Failed to set configuration[/red]")
+
+
+def get_config_value(key: str, default: Any = None) -> Any:
+    """Get a single configuration value."""
+    config = load_config()
+    return config.get(key, default)

roastbuddy/core/database.py

@@ -0,0 +1,198 @@
+"""Database management for RoastBuddy."""
+
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+from roastbuddy.core.config import get_config_dir
+
+DB_FILE = get_config_dir() / "roastbuddy.db"
+
+
+def get_db_connection() -> sqlite3.Connection:
+    """Get a database connection."""
+    conn = sqlite3.connect(DB_FILE)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def initialize_database():
+    """Initialize the database schema."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    # Commits table
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS commits (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            commit_hash TEXT UNIQUE NOT NULL,
+            message TEXT NOT NULL,
+            author TEXT NOT NULL,
+            timestamp DATETIME NOT NULL,
+            files_changed INTEGER DEFAULT 0,
+            lines_added INTEGER DEFAULT 0,
+            lines_deleted INTEGER DEFAULT 0,
+            is_clean BOOLEAN DEFAULT 0,
+            repo_path TEXT NOT NULL
+        )
+    """)
+    
+    # Streaks table
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS streaks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            streak_type TEXT NOT NULL,
+            current_count INTEGER DEFAULT 0,
+            best_count INTEGER DEFAULT 0,
+            last_updated DATETIME NOT NULL,
+            repo_path TEXT NOT NULL
+        )
+    """)
+    
+    # Roasts and praise history
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS interactions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            interaction_type TEXT NOT NULL,
+            content TEXT NOT NULL,
+            commit_hash TEXT,
+            timestamp DATETIME NOT NULL,
+            source TEXT NOT NULL,
+            repo_path TEXT NOT NULL
+        )
+    """)
+    
+    # Achievements/milestones
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS achievements (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            achievement_type TEXT NOT NULL,
+            description TEXT NOT NULL,
+            earned_at DATETIME NOT NULL,
+            repo_path TEXT NOT NULL
+        )
+    """)
+    
+    conn.commit()
+    conn.close()
+
+
+def add_commit_record(commit_data: Dict[str, Any]) -> bool:
+    """Add a commit record to the database."""
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT OR REPLACE INTO commits 
+            (commit_hash, message, author, timestamp, files_changed, 
+             lines_added, lines_deleted, is_clean, repo_path)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            commit_data.get("hash"),
+            commit_data.get("message"),
+            commit_data.get("author"),
+            commit_data.get("timestamp"),
+            commit_data.get("files_changed", 0),
+            commit_data.get("lines_added", 0),
+            commit_data.get("lines_deleted", 0),
+            commit_data.get("is_clean", False),
+            commit_data.get("repo_path"),
+        ))
+        
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"Error adding commit: {e}")
+        return False
+
+
+def add_interaction(interaction_type: str, content: str, commit_hash: Optional[str], 
+                    source: str, repo_path: str) -> bool:
+    """Add a roast/praise interaction to the database."""
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT INTO interactions 
+            (interaction_type, content, commit_hash, timestamp, source, repo_path)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (
+            interaction_type,
+            content,
+            commit_hash,
+            datetime.now().isoformat(),
+            source,
+            repo_path
+        ))
+        
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"Error adding interaction: {e}")
+        return False
+
+
+def get_streak_data(streak_type: str, repo_path: str) -> Optional[Dict[str, Any]]:
+    """Get streak data for a specific type."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT * FROM streaks 
+        WHERE streak_type = ? AND repo_path = ?
+    """, (streak_type, repo_path))
+    
+    row = cursor.fetchone()
+    conn.close()
+    
+    if row:
+        return dict(row)
+    return None
+
+
+def update_streak(streak_type: str, current_count: int, best_count: int, repo_path: str) -> bool:
+    """Update or create a streak record."""
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT OR REPLACE INTO streaks 
+            (streak_type, current_count, best_count, last_updated, repo_path)
+            VALUES (?, ?, ?, ?, ?)
+        """, (
+            streak_type,
+            current_count,
+            best_count,
+            datetime.now().isoformat(),
+            repo_path
+        ))
+        
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"Error updating streak: {e}")
+        return False
+
+
+def get_recent_interactions(limit: int = 10, repo_path: str = ".") -> List[Dict[str, Any]]:
+    """Get recent roast/praise interactions."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT * FROM interactions 
+        WHERE repo_path = ?
+        ORDER BY timestamp DESC 
+        LIMIT ?
+    """, (repo_path, limit))
+    
+    rows = cursor.fetchall()
+    conn.close()
+    
+    return [dict(row) for row in rows]

roastbuddy/core/history.py

@@ -0,0 +1,40 @@
+"""History display functionality."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from roastbuddy.core.database import get_recent_interactions
+from roastbuddy.utils.git_utils import get_repo_path
+
+console = Console()
+
+
+def show_history(limit: int = 10):
+    """Show roast and praise history."""
+    repo_path = get_repo_path()
+    interactions = get_recent_interactions(limit=limit, repo_path=repo_path)
+    
+    if not interactions:
+        console.print("[yellow]📜 No history yet![/yellow]")
+        console.print("[dim]Use [bold]roastbuddy roast[/bold] or [bold]roastbuddy praise[/bold] first![/dim]")
+        return
+    
+    table = Table(title=f"📜 RoastBuddy History (last {len(interactions)})")
+    table.add_column("Type", style="cyan", width=8)
+    table.add_column("Content", style="white", width=60)
+    table.add_column("Source", style="dim", width=10)
+    table.add_column("Time", style="dim", width=16)
+    
+    for interaction in interactions:
+        interaction_type = interaction["interaction_type"]
+        emoji = "🔥" if interaction_type == "roast" else "✨"
+        type_str = f"{emoji} {interaction_type.title()}"
+        
+        content = interaction["content"][:60] + "..." if len(interaction["content"]) > 60 else interaction["content"]
+        
+        source = interaction["source"]
+        timestamp = interaction["timestamp"][:16]  # Just date and time
+        
+        table.add_row(type_str, content, source, timestamp)
+    
+    console.print(table)

roastbuddy/core/initializer.py

@@ -0,0 +1,61 @@
+"""Initializer for RoastBuddy."""
+
+import os
+from pathlib import Path
+from git import Repo, InvalidGitRepositoryError
+from rich.console import Console
+from roastbuddy.core.config import get_config_dir, save_config, DEFAULT_CONFIG
+from roastbuddy.core.database import initialize_database
+
+console = Console()
+
+
+def is_git_repository(path: str) -> bool:
+    """Check if the path is a git repository."""
+    try:
+        Repo(path, search_parent_directories=True)
+        return True
+    except InvalidGitRepositoryError:
+        return False
+
+
+def initialize_roastbuddy(path: str = ".") -> bool:
+    """Initialize RoastBuddy in a git repository."""
+    path = Path(path).resolve()
+    
+    # Check if it's a git repository
+    if not is_git_repository(str(path)):
+        console.print(f"[red]❌ {path} is not a git repository![/red]")
+        console.print("[yellow]💡 Initialize git first: [bold]git init[/bold][/yellow]")
+        return False
+    
+    try:
+        # Create config directory
+        config_dir = get_config_dir()
+        console.print(f"[dim]Creating config directory: {config_dir}[/dim]")
+        
+        # Initialize database
+        console.print("[dim]Initializing database...[/dim]")
+        initialize_database()
+        
+        # Save default configuration
+        console.print("[dim]Creating default configuration...[/dim]")
+        save_config(DEFAULT_CONFIG)
+        
+        # Create .roastbuddy marker in repo
+        marker_file = path / ".roastbuddy"
+        if not marker_file.exists():
+            marker_file.touch()
+            console.print(f"[dim]Created repository marker: {marker_file}[/dim]")
+        
+        console.print("\n[bold green]🎉 RoastBuddy initialized successfully![/bold green]")
+        console.print("\n[cyan]Next steps:[/cyan]")
+        console.print("  • [bold]roastbuddy roast[/bold] - Get roasted!")
+        console.print("  • [bold]roastbuddy praise[/bold] - Get some praise")
+        console.print("  • [bold]roastbuddy status[/bold] - Check your stats")
+        
+        return True
+        
+    except Exception as e:
+        console.print(f"[red]❌ Error during initialization: {e}[/red]")
+        return False

roastbuddy/core/roaster.py

@@ -0,0 +1,130 @@
+"""Roasting and praising functionality."""
+
+import random
+from rich.console import Console
+from rich.panel import Panel
+from roastbuddy.utils.git_utils import find_git_repo, get_last_commit, get_repo_path
+from roastbuddy.utils.copilot_utils import (
+    is_copilot_available,
+    generate_roast_with_copilot,
+    generate_praise_with_copilot,
+    suggest_copilot_install
+)
+from roastbuddy.templates.roast_templates import ROAST_TEMPLATES, get_roast_category
+from roastbuddy.templates.praise_templates import PRAISE_TEMPLATES, get_praise_category
+from roastbuddy.core.config import get_config_value
+from roastbuddy.core.database import add_interaction
+
+console = Console()
+
+
+def roast_code(last_commit: bool = True):
+    """Generate a roast for the code."""
+    repo = find_git_repo()
+    
+    if not repo:
+        console.print("[red]❌ Not in a git repository![/red]")
+        console.print("[yellow]Initialize git first: [bold]git init[/bold][/yellow]")
+        return
+    
+    commit_data = get_last_commit(repo)
+    
+    if not commit_data:
+        console.print("[yellow]⚠️ No commits found yet![/yellow]")
+        console.print("[dim]Make your first commit and come back for a roast! 🔥[/dim]")
+        return
+    
+    # Check if Copilot should be used
+    use_copilot = get_config_value("use_copilot", "auto")
+    copilot_available = is_copilot_available()
+    
+    roast_text = None
+    source = "template"
+    
+    # Try Copilot if configured
+    if use_copilot in ["auto", "always"] and copilot_available:
+        roast_text = generate_roast_with_copilot(commit_data)
+        source = "copilot"
+        if roast_text:
+            console.print("[dim]🤖 Roast powered by GitHub Copilot[/dim]\n")
+    
+    # Fallback to templates
+    if not roast_text:
+        if use_copilot == "always":
+            console.print("[yellow]⚠️ Copilot not available but set to 'always'[/yellow]")
+            suggest_copilot_install()
+            return
+        
+        category = get_roast_category(commit_data)
+        roast_text = random.choice(ROAST_TEMPLATES.get(category, ROAST_TEMPLATES["default"]))
+        
+        if not copilot_available and use_copilot == "auto":
+            console.print("[dim]💡 Using built-in roasts (Copilot not available)[/dim]\n")
+    
+    # Display the roast
+    console.print(Panel.fit(
+        f"[bold red]🔥 Your Roast[/bold red]\n\n"
+        f"{roast_text}\n\n"
+        f"[dim]Commit: {commit_data['short_hash']} - {commit_data['message'][:50]}...[/dim]",
+        title="Roast",
+        border_style="red"
+    ))
+    
+    # Save to database
+    add_interaction("roast", roast_text, commit_data["hash"], source, commit_data["repo_path"])
+
+
+def praise_code(last_commit: bool = True):
+    """Generate praise for the code."""
+    repo = find_git_repo()
+    
+    if not repo:
+        console.print("[red]❌ Not in a git repository![/red]")
+        console.print("[yellow]Initialize git first: [bold]git init[/bold][/yellow]")
+        return
+    
+    commit_data = get_last_commit(repo)
+    
+    if not commit_data:
+        console.print("[yellow]⚠️ No commits found yet![/yellow]")
+        console.print("[dim]Make your first commit and come back for praise! ✨[/dim]")
+        return
+    
+    # Check if Copilot should be used
+    use_copilot = get_config_value("use_copilot", "auto")
+    copilot_available = is_copilot_available()
+    
+    praise_text = None
+    source = "template"
+    
+    # Try Copilot if configured
+    if use_copilot in ["auto", "always"] and copilot_available:
+        praise_text = generate_praise_with_copilot(commit_data)
+        source = "copilot"
+        if praise_text:
+            console.print("[dim]🤖 Praise powered by GitHub Copilot[/dim]\n")
+    
+    # Fallback to templates
+    if not praise_text:
+        if use_copilot == "always":
+            console.print("[yellow]⚠️ Copilot not available but set to 'always'[/yellow]")
+            suggest_copilot_install()
+            return
+        
+        category = get_praise_category(commit_data)
+        praise_text = random.choice(PRAISE_TEMPLATES.get(category, PRAISE_TEMPLATES["default"]))
+        
+        if not copilot_available and use_copilot == "auto":
+            console.print("[dim]💡 Using built-in praise (Copilot not available)[/dim]\n")
+    
+    # Display the praise
+    console.print(Panel.fit(
+        f"[bold green]✨ Your Praise[/bold green]\n\n"
+        f"{praise_text}\n\n"
+        f"[dim]Commit: {commit_data['short_hash']} - {commit_data['message'][:50]}...[/dim]",
+        title="Praise",
+        border_style="green"
+    ))
+    
+    # Save to database
+    add_interaction("praise", praise_text, commit_data["hash"], source, commit_data["repo_path"])

roastbuddy/core/share.py

@@ -0,0 +1,18 @@
+"""Shareable content generation."""
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def generate_shareable(format_type: str = "linkedin"):
+    """Generate shareable social media content."""
+    # TODO: Implement shareable content generation
+    console.print(Panel.fit(
+        f"[bold cyan]📤 {format_type.title()} Content[/bold cyan]\n\n"
+        "[yellow]Shareable content generation coming soon![/yellow]\n"
+        "Will generate awesome posts for social media!",
+        title="Share",
+        border_style="cyan"
+    ))