get2work 0.1.0__tar.gz

get2work-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+venv/
+__pycache__/
+*.pyc
+.get2work/
+*.egg-info/
+dist/
+build/

get2work-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: get2work
+Version: 0.1.0
+Summary: The Python library that makes you actually work
+Requires-Python: >=3.9
+Requires-Dist: anthropic>=0.20.0
+Requires-Dist: apscheduler>=3.10.0
+Requires-Dist: gitpython>=3.1.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: pygame>=2.5.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: watchdog>=3.0.0
+Description-Content-Type: text/markdown
+
+# get2work 
+
+> The Python library that makes you actually work.
+
+[![PyPI version](https://badge.fury.io/py/get2work.svg)](https://badge.fury.io/py/get2work)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+get2work is a CLI tool that gamifies your coding productivity. It celebrates your commits, roasts your git history, shames you when you're slacking, and makes you actually ship things.
+
+## Features
+
+-  **Commit celebrations** — animations and sounds every time you commit
+-  **Level system** — 8 levels from "Hello World Survivor" to "Linus Would Be Proud"
+-  **Streak tracking** — daily commit streaks
+-  **Shame notifications** — get roasted if you haven't committed today
+-  **AI roasts** — your commit history analyzed and destroyed by AI
+-  **Vibe check** — AI mental health diagnosis based on your commits
+-  **Peer pressure** — see what other devs are shipping and feel bad
+-  **Pomodoro timer** — focus sessions that count toward your level
+-  **Accountability receipt** — daily summary of what you actually did
+-  **Code funeral** — deleting 100+ lines triggers a funeral 
+-  **Git blame but personal** — AI roasts each commit individually
+
+##  Installation
+
+```bash
+pip install get2work
+```
+
+##  Quick Start
+
+```bash
+# Install the git hook in your repo (do this once per project)
+get2work install
+
+# Check your level and stats
+get2work status
+
+# Now just commit normally and watch the magic happen
+git commit -m "feat: add something cool"
+```
+
+##  Commands
+
+| Command | Description |
+|---|---|
+| `get2work install` | Install git hook in current repo |
+| `get2work status` | Your level, streak, and stats |
+| `get2work roast` | Get your commits roasted by AI  |
+| `get2work vibe` | AI mental health diagnosis  |
+| `get2work blame` | Git blame but make it personal  |
+| `get2work peer <username>` | Stalk a dev on GitHub  |
+| `get2work randompeer` | Random dev from the internet  |
+| `get2work pomodoro` | Start a pomodoro timer  |
+| `get2work shame` | Check if you deserve to be shamed  |
+| `get2work receipt` | Your accountability receipt  |
+| `get2work start` | Start background watcher |
+
+##  AI Features (Optional)
+
+The `roast`, `vibe`, and `blame` commands use AI for better results. Without an API key they fall back to hardcoded funny responses.
+
+To enable AI roasts set your OpenAI API key:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+## Custom Sounds
+
+Replace default sounds with your own by setting environment variables:
+
+```bash
+export GET2WORK_SOUND_CELEBRATE="/path/to/your/sound.mp3"
+export GET2WORK_SOUND_FUNERAL="/path/to/funeral.mp3"
+export GET2WORK_SOUND_SHAME="/path/to/shame.mp3"
+export GET2WORK_SOUND_LEVELUP="/path/to/levelup.mp3"
+```
+
+## Level System
+
+| Level | Name | Commits needed |
+|---|---|---|
+| 1 | Hello World Survivor | 0 |
+| 2 | Tutorial Finisher | 10 |
+| 3 | Functional but Confused | 30 |
+| 4 | It Works Don't Touch It | 60 |
+| 5 | Commits with Confidence (wrongly) | 100 |
+| 6 | git push --force and it worked | 200 |
+| 7 | The Last Line of Defense | 400 |
+| 8 | Linus Would Be Proud | 700 |
+
+## Tutorial
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](COLAB_LINK_HERE)
+
+## Docker
+
+```bash
+docker build -t get2work .
+docker run get2work
+```

get2work-0.1.0/README.md

@@ -0,0 +1,102 @@
+# get2work 
+
+> The Python library that makes you actually work.
+
+[![PyPI version](https://badge.fury.io/py/get2work.svg)](https://badge.fury.io/py/get2work)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+get2work is a CLI tool that gamifies your coding productivity. It celebrates your commits, roasts your git history, shames you when you're slacking, and makes you actually ship things.
+
+## Features
+
+-  **Commit celebrations** — animations and sounds every time you commit
+-  **Level system** — 8 levels from "Hello World Survivor" to "Linus Would Be Proud"
+-  **Streak tracking** — daily commit streaks
+-  **Shame notifications** — get roasted if you haven't committed today
+-  **AI roasts** — your commit history analyzed and destroyed by AI
+-  **Vibe check** — AI mental health diagnosis based on your commits
+-  **Peer pressure** — see what other devs are shipping and feel bad
+-  **Pomodoro timer** — focus sessions that count toward your level
+-  **Accountability receipt** — daily summary of what you actually did
+-  **Code funeral** — deleting 100+ lines triggers a funeral 
+-  **Git blame but personal** — AI roasts each commit individually
+
+##  Installation
+
+```bash
+pip install get2work
+```
+
+##  Quick Start
+
+```bash
+# Install the git hook in your repo (do this once per project)
+get2work install
+
+# Check your level and stats
+get2work status
+
+# Now just commit normally and watch the magic happen
+git commit -m "feat: add something cool"
+```
+
+##  Commands
+
+| Command | Description |
+|---|---|
+| `get2work install` | Install git hook in current repo |
+| `get2work status` | Your level, streak, and stats |
+| `get2work roast` | Get your commits roasted by AI  |
+| `get2work vibe` | AI mental health diagnosis  |
+| `get2work blame` | Git blame but make it personal  |
+| `get2work peer <username>` | Stalk a dev on GitHub  |
+| `get2work randompeer` | Random dev from the internet  |
+| `get2work pomodoro` | Start a pomodoro timer  |
+| `get2work shame` | Check if you deserve to be shamed  |
+| `get2work receipt` | Your accountability receipt  |
+| `get2work start` | Start background watcher |
+
+##  AI Features (Optional)
+
+The `roast`, `vibe`, and `blame` commands use AI for better results. Without an API key they fall back to hardcoded funny responses.
+
+To enable AI roasts set your OpenAI API key:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+## Custom Sounds
+
+Replace default sounds with your own by setting environment variables:
+
+```bash
+export GET2WORK_SOUND_CELEBRATE="/path/to/your/sound.mp3"
+export GET2WORK_SOUND_FUNERAL="/path/to/funeral.mp3"
+export GET2WORK_SOUND_SHAME="/path/to/shame.mp3"
+export GET2WORK_SOUND_LEVELUP="/path/to/levelup.mp3"
+```
+
+## Level System
+
+| Level | Name | Commits needed |
+|---|---|---|
+| 1 | Hello World Survivor | 0 |
+| 2 | Tutorial Finisher | 10 |
+| 3 | Functional but Confused | 30 |
+| 4 | It Works Don't Touch It | 60 |
+| 5 | Commits with Confidence (wrongly) | 100 |
+| 6 | git push --force and it worked | 200 |
+| 7 | The Last Line of Defense | 400 |
+| 8 | Linus Would Be Proud | 700 |
+
+## Tutorial
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](COLAB_LINK_HERE)
+
+## Docker
+
+```bash
+docker build -t get2work .
+docker run get2work
+```

get2work-0.1.0/get2work/__init__.py

@@ -0,0 +1 @@
+from get2work import cli

get2work-0.1.0/get2work/celebrate.py

@@ -0,0 +1,114 @@
+import time
+import random
+import os
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+SOUNDS_DIR = Path(__file__).parent.parent / "sounds"
+
+CUSTOM_SOUNDS = {
+    "celebrate": os.environ.get("GET2WORK_SOUND_CELEBRATE"),
+    "funeral": os.environ.get("GET2WORK_SOUND_FUNERAL"),
+    "shame": os.environ.get("GET2WORK_SOUND_SHAME"),
+    "levelup": os.environ.get("GET2WORK_SOUND_LEVELUP"),
+    "success": os.environ.get("GET2WORK_SOUND_SUCCESS"),
+    "error": os.environ.get("GET2WORK_SOUND_ERROR"),
+}
+
+DEFAULT_SOUNDS = {
+    "celebrate": SOUNDS_DIR / "celebrate.mp3",
+    "funeral":   SOUNDS_DIR / "funeral.mp3",
+    "shame":     SOUNDS_DIR / "shame.mp3",
+    "levelup":   SOUNDS_DIR / "levelup.mp3",
+    "success":   SOUNDS_DIR / "success.mp3",
+    "error":     SOUNDS_DIR / "error.mp3",
+}
+
+COMMIT_MESSAGES = [
+    "YOOOO YOU ACTUALLY COMMITTED 🔥",
+    "look at you being productive omg",
+    "a commit?? in THIS economy??",
+    "slay bestie, that's a commit",
+    "the git history thanks you",
+    "ok ok ok we're doing this 💪",
+    "committed and not quitting, respect",
+    "your future self says thanks... maybe",
+]
+
+LEVELUP_MESSAGES = [
+    "YOU LEVELED UP ARE YOU KIDDING ME",
+    "bro is actually getting good at this",
+    "the grindset is REAL",
+    "level up achieved, touch grass later",
+    "ok we are NOT the same anymore 👑",
+]
+
+FUNERAL_MESSAGES = [
+    "rip to those lines of code 💀",
+    "they didn't make it...",
+    "gone but not forgotten (they were probably bad anyway)",
+    "a moment of silence for your deleted code",
+    "the codebase is lighter now. emotionally too.",
+]
+
+def play_sound(name: str):
+    try:
+        import pygame
+        custom = CUSTOM_SOUNDS.get(name)
+        path = Path(custom) if custom else DEFAULT_SOUNDS.get(name)
+
+        if not path or not path.exists():
+            return
+
+        pygame.mixer.init()
+        pygame.mixer.music.load(str(path))
+        pygame.mixer.music.play()
+        time.sleep(1.5)
+        pygame.mixer.quit()
+    except Exception:
+        pass
+
+def celebrate_commit():
+    colors = ["red", "yellow", "green", "cyan", "magenta", "blue"]
+    msg = random.choice(COMMIT_MESSAGES)
+
+    play_sound("celebrate")
+    console.print()
+    for i in range(3):
+        color = random.choice(colors)
+        console.print(f"  {'🎉' * (i+2)}  {msg}  {'🎉' * (i+2)}", style=f"bold {color}")
+        time.sleep(0.15)
+    console.print()
+
+def celebrate_levelup(level_name: str):
+    msg = random.choice(LEVELUP_MESSAGES)
+
+    play_sound("levelup")
+    console.print()
+    console.rule("[bold yellow]LEVEL UP[/bold yellow]")
+    console.print(f"\n  ⚡ [bold yellow]{msg}[/bold yellow]")
+    console.print(f"  👑 [bold cyan]You are now: {level_name}[/bold cyan]\n")
+    console.rule("[bold yellow]LEVEL UP[/bold yellow]")
+    console.print()
+
+def code_funeral():
+    msg = random.choice(FUNERAL_MESSAGES)
+
+    play_sound("funeral")
+    console.print()
+    console.rule("[bold red]💀 CODE FUNERAL 💀[/bold red]")
+    console.print(f"\n  [bold red]{msg}[/bold red]")
+    console.print("  [dim]deleted: yes. missed: debatable.[/dim]\n")
+    console.rule("[bold red]💀 💀 💀[/bold red]")
+    console.print()
+
+def play_success():
+    play_sound("success")
+
+def play_error():
+    play_sound("error")
+
+def play_shame():
+    play_sound("shame")

get2work-0.1.0/get2work/cli.py

@@ -0,0 +1,227 @@
+import typer
+from rich.console import Console
+from datetime import date
+
+app = typer.Typer(help="get2work — stop scrolling, start coding")
+console = Console()
+
+@app.command()
+def install():
+    """Install get2work hook in your repo 🔧"""
+    import os
+    import stat
+    from pathlib import Path
+
+    try:
+        import git
+        repo = git.Repo(".", search_parent_directories=True)
+        hooks_dir = Path(repo.git_dir) / "hooks"
+        hook_path = hooks_dir / "post-commit"
+
+        hook_script = """#!/bin/sh
+get2work celebrate-commit
+"""
+        with open(hook_path, "w") as f:
+            f.write(hook_script)
+
+        st = os.stat(hook_path)
+        os.chmod(hook_path, st.st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+        console.print("\n  [bold green]✅ get2work installed![/bold green]")
+        console.print("  [dim]now every commit will be celebrated 🎉[/dim]\n")
+
+    except Exception as e:
+        console.print(f"\n  [bold red]❌ error: {e}[/bold red]\n")
+
+@app.command()
+def celebrate_commit():
+    """Triggered automatically on commit 🎉"""
+    from get2work.storage import load, increment
+    from get2work.levels import check_levelup
+    from get2work.celebrate import celebrate_commit as do_celebrate, celebrate_levelup, code_funeral
+    import git
+
+    try:
+        repo = git.Repo(".", search_parent_directories=True)
+        commits = list(repo.iter_commits(max_count=1))
+        if commits:
+            commit = commits[0]
+            try:
+                stats = commit.stats.total
+                lines_added = stats.get("insertions", 0)
+                lines_deleted = stats.get("deletions", 0)
+            except Exception:
+                lines_added = 0
+                lines_deleted = 0
+
+            increment("commits")
+            increment("total_lines_added", lines_added)
+            increment("total_lines_deleted", lines_deleted)
+
+            from get2work.watcher import update_streak
+            update_streak()
+
+            do_celebrate()
+
+            if lines_deleted > 100:
+                code_funeral()
+
+            leveled_up, level_name = check_levelup()
+            if leveled_up:
+                celebrate_levelup(level_name)
+
+    except Exception as e:
+        pass
+
+@app.command()
+def status():
+    """Check your level, streak and stats"""
+    from get2work.storage import load
+    from get2work.levels import get_level, get_next_level
+
+    data = load()
+    commits = data["commits"]
+    streak = data["streak"]
+    level_num, level_name = get_level(commits)
+    next_level = get_next_level(commits)
+
+    console.print()
+    console.rule("[bold cyan]get2work[/bold cyan]")
+    console.print(f"\n  👾 [bold cyan]Level {level_num}[/bold cyan] — [yellow]{level_name}[/yellow]")
+    console.print(f"  🔥 [bold]Streak:[/bold] {streak} days")
+    console.print(f"  📦 [bold]Total commits:[/bold] {commits}")
+    console.print(f"  🍅 [bold]Pomodoros:[/bold] {data['pomodoros_completed']}")
+    console.print(f"  👀 [bold]Distractions caught:[/bold] {data['distractions_caught']}")
+
+    if next_level:
+        needed = next_level[0] - commits
+        console.print(f"\n  ⚡ [dim]{needed} commits until [bold]{next_level[1]}[/bold][/dim]")
+
+    console.print()
+
+@app.command()
+def roast():
+    """Get your commits roasted 🔥"""
+    from get2work.roast import roast_my_commits
+    roast_my_commits()
+    
+@app.command()
+def blame():
+    """Git blame but make it personal 🔍"""
+    from get2work.roast import git_blame_personal
+    git_blame_personal()    
+
+@app.command()
+def vibe():
+    """Get a mental health diagnosis based on your commits 🧠"""
+    from get2work.roast import vibe_check
+    vibe_check()
+    
+@app.command()
+def peer(username: str = typer.Argument(..., help="GitHub username to stalk 👀")):
+    """See what others are committing and feel bad about yourself 👀"""
+    from get2work.peer_pressure import peer_pressure
+    peer_pressure(username)    
+    
+@app.command()
+def randompeer():
+    """Get shamed by a random dev from the internet 🎲"""
+    from get2work.peer_pressure import random_peer
+    random_peer()
+    
+@app.command()
+def distraction():
+    """Check if you're slacking right now 👀"""
+    from get2work.distraction import distraction_check
+    caught = distraction_check()
+    if not caught:
+        console.print("\n  [bold green]✅ no distractions detected[/bold green]")
+        console.print("  [dim]surprisingly productive. respect.[/dim]\n")
+        
+        
+@app.command()
+def shame():
+    """Check if you deserve to be shamed right now 😤"""
+    from get2work.watcher import CommitWatcher
+    watcher = CommitWatcher()
+    watcher.check_shame()
+
+@app.command()
+def start():
+    """Start get2work in background — watches commits and distractions 👀"""
+    import threading
+    import time
+    from get2work.watcher import CommitWatcher
+    from get2work.distraction import start_distraction_watcher
+
+    console.print("\n  [bold green]get2work is watching you 👀[/bold green]")
+    console.print("  [dim]commit something or face the consequences[/dim]\n")
+
+    watcher = CommitWatcher()
+
+    def shame_loop():
+        while True:
+            time.sleep(60 * 30)
+            watcher.check_shame()
+
+    def distraction_loop():
+        start_distraction_watcher(interval_seconds=120)
+
+    t1 = threading.Thread(target=shame_loop, daemon=True)
+    t2 = threading.Thread(target=distraction_loop, daemon=True)
+    t1.start()
+    t2.start()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        console.print("\n  [dim]get2work stopped. go touch grass.[/dim]\n")  
+        
+@app.command()
+def pomodoro(minutes: int = typer.Option(25, help="Pomodoro duration in minutes")):
+    """Start a pomodoro timer 🍅"""
+    import time
+    from get2work.storage import increment
+
+    console.print(f"\n  🍅 [bold green]Pomodoro started — {minutes} minutes[/bold green]")
+    console.print("  [dim]focus mode activated, no excuses[/dim]\n")
+
+    total_seconds = minutes * 60
+    with console.status("[green]working...[/green]") as status:
+        for remaining in range(total_seconds, 0, -1):
+            mins, secs = divmod(remaining, 60)
+            status.update(f"[green]⏱ {mins:02d}:{secs:02d} remaining — stay focused[/green]")
+            time.sleep(1)
+
+    increment("pomodoros_completed")
+    console.print("\n  ✅ [bold green]POMODORO DONE![/bold green]")
+    console.print("  [dim]ok now you can touch grass for 5 minutes[/dim]\n")
+
+@app.command()
+def receipt():
+    """Get your accountability receipt for today 🧾"""
+    from get2work.storage import load
+    from get2work.levels import get_level
+    import datetime
+
+    data = load()
+    now = datetime.datetime.now()
+    level_num, level_name = get_level(data["commits"])
+
+    console.print()
+    console.rule("[bold white]🧾 ACCOUNTABILITY RECEIPT[/bold white]")
+    console.print(f"  [dim]{now.strftime('%Y-%m-%d %H:%M')}[/dim]\n")
+    console.print(f"  Level:          {level_name}")
+    console.print(f"  Commits:        {data['commits']}")
+    console.print(f"  Streak:         {data['streak']} days")
+    console.print(f"  Pomodoros:      {data['pomodoros_completed']}")
+    console.print(f"  Distractions:   {data['distractions_caught']}")
+    console.print(f"\n  [dim]Lines added:    {data['total_lines_added']}[/dim]")
+    console.print(f"  [dim]Lines deleted:  {data['total_lines_deleted']}[/dim]")
+    console.print()
+    console.rule("[bold white]thanks for coming to get2work[/bold white]")
+    console.print()
+
+if __name__ == "__main__":
+    app()

get2work-0.1.0/get2work/distraction.py

@@ -0,0 +1,74 @@
+import psutil
+import random
+from rich.console import Console
+from get2work.storage import increment
+from get2work.celebrate import play_shame
+
+console = Console()
+
+DISTRACTING_APPS = [
+    "netflix", "spotify", "discord", "telegram",
+    "whatsapp", "instagram", "tiktok", "youtube",
+    "twitch", "steam", "epicgames", "roblox",
+    "minecraft", "fortnite", "chess", "solitaire",
+    "slack",  "zoom", "teams",
+]
+
+DISTRACTING_URLS_KEYWORDS = [
+    "youtube", "netflix", "twitter", "instagram",
+    "tiktok", "reddit", "facebook", "twitch",
+    "memes", "buzzfeed", "9gag",
+]
+
+CAUGHT_MESSAGES = [
+    "bro really said 'just 5 minutes' 💀",
+    "the audacity. the AUDACITY.",
+    "we saw that. get back to work.",
+    "not you watching {app} instead of coding",
+    "your commits are not going to write themselves",
+    "caught in 4k. close it.",
+    "{app}?? really?? RIGHT NOW??",
+    "the repo is crying. {app} can wait.",
+    "ok so we're doing THIS instead of shipping features",
+    "distraction detected. shame incoming. 🚨",
+]
+
+def get_running_processes() -> list:
+    processes = []
+    try:
+        for proc in psutil.process_iter(['name']):
+            try:
+                name = proc.info['name'].lower()
+                processes.append(name)
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return processes
+
+def check_distractions() -> str | None:
+    processes = get_running_processes()
+    for proc in processes:
+        for app in DISTRACTING_APPS:
+            if app in proc:
+                return app
+    return None
+
+def distraction_check():
+    caught = check_distractions()
+    if caught:
+        increment("distractions_caught")
+        play_shame()
+
+        msg = random.choice(CAUGHT_MESSAGES).replace("{app}", caught)
+        console.print(f"\n  [bold red]🚨 DISTRACTION DETECTED[/bold red]")
+        console.print(f"  [red]{msg}[/red]\n")
+        return True
+    return False
+
+def start_distraction_watcher(interval_seconds: int = 120):
+    import time
+    console.print("  [dim]distraction detector active 👀[/dim]")
+    while True:
+        distraction_check()
+        time.sleep(interval_seconds)

get2work-0.1.0/get2work/levels.py

@@ -0,0 +1,37 @@
+from get2work.storage import load, save
+
+LEVELS = [
+    (0,   "Hello World Survivor"),
+    (10,  "Tutorial Finisher"),
+    (30,  "Functional but Confused"),
+    (60,  "It Works Don't Touch It"),
+    (100, "Commits with Confidence (wrongly)"),
+    (200, "git push --force and it worked"),
+    (400, "The Last Line of Defense"),
+    (700, "Linus Would Be Proud"),
+]
+
+def get_level(commits: int) -> tuple:
+    current = (1, LEVELS[0][1])
+    for i, (threshold, name) in enumerate(LEVELS):
+        if commits >= threshold:
+            current = (i + 1, name)
+    return current
+
+def get_next_level(commits: int) -> tuple | None:
+    for threshold, name in LEVELS:
+        if commits < threshold:
+            return (threshold, name)
+    return None
+
+def check_levelup() -> tuple:
+    data = load()
+    commits = data["commits"]
+    level_num, level_name = get_level(commits)
+    old_level = data.get("level", 1)
+
+    if level_num > old_level:
+        data["level"] = level_num
+        save(data)
+        return True, level_name
+    return False, level_name

get2work-0.1.0/get2work/peer_pressure.py

@@ -0,0 +1,123 @@
+import random
+import requests
+from rich.console import Console
+from datetime import datetime, timezone
+
+console = Console()
+
+SARCASTIC_COMMENTS = [
+    "and what are YOU doing with your life?",
+    "must be nice to actually commit things 👀",
+    "imagine being this productive. couldn't be you huh",
+    "they said 'i'll do it later' and then did it NOW",
+    "not you watching others work while you're here",
+    "the dedication... the consistency... the shame you should feel",
+    "ok but why are they built different tho",
+    "they woke up and chose violence (against procrastination)",
+    "this person has never heard of 'i'll do it tomorrow'",
+    "ratio'd by someone's commit history 💀",
+    "they're just like you but... productive",
+    "bro said 'ship it' and actually shipped it",
+]
+
+NO_COMMITS_COMMENTS = [
+    "even THEY took a day off. you have no excuse though.",
+    "ok they're resting. you should be coding.",
+    "slow day for them. not an excuse for you.",
+]
+
+RANDOM_USERNAMES = [
+    "antfu", "patak-dev", "sxzz",
+    "privatenumber", "jantimon", "nzakas",
+    "ljharb", "nicolo-ribaudo", "sheremet-va",
+    "yyx990803", "egoist", "pi0",
+    "unjs", "Rich-Harris", "sveltejs",
+]
+
+def get_recent_commits(username: str) -> list:
+    try:
+        url = f"https://api.github.com/users/{username}/events/public"
+        response = requests.get(url, timeout=3)
+        if response.status_code != 200:
+            return []
+
+        events = response.json()
+        commits = []
+        for event in events:
+            if event.get("type") == "PushEvent":
+                payload = event.get("payload", {})
+                repo = event.get("repo", {}).get("name", "unknown")
+                event_commits = payload.get("commits", [])
+                if event_commits:
+                    for commit in event_commits:
+                        msg = commit.get("message", "").split("\n")[0]
+                        if msg:
+                            commits.append({
+                                "message": msg,
+                                "repo": repo,
+                                "date": event.get("created_at", ""),
+                            })
+                else:
+                    commits.append({
+                        "message": "pushed some code 👀",
+                        "repo": repo,
+                        "date": event.get("created_at", ""),
+                    })
+            if len(commits) >= 5:
+                break
+        return commits
+
+    except Exception:
+        return []
+    
+def format_time_ago(date_str: str) -> str:
+    try:
+        dt = datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+        now = datetime.now(timezone.utc)
+        diff = now - dt
+        minutes = int(diff.total_seconds() / 60)
+
+        if minutes < 60:
+            return f"{minutes}m ago"
+        elif minutes < 1440:
+            return f"{minutes // 60}h ago"
+        else:
+            return f"{minutes // 1440}d ago"
+    except Exception:
+        return "recently"
+
+def _display_commits(username: str, commits: list):
+    if not commits:
+        comment = random.choice(NO_COMMITS_COMMENTS)
+        console.print(f"  [dim]no recent commits from {username}[/dim]")
+        console.print(f"  [yellow]👀 {comment}[/yellow]\n")
+        return
+
+    comment = random.choice(SARCASTIC_COMMENTS)
+    console.print(f"  [bold]recent commits by [cyan]{username}[/cyan]:[/bold]\n")
+
+    for c in commits:
+        time_ago = format_time_ago(c["date"])
+        console.print(f"  [green]▸[/green] [white]{c['message']}[/white]")
+        console.print(f"    [dim]{c['repo']} · {time_ago}[/dim]")
+
+    console.print(f"\n  [bold yellow]👀 {comment}[/bold yellow]\n")
+
+def peer_pressure(username: str):
+    console.print(f"\n  [bold cyan]checking what {username} is up to...[/bold cyan]\n")
+    commits = get_recent_commits(username)
+    _display_commits(username, commits)
+
+def random_peer():
+    console.print(f"\n  [bold magenta]pulling a random dev from the void...[/bold magenta]\n")
+    
+    usernames = random.sample(RANDOM_USERNAMES, len(RANDOM_USERNAMES))
+    
+    for username in usernames:
+        commits = get_recent_commits(username)
+        if commits:
+            _display_commits(username, commits)
+            return
+
+    console.print("  [dim]all devs are slacking too. rare.[/dim]")
+    console.print("  [yellow]👀 even the internet is taking a break. no excuses for you though.[/yellow]\n")

get2work-0.1.0/get2work/roast.py

@@ -0,0 +1,181 @@
+import random
+from rich.console import Console
+
+console = Console()
+
+ROAST_FALLBACK = [
+    "your commits look like you're coding with your eyes closed ngl",
+    "bro really said 'fix' 5 times in a row. fix WHAT??",
+    "committing at 3am again? the grindset is NOT it",
+    "your commit history reads like a cry for help",
+    "one commit today? one? really? ok.",
+    "the way you commit... your tech lead is losing sleep",
+    "'update' is not a commit message. try again bestie",
+    "your streak died and you didn't even notice 💀",
+    "bro codes like they're defusing a bomb at all times",
+    "the git log called. it's concerned about you.",
+]
+
+VIBE_FALLBACK = [
+    "diagnosis: you're cooked but in a productive way",
+    "your commits say 'i am fine' but the timestamps say otherwise",
+    "clinical assessment: chaotic good developer with trust issues",
+    "you commit like someone who has seen things. dark things.",
+    "prognosis: will survive, but the codebase might not",
+    "your vibe is 'senior dev in a junior's body' and it shows",
+    "mental state: 404 work life balance not found",
+    "you're not burnout, you're just... extra crispy",
+]
+
+def get_commits_summary(repo_path: str = ".") -> str:
+    try:
+        import git
+        repo = git.Repo(repo_path, search_parent_directories=True)
+        commits = list(repo.iter_commits(max_count=20))
+        if not commits:
+            return "No commits found"
+        summary = []
+        for c in commits:
+            summary.append(f"- {c.message.strip()} ({c.authored_datetime.strftime('%A %H:%M')})")
+        return "\n".join(summary)
+    except Exception as e:
+        return f"Error reading commits: {e}"
+
+def _try_ai_roast(commits_summary: str, mode: str = "roast") -> str | None:
+    try:
+        from openai import OpenAI
+        import os
+
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            return None
+
+        client = OpenAI(api_key=api_key)
+
+        if mode == "roast":
+            system = """You are a savage but funny code roaster.
+Roast the developer based on their git commit history.
+Be sarcastic, funny and gen z. Max 4 lines.
+Respond in the same language the commits are written in."""
+        else:
+            system = """You are a therapist for developers but make it sarcastic.
+Analyze the git commit history and give a mental health diagnosis.
+Be funny, gen z, and dramatic. Max 5 lines.
+Respond in the same language the commits are written in."""
+
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            max_tokens=300,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": f"Commits:\n{commits_summary}"}
+            ]
+        )
+        return response.choices[0].message.content
+
+    except Exception:
+        return None
+
+def roast_my_commits(repo_path: str = "."):
+    console.print("\n  [bold magenta]loading your L's...[/bold magenta]\n")
+    commits = get_commits_summary(repo_path)
+
+    result = _try_ai_roast(commits, mode="roast")
+    source = "🤖 AI ROAST" if result else "🔥 ROAST"
+    if not result:
+        result = random.choice(ROAST_FALLBACK)
+
+    console.print(f"  [bold red]{source}:[/bold red]\n")
+    console.print(f"  [red]{result}[/red]\n")
+
+def vibe_check(repo_path: str = "."):
+    console.print("\n  [bold cyan]analyzing your vibe...[/bold cyan]\n")
+    commits = get_commits_summary(repo_path)
+
+    result = _try_ai_roast(commits, mode="vibe")
+    source = "🤖 AI VIBE CHECK" if result else "🧠 VIBE CHECK"
+    if not result:
+        result = random.choice(VIBE_FALLBACK)
+
+    console.print(f"  [bold cyan]{source}:[/bold cyan]\n")
+    console.print(f"  [cyan]{result}[/cyan]\n")
+    
+BLAME_FALLBACK = [
+    "this line was written by someone who had given up on life",
+    "whoever wrote this was clearly having a bad day. we don't judge. we do judge.",
+    "this code works and nobody knows why. not even the author.",
+    "written at 2am. you can tell.",
+    "the author of this line has since left the company. smart move.",
+    "this is either genius or a cry for help. probably both.",
+    "no comment. literally, they left no comment. typical.",
+    "the person who wrote this knew exactly what they were doing. unfortunately.",
+    "this line has survived 3 refactors. it's unkillable. it's a cockroach.",
+    "written with the confidence of someone who doesn't have to maintain this.",
+]
+
+def git_blame_personal(repo_path: str = "."):
+    import git
+
+    console.print("\n  [bold yellow]analyzing who to blame...[/bold yellow]\n")
+
+    try:
+        repo = git.Repo(repo_path, search_parent_directories=True)
+        commits = list(repo.iter_commits(max_count=10))
+
+        if not commits:
+            console.print("  [dim]no commits to blame. you're safe. for now.[/dim]\n")
+            return
+
+        blame_data = []
+        for commit in commits[:5]:
+            blame_data.append({
+                "author": commit.author.name,
+                "message": commit.message.strip().split("\n")[0],
+                "date": commit.authored_datetime.strftime("%A %H:%M"),
+                "files": list(commit.stats.files.keys())[:2],
+            })
+
+        result = _try_ai_blame(blame_data)
+        if not result:
+            import random
+            console.print(f"  [bold yellow]🔍 GIT BLAME BUT MAKE IT PERSONAL:[/bold yellow]\n")
+            for item in blame_data:
+                comment = random.choice(BLAME_FALLBACK)
+                console.print(f"  [white]commit:[/white] [dim]{item['message']}[/dim]")
+                console.print(f"  [yellow]→ {comment}[/yellow]\n")
+        else:
+            console.print(f"  [bold yellow]🔍 GIT BLAME BUT MAKE IT PERSONAL:[/bold yellow]\n")
+            console.print(f"  [yellow]{result}[/yellow]\n")
+
+    except Exception as e:
+        console.print(f"  [red]error: {e}[/red]\n")
+
+def _try_ai_blame(blame_data: list) -> str | None:
+    try:
+        from openai import OpenAI
+        import os
+
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            return None
+
+        client = OpenAI(api_key=api_key)
+
+        system = """You are a savage code historian.
+You analyze git commits and roast each one personally.
+For each commit, make a personal comment about the author's life choices.
+Be funny, gen z, sarcastic. One line per commit max.
+Respond in the same language the commits are written in."""
+
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            max_tokens=400,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": f"Blame these commits:\n{str(blame_data)}"}
+            ]
+        )
+        return response.choices[0].message.content
+
+    except Exception:
+        return None

