gitgotchi 0.1.0__py3-none-any.whl

src/db/state_manager.py

@@ -0,0 +1,277 @@
+"""State management for pet persistence."""
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from sqlalchemy.orm import Session
+
+from src.db.models import (
+    CommitHistory,
+    PetState,
+    StoryMemory,
+    get_engine,
+    init_db,
+)
+from src.pet.states import PetForm, PetMood, PetStats
+
+
+class StateManager:
+    """Manages pet state persistence and retrieval."""
+
+    def __init__(self, db_path: str = ".gitgotchi/state.db") -> None:
+        """Initialize state manager.
+
+        Args:
+            db_path: Path to SQLite database file
+        """
+        self.db_path = db_path
+        self._ensure_db_exists()
+        self.engine = get_engine(db_path)
+
+    def _ensure_db_exists(self) -> None:
+        """Ensure database directory and schema exist."""
+        db_dir = Path(self.db_path).parent
+        db_dir.mkdir(parents=True, exist_ok=True)
+        init_db(self.db_path)
+
+    def get_pet_state(self) -> PetStats:
+        """Load current pet state from database.
+
+        Returns:
+            PetStats instance with current state
+        """
+        with Session(self.engine) as session:
+            pet_state = session.query(PetState).first()
+
+            if not pet_state:
+                # Create initial state
+                pet_state = PetState()
+                session.add(pet_state)
+                session.commit()
+
+            # Convert to PetStats
+            stats = PetStats()
+            stats.pet_name = pet_state.pet_name
+            stats.total_commits = pet_state.total_commits
+            stats.lines_added = pet_state.lines_added
+            stats.lines_deleted = pet_state.lines_deleted
+            stats.merge_conflicts = pet_state.merge_conflicts
+            stats.reverts = pet_state.reverts
+            stats.quality_score = pet_state.quality_score
+            stats.evolution_points = pet_state.evolution_points
+            stats.friend_level = pet_state.friend_level
+            stats.last_fed = pet_state.last_fed
+            stats.current_mood = PetMood(pet_state.current_mood)
+            stats.current_form = PetForm(pet_state.current_form)
+
+            return stats
+
+    def save_pet_state(self, stats: PetStats) -> None:
+        """Save pet state to database.
+
+        Args:
+            stats: PetStats instance to persist
+        """
+        with Session(self.engine) as session:
+            pet_state = session.query(PetState).first()
+
+            if not pet_state:
+                pet_state = PetState()
+                session.add(pet_state)
+
+            pet_state.pet_name = stats.pet_name
+            pet_state.total_commits = stats.total_commits
+            pet_state.lines_added = stats.lines_added
+            pet_state.lines_deleted = stats.lines_deleted
+            pet_state.merge_conflicts = stats.merge_conflicts
+            pet_state.reverts = stats.reverts
+            pet_state.quality_score = stats.quality_score
+            pet_state.evolution_points = stats.evolution_points
+            pet_state.friend_level = stats.friend_level
+            pet_state.last_fed = stats.last_fed
+            pet_state.current_mood = stats.current_mood.value
+            pet_state.current_form = stats.current_form.value
+            pet_state.updated_at = datetime.now()
+
+            session.commit()
+
+    def log_commit(
+        self,
+        commit_hash: str,
+        author: str,
+        message: str,
+        timestamp: datetime,
+        lines_added: int = 0,
+        lines_deleted: int = 0,
+        files_changed: int = 0,
+        is_merge: bool = False,
+        is_revert: bool = False,
+        quality_impact: float = 0.0,
+    ) -> None:
+        """Log a commit to history.
+
+        Args:
+            commit_hash: Git commit SHA
+            author: Commit author
+            message: Commit message
+            timestamp: Commit timestamp
+            lines_added: Lines added in commit
+            lines_deleted: Lines deleted in commit
+            files_changed: Number of files changed
+            is_merge: Whether this is a merge commit
+            is_revert: Whether this is a revert commit
+            quality_impact: Impact on quality score
+        """
+        with Session(self.engine) as session:
+            # Check if already logged
+            existing = (
+                session.query(CommitHistory)
+                .filter_by(commit_hash=commit_hash)
+                .first()
+            )
+
+            if existing:
+                return
+
+            commit = CommitHistory(
+                commit_hash=commit_hash,
+                author=author,
+                message=message,
+                timestamp=timestamp,
+                lines_added=lines_added,
+                lines_deleted=lines_deleted,
+                files_changed=files_changed,
+                is_merge=is_merge,
+                is_revert=is_revert,
+                quality_impact=quality_impact,
+            )
+            session.add(commit)
+            session.commit()
+
+    def save_story(
+        self,
+        commit_hash: str,
+        story_text: str,
+        story_type: str,
+        pet_form: PetForm,
+        pet_mood: PetMood,
+        tokens_used: Optional[int] = None,
+    ) -> None:
+        """Save generated story to cache.
+
+        Args:
+            commit_hash: Associated commit hash
+            story_text: Generated story content
+            story_type: Type of story
+            pet_form: Pet form at time of generation
+            pet_mood: Pet mood at time of generation
+            tokens_used: Number of tokens used
+        """
+        with Session(self.engine) as session:
+            story = StoryMemory(
+                commit_hash=commit_hash,
+                story_text=story_text,
+                story_type=story_type,
+                pet_form_at_time=pet_form.value,
+                pet_mood_at_time=pet_mood.value,
+                tokens_used=tokens_used,
+            )
+            session.add(story)
+            session.commit()
+
+    def get_story(self, commit_hash: str) -> Optional[str]:
+        """Retrieve cached story for a commit.
+
+        Args:
+            commit_hash: Git commit SHA
+
+        Returns:
+            Story text if cached, None otherwise
+        """
+        with Session(self.engine) as session:
+            story = (
+                session.query(StoryMemory)
+                .filter_by(commit_hash=commit_hash)
+                .first()
+            )
+            return story.story_text if story else None
+
+    def process_commit_event(
+        self,
+        commit_hash: str,
+        author: str,
+        message: str,
+        timestamp: datetime,
+        lines_added: int = 0,
+        lines_deleted: int = 0,
+        files_changed: int = 0,
+        is_merge: bool = False,
+        is_revert: bool = False,
+    ) -> PetStats:
+        """Process a commit event and update pet state.
+
+        Args:
+            commit_hash: Git commit SHA
+            author: Commit author
+            message: Commit message
+            timestamp: Commit timestamp
+            lines_added: Lines added in commit
+            lines_deleted: Lines deleted in commit
+            files_changed: Number of files changed
+            is_merge: Whether this is a merge commit
+            is_revert: Whether this is a revert commit
+
+        Returns:
+            Updated PetStats
+        """
+        # Load current state
+        stats = self.get_pet_state()
+
+        # Update stats
+        stats.total_commits += 1
+        stats.lines_added += lines_added
+        stats.lines_deleted += lines_deleted
+
+        if is_merge:
+            stats.merge_conflicts += 1
+
+        if is_revert:
+            stats.reverts += 1
+
+        # Feed the pet (updates last_fed and mood)
+        stats.feed()
+
+        # Update form based on new stats
+        stats.update_form()
+
+        # Calculate quality impact
+        quality_impact = 0.0
+        if is_revert:
+            quality_impact = -5.0
+        elif is_merge:
+            quality_impact = -2.0
+        else:
+            quality_impact = 1.0
+
+        stats.quality_score = max(
+            0.0, min(100.0, stats.quality_score + quality_impact)
+        )
+
+        # Log commit
+        self.log_commit(
+            commit_hash=commit_hash,
+            author=author,
+            message=message,
+            timestamp=timestamp,
+            lines_added=lines_added,
+            lines_deleted=lines_deleted,
+            files_changed=files_changed,
+            is_merge=is_merge,
+            is_revert=is_revert,
+            quality_impact=quality_impact,
+        )
+
+        # Save updated state
+        self.save_pet_state(stats)
+
+        return stats