get2work-0.1.0/get2work/storage.py

@@ -0,0 +1,38 @@
+import json
+from pathlib import Path
+
+STORAGE_PATH = Path.home() / ".get2work" / "data.json"
+
+DEFAULT_DATA = {
+    "commits": 0,
+    "streak": 0,
+    "last_commit_date": None,
+    "level": 1,
+    "total_lines_added": 0,
+    "total_lines_deleted": 0,
+    "pomodoros_completed": 0,
+    "distractions_caught": 0,
+}
+
+def load() -> dict:
+    if not STORAGE_PATH.exists():
+        STORAGE_PATH.parent.mkdir(parents=True, exist_ok=True)
+        save(DEFAULT_DATA)
+        return DEFAULT_DATA.copy()
+    with open(STORAGE_PATH) as f:
+        return json.load(f)
+
+def save(data: dict):
+    STORAGE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(STORAGE_PATH, "w") as f:
+        json.dump(data, f, indent=2)
+
+def increment(key: str, amount: int = 1):
+    data = load()
+    data[key] = data.get(key, 0) + amount
+    save(data)
+
+def update(key: str, value):
+    data = load()
+    data[key] = value
+    save(data)

get2work-0.1.0/get2work/watcher.py

@@ -0,0 +1,172 @@
+import time
+import random
+import git
+from datetime import date, datetime
+from rich.console import Console
+from get2work.storage import load, save, increment, update
+from get2work.levels import check_levelup
+from get2work.celebrate import celebrate_commit, celebrate_levelup, code_funeral, play_shame
+
+console = Console()
+
+SHAME_MESSAGES_LOW = [
+    "hey... everything ok? no commits today 👀",
+    "sooo are we coding or just vibing?",
+    "the repo is lonely. just saying.",
+    "no pressure but... commit something maybe?",
+    "gentle reminder that you exist and so does git",
+]
+
+SHAME_MESSAGES_MED = [
+    "your streak is in danger bro 😬",
+    "bro really said 'i'll commit later' huh",
+    "the codebase misses you. or maybe it doesn't. hard to tell.",
+    "ok so we're just not committing today? ok.",
+    "your github is looking a little dry rn 💀",
+]
+
+SHAME_MESSAGES_HIGH = [
+    "I'M NOT MAD I'M JUST DISAPPOINTED",
+    "THE AUDACITY OF NOT COMMITTING",
+    "at this point are you even a developer",
+    "your github is a desert. a wasteland. nothing.",
+    "bro said 'i'm a developer' and then didn't develop 💀",
+    "the commit history called. it's filing a missing persons report.",
+]
+
+def get_shame_message(hours_since_commit: int) -> str:
+    if hours_since_commit < 4:
+        return random.choice(SHAME_MESSAGES_LOW)
+    elif hours_since_commit < 8:
+        return random.choice(SHAME_MESSAGES_MED)
+    else:
+        return random.choice(SHAME_MESSAGES_HIGH)
+
+class CommitWatcher:
+    def __init__(self, repo_path: str = "."):
+        self.repo_path = repo_path
+        self.last_commit = None
+        self._get_last_commit()
+
+    def _get_last_commit(self):
+        try:
+            repo = git.Repo(self.repo_path, search_parent_directories=True)
+            commits = list(repo.iter_commits(max_count=1))
+            if commits:
+                self.last_commit = commits[0].hexsha
+        except Exception:
+            pass
+
+    def check_new_commit(self):
+        try:
+            repo = git.Repo(self.repo_path, search_parent_directories=True)
+            commits = list(repo.iter_commits(max_count=1))
+            if not commits:
+                return
+            latest = commits[0]
+            if latest.hexsha == self.last_commit:
+                return
+            self.last_commit = latest.hexsha
+            self._handle_new_commit(repo, latest)
+        except Exception:
+            pass
+
+    def _handle_new_commit(self, repo, commit):
+        try:
+            stats = commit.stats.total
+            lines_added = stats.get("insertions", 0)
+            lines_deleted = stats.get("deletions", 0)
+        except Exception:
+            lines_added = 0
+            lines_deleted = 0
+
+        increment("commits")
+        increment("total_lines_added", lines_added)
+        increment("total_lines_deleted", lines_deleted)
+
+        self._update_streak()
+        celebrate_commit()
+
+        if lines_deleted > 100:
+            code_funeral()
+
+        leveled_up, level_name = check_levelup()
+        if leveled_up:
+            celebrate_levelup(level_name)
+
+    def _update_streak(self):
+        data = load()
+        today = str(date.today())
+        last = data.get("last_commit_date")
+
+        if last == today:
+            return
+
+        if last is None:
+            data["streak"] = 1
+        else:
+            last_date = datetime.strptime(last, "%Y-%m-%d").date()
+            diff = (date.today() - last_date).days
+            if diff == 1:
+                data["streak"] = data.get("streak", 0) + 1
+            else:
+                data["streak"] = 1
+
+        data["last_commit_date"] = today
+        save(data)
+
+    def check_shame(self):
+        data = load()
+        last = data.get("last_commit_date")
+        today = str(date.today())
+
+        if last == today:
+            console.print("\n  [bold green]✅ you committed today. we're proud.[/bold green]")
+            console.print("  [dim]don't ruin it.[/dim]\n")
+            return
+
+        if last is None:
+            hours = 24
+        else:
+            last_date = datetime.strptime(last, "%Y-%m-%d")
+            hours = int((datetime.now() - last_date).total_seconds() / 3600)
+
+        msg = get_shame_message(hours)
+        play_shame()
+        console.print(f"\n  [bold red]⚠️  {msg}[/bold red]\n")
+            
+def update_streak():
+    data = load()
+    today = str(date.today())
+    last = data.get("last_commit_date")
+
+    if last == today:
+        return
+
+    if last is None:
+        data["streak"] = 1
+    else:
+        last_date = datetime.strptime(last, "%Y-%m-%d").date()
+        diff = (date.today() - last_date).days
+        if diff == 1:
+            data["streak"] = data.get("streak", 0) + 1
+        else:
+            data["streak"] = 1
+
+    data["last_commit_date"] = today
+    save(data)        
+
+def start_watching(repo_path: str = "."):
+    watcher = CommitWatcher(repo_path)
+    console.print("\n  [bold green]get2work is watching you 👀[/bold green]")
+    console.print("  [dim]commit something or face the consequences[/dim]\n")
+
+    check_interval = 0
+    while True:
+        watcher.check_new_commit()
+        check_interval += 1
+
+        if check_interval % 180 == 0:
+            watcher.check_shame()
+
+        time.sleep(10)

get2work-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "get2work"
+version = "0.1.0"
+description = "The Python library that makes you actually work"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "gitpython>=3.1.0",
+    "watchdog>=3.0.0",
+    "psutil>=5.9.0",
+    "anthropic>=0.20.0",
+    "requests>=2.31.0",
+    "apscheduler>=3.10.0",
+    "pygame>=2.5.0",
+]
+
+[project.scripts]
+get2work = "get2work.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["get2work"]