src/hooks/__init__.py

@@ -0,0 +1 @@
+"""Git hooks module."""

src/hooks/installer.py

@@ -0,0 +1,128 @@
+"""Hook installation."""
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+from git import InvalidGitRepositoryError, Repo
+from rich.console import Console
+
+console = Console()
+
+
+def find_git_root() -> Optional[Path]:
+    """Find git repository root.
+
+    Returns:
+        Path to git root, or None if not in a git repo
+    """
+    try:
+        repo = Repo(".", search_parent_directories=True)
+        return Path(repo.git_dir).parent
+    except InvalidGitRepositoryError:
+        return None
+
+
+def install_hooks() -> bool:
+    """Install git hooks for GitGotchi.
+
+    Returns:
+        True if successful, False otherwise
+    """
+    git_root = find_git_root()
+
+    if not git_root:
+        console.print(
+            "[red]👻 No git repository found! Initialize git first.[/red]"
+        )
+        return False
+
+    hooks_dir = git_root / ".git" / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    post_commit_path = hooks_dir / "post-commit"
+
+    # GitGotchi hook content
+    python_path = sys.executable.replace("\\", "/")
+    gitgotchi_hook = f"""#!/bin/sh
+# GitGotchi post-commit hook
+"{python_path}" -m src.hooks.post_commit
+"""
+
+    # Check if hook already exists
+    if post_commit_path.exists():
+        existing_content = post_commit_path.read_text()
+
+        if "GitGotchi" in existing_content:
+            console.print("[yellow]👻 GitGotchi hooks already installed![/yellow]")
+            return True
+
+        # Append to existing hook
+        console.print(
+            "[yellow]⚠️  Existing post-commit hook found. Appending GitGotchi...[/yellow]"
+        )
+        with open(post_commit_path, "a") as f:
+            f.write("\n" + gitgotchi_hook)
+    else:
+        # Create new hook
+        post_commit_path.write_text(gitgotchi_hook)
+
+    # Make executable
+    post_commit_path.chmod(0o755)
+
+    console.print("[green]✨ GitGotchi hooks installed successfully![/green]")
+    console.print(f"[dim]Hook location: {post_commit_path}[/dim]")
+
+    return True
+
+
+def uninstall_hooks() -> bool:
+    """Uninstall GitGotchi git hooks.
+
+    Returns:
+        True if successful, False otherwise
+    """
+    git_root = find_git_root()
+
+    if not git_root:
+        console.print("[red]👻 No git repository found![/red]")
+        return False
+
+    post_commit_path = git_root / ".git" / "hooks" / "post-commit"
+
+    if not post_commit_path.exists():
+        console.print("[yellow]👻 No hooks found to uninstall.[/yellow]")
+        return True
+
+    existing_content = post_commit_path.read_text()
+
+    if "GitGotchi" not in existing_content:
+        console.print("[yellow]👻 GitGotchi hooks not found.[/yellow]")
+        return True
+
+    # Remove GitGotchi section
+    lines = existing_content.split("\n")
+    filtered_lines = []
+    skip_next = False
+
+    for line in lines:
+        if "GitGotchi" in line:
+            skip_next = True
+            continue
+        if skip_next and line.strip().startswith("python"):
+            skip_next = False
+            continue
+        filtered_lines.append(line)
+
+    new_content = "\n".join(filtered_lines).strip()
+
+    if new_content and new_content != "#!/bin/sh":
+        # Other hooks remain, update file
+        post_commit_path.write_text(new_content)
+        console.print("[green]✨ GitGotchi hooks removed.[/green]")
+    else:
+        # No other hooks, delete file
+        post_commit_path.unlink()
+        console.print("[green]✨ GitGotchi hooks removed (file deleted).[/green]")
+
+    return True

src/hooks/post_commit.py

@@ -0,0 +1,70 @@
+"""Git hook handlers."""
+from datetime import datetime
+from pathlib import Path
+
+from git import Repo
+
+from src.db.state_manager import StateManager
+from src.pet.renderer import render_commit_response, render_error, render_evolution
+
+
+def handle_post_commit() -> None:
+    """Handle post-commit hook."""
+    try:
+        # Get git repo
+        repo = Repo(".", search_parent_directories=True)
+        git_root = Path(repo.git_dir).parent
+
+        # Get latest commit
+        commit = repo.head.commit
+
+        # Parse commit metadata
+        commit_hash = commit.hexsha
+        author = str(commit.author)
+        message = commit.message
+        timestamp = datetime.fromtimestamp(commit.committed_date)
+
+        # Calculate stats
+        stats = commit.stats.total
+        lines_added = stats.get("insertions", 0)
+        lines_deleted = stats.get("deletions", 0)
+        files_changed = stats.get("files", 0)
+
+        # Check for merge/revert
+        is_merge = len(commit.parents) > 1
+        is_revert = message.lower().startswith("revert")
+
+        # Initialize state manager
+        db_path = git_root / ".gitgotchi" / "state.db"
+        state_manager = StateManager(str(db_path))
+
+        # Get old form for evolution check
+        old_stats = state_manager.get_pet_state()
+        old_form = old_stats.current_form
+
+        # Process commit event
+        new_stats = state_manager.process_commit_event(
+            commit_hash=commit_hash,
+            author=author,
+            message=message,
+            timestamp=timestamp,
+            lines_added=lines_added,
+            lines_deleted=lines_deleted,
+            files_changed=files_changed,
+            is_merge=is_merge,
+            is_revert=is_revert,
+        )
+
+        # Check for evolution
+        if new_stats.current_form != old_form:
+            render_evolution(old_form, new_stats.current_form)
+
+        # Render commit response
+        render_commit_response(new_stats, lines_added, lines_deleted)
+
+    except Exception as e:
+        render_error(f"Failed to process commit: {str(e)}")
+
+
+if __name__ == "__main__":
+    handle_post_commit()

src/pet/__init__.py

@@ -0,0 +1 @@
+"""Pet module."""

src/pet/evolution.py

@@ -0,0 +1,5 @@
+"""Pet evolution logic."""
+
+def evolve_pet():
+    """Handle pet evolution."""
+    pass

src/pet/renderer.py

@@ -0,0 +1,208 @@
+"""ASCII art & terminal UI."""
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from src.pet.states import PetForm, PetMood, PetStats
+
+# Force UTF-8 encoding for Windows
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8")
+
+console = Console(force_terminal=True, legacy_windows=False)
+
+# ASCII art for each pet form
+PET_SPRITES = {
+    PetForm.EGG: """
+    .-""-.
+   /      \\
+  |  o  o  |
+   \\  __  /
+    '-..-'
+""",
+    PetForm.GHOST: """
+    .-.
+   (o.o)
+    |=|
+   __|__
+  /     \\
+ | () () |
+  \\     /
+   `---'
+""",
+    PetForm.ANGEL: """
+    \\|/
+  .-'o'-.
+ /  \\_/  \\
+|  (o.o)  |
+ \\   |   /
+  '--|--'
+     |
+    / \\
+""",
+    PetForm.DEMON: """
+   /\\ /\\
+  (  o.o )
+   > ^ <
+  /|   |\\
+ (_|   |_)
+   |   |
+  /|   |\\
+""",
+    PetForm.ZOMBIE: """
+    .---.
+   /x   x\\
+  |  ___  |
+   \\ \\_/ /
+    |||||
+   /|   |\\
+  / |   | \\
+""",
+    PetForm.WRAITH: """
+    ___
+  .'   '.
+ /  o o  \\
+|    ^    |
+ \\  \\_/  /
+  '.___.'
+   |||||
+  ~~~~~~~
+""",
+}
+
+# Mood-based colors (Stardew Valley inspired pastels)
+MOOD_COLORS = {
+    PetMood.JOYFUL: "bright_yellow",  # Gold sparkles
+    PetMood.HAPPY: "cyan",  # Sky blue
+    PetMood.CONTENT: "bright_white",  # Soft white
+    PetMood.HUNGRY: "yellow",  # Gentle yellow
+    PetMood.TIRED: "magenta",  # Lavender
+    PetMood.SLEEPING: "blue",  # Soft blue
+}
+
+# Mood messages (friendly and encouraging)
+MOOD_MESSAGES = {
+    PetMood.JOYFUL: "✨ Your friend is glowing with happiness! ✨",
+    PetMood.HAPPY: "💛 Your companion is content and cheerful!",
+    PetMood.CONTENT: "🌟 Your friend is peaceful and happy",
+    PetMood.HUNGRY: "🍂 Your friend misses you... time for a commit?",
+    PetMood.TIRED: "💤 Your companion is getting sleepy...",
+    PetMood.SLEEPING: "😴 Zzz... Your friend is dreaming of code...",
+}
+
+
+def render_pet(stats: PetStats, show_stats: bool = True) -> None:
+    """Render pet to terminal with haunted styling.
+
+    Args:
+        stats: Current pet statistics
+        show_stats: Whether to show detailed stats
+    """
+    sprite = PET_SPRITES.get(stats.current_form, PET_SPRITES[PetForm.GHOST])
+    color = MOOD_COLORS.get(stats.current_mood, "white")
+    mood_msg = MOOD_MESSAGES.get(stats.current_mood, "")
+
+    # Create styled sprite
+    styled_sprite = Text(sprite, style=color)
+
+    # Build title
+    title = f"👻 {stats.current_form.value.upper()} - {stats.current_mood.value}"
+
+    # Build subtitle with mood message
+    subtitle = Text(mood_msg, style=color)
+
+    # Create panel content
+    content = styled_sprite
+
+    if show_stats:
+        stats_text = Text("\n")
+        stats_text.append(f"💀 Commits: {stats.total_commits}\n", style="cyan")
+        stats_text.append(f"✨ Quality: {stats.quality_score:.1f}/100\n", style="cyan")
+        stats_text.append(f"➕ Lines Added: {stats.lines_added}\n", style="green")
+        stats_text.append(f"➖ Lines Deleted: {stats.lines_deleted}\n", style="red")
+        stats_text.append(f"⚔️  Conflicts: {stats.merge_conflicts}\n", style="yellow")
+        stats_text.append(f"🔄 Reverts: {stats.reverts}\n", style="magenta")
+
+        content = Text.assemble(styled_sprite, stats_text)
+
+    # Render panel
+    panel = Panel(
+        content,
+        title=title,
+        subtitle=subtitle,
+        border_style=color,
+        padding=(1, 2),
+    )
+
+    console.print(panel)
+
+
+def render_evolution(old_form: PetForm, new_form: PetForm) -> None:
+    """Render evolution animation.
+
+    Args:
+        old_form: Previous pet form
+        new_form: New pet form
+    """
+    console.print("\n")
+    console.print("✨" * 20, style="bright_yellow")
+    console.print(
+        f"[bold bright_yellow]Something magical is happening! ✨[/bold bright_yellow]"
+    )
+    console.print(
+        f"[bold bright_cyan]Your {old_form.value} is evolving into a {new_form.value}! 🎉[/bold bright_cyan]"
+    )
+    console.print("✨" * 20, style="bright_yellow")
+    console.print("\n")
+
+
+def render_commit_response(
+    stats: PetStats, lines_added: int, lines_deleted: int
+) -> None:
+    """Render response to a commit.
+
+    Args:
+        stats: Updated pet statistics
+        lines_added: Lines added in commit
+        lines_deleted: Lines deleted in commit
+    """
+    console.print("\n")
+
+    # Friendly commit messages
+    messages = [
+        "Your friend is happy! Great commit! ✨",
+        "Yay! Your companion grows stronger! 🌟",
+        "Another step forward together! 💛",
+        "Your friend appreciates your hard work! 🍂",
+        "Wonderful! Your bond deepens! ❤️",
+    ]
+
+    import random
+
+    msg = random.choice(messages)
+    console.print(f"[cyan]{msg}[/cyan]")
+
+    # Show quick stats
+    console.print(
+        f"[green]+{lines_added}[/green] [red]-{lines_deleted}[/red] lines"
+    )
+
+    # Render pet
+    render_pet(stats, show_stats=False)
+
+
+def render_error(message: str) -> None:
+    """Render error with friendly flavor.
+
+    Args:
+        message: Error message
+    """
+    console.print(
+        Panel(
+            f"[bold yellow]🌙 Oh no! Something went wrong...[/bold yellow]\n\n{message}",
+            border_style="yellow",
+            title="⚠️  Oops",
+        )
+    )