git-gamify 1.0.0__tar.gz

git_gamify-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: git-gamify
+Version: 1.0.0
+Summary: A CLI tool that adds a fun gamification layer to your daily Git usage.
+Author-email: Your Name <your.email@example.com>
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer[all]>=0.9.0

git_gamify-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "git-gamify"
+version = "1.0.0"
+authors = [
+    { name = "Your Name", email = "your.email@example.com" },
+]
+description = "A CLI tool that adds a fun gamification layer to your daily Git usage."
+readme = "README.md"
+requires-python = ">=3.8"
+# 使用新的、推荐的 license 格式，修复了警告
+license = { text = "MIT License" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "rich>=13.0.0",
+    "typer[all]>=0.9.0",
+]
+
+[project.scripts]
+gg = "gg_cli.main:cli_entry"
+
+# ----------------- 新增和修改的部分在这里 -----------------
+[tool.setuptools]
+# 告诉 setuptools 我们的代码包在 src 文件夹里
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+# 告诉 setuptools，要将所有文件夹下的所有 .json 文件都包含进来
+"*" = ["**/*.json"]

git_gamify-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

git_gamify-1.0.0/src/gg_cli/achievements.py

@@ -0,0 +1,119 @@
+# src/gg_cli/achievements.py
+"""Handles the logic for checking and unlocking all achievements."""
+
+import json
+import re
+from datetime import date, datetime
+from gg_cli.utils import DEFINITIONS_DIR, console
+from gg_cli.translator import Translator
+from rich.panel import Panel
+
+
+def load_achievement_definitions() -> dict:
+    """
+    Loads achievement definitions from JSON and flattens them into a single dict.
+
+    Returns:
+        A dictionary mapping achievement IDs to their definition data.
+    """
+    with open(DEFINITIONS_DIR / 'achievements.json', 'r', encoding='utf-8') as f:
+        defs = json.load(f)
+        # Flatten the structure from categories into a single ID-based dictionary.
+        return {ach_id: ach_data for category in defs.values() for ach_id, ach_data in category.items()}
+
+
+ACHIEVEMENTS_DEF = load_achievement_definitions()
+
+
+# Helper functions for checking specific achievement conditions.
+# These are kept internal to this module.
+
+def _check_simple_stat(user_data: dict, stat_key: str, target_value: int, ach_id: str) -> dict | None:
+    """Generic checker for achievements based on a simple statistic count."""
+    if user_data["stats"].get(stat_key, 0) >= target_value:
+        return {"id": ach_id}
+    return None
+
+
+def _check_midnight_coder(user_data: dict, context: dict, **kwargs) -> dict | None:
+    """Checker for the 'Midnight Coder' achievement."""
+    if context.get("command") != "commit":
+        return None
+    now = datetime.now()
+    if 0 <= now.hour < 4:  # Check if the time is between 00:00 and 04:00
+        return {"id": "midnight_coder"}
+    return None
+
+
+def _check_firefighter(user_data: dict, context: dict, **kwargs) -> dict | None:
+    """Checker for the 'Firefighter' achievement."""
+    if context.get("command") != "commit":
+        return None
+    deletions = context.get("deletions", 0)
+    if deletions >= 500:
+        return {"id": "firefighter"}
+    return None
+
+
+def _check_storyteller(user_data: dict, context: dict, **kwargs) -> dict | None:
+    """Checker for the 'Storyteller' achievement."""
+    if context.get("command") != "commit":
+        return None
+    commit_message = context.get("commit_message", "")
+    if len(commit_message.split()) >= 50:
+        return {"id": "storyteller"}
+    return None
+
+
+# Maps achievement IDs to their corresponding checker functions for easy iteration.
+ACHIEVEMENT_CHECKERS = {
+    "first_commit": lambda u, **kwargs: _check_simple_stat(u, "total_commits", 1, "first_commit"),
+    "commit_10":    lambda u, **kwargs: _check_simple_stat(u, "total_commits", 10, "commit_10"),
+    "commit_100":   lambda u, **kwargs: _check_simple_stat(u, "total_commits", 100, "commit_100"),
+    "commit_1000":  lambda u, **kwargs: _check_simple_stat(u, "total_commits", 1000, "commit_1000"),
+    "first_push":   lambda u, **kwargs: _check_simple_stat(u, "total_pushes", 1, "first_push"),
+    "push_50":      lambda u, **kwargs: _check_simple_stat(u, "total_pushes", 50, "push_50"),
+    "combo_3":      lambda u, **kwargs: _check_simple_stat(u, "consecutive_commit_days", 3, "combo_3"),
+    "combo_7":      lambda u, **kwargs: _check_simple_stat(u, "consecutive_commit_days", 7, "combo_7"),
+    "combo_30":     lambda u, **kwargs: _check_simple_stat(u, "consecutive_commit_days", 30, "combo_30"),
+    "midnight_coder": _check_midnight_coder,
+    "firefighter": _check_firefighter,
+    "storyteller": _check_storyteller,
+}
+
+
+def check_all_achievements(user_data: dict, translator: Translator, context: dict) -> int:
+    """
+    Iterates through all defined achievements and checks if they should be unlocked.
+
+    If an achievement is unlocked, it updates user_data, prints a notification,
+    and contributes to the total XP gained in this session.
+
+    Args:
+        user_data: The user's current data dictionary.
+        translator: An instance of the Translator class for notifications.
+        context: A dictionary containing contextual info about the command (e.g., command name).
+
+    Returns:
+        The total XP awarded from all newly unlocked achievements.
+    """
+    xp_from_achievements = 0
+
+    for ach_id, checker_func in ACHIEVEMENT_CHECKERS.items():
+        if ach_id not in user_data["achievements_unlocked"]:
+            result = checker_func(user_data, context=context)
+            if result:
+                user_data["achievements_unlocked"][ach_id] = date.today().isoformat()
+
+                reward = ACHIEVEMENTS_DEF[ach_id].get("xp_reward", 0)
+                xp_from_achievements += reward
+
+                # Display a notification to the user.
+                name = translator.t(ACHIEVEMENTS_DEF[ach_id]["name_key"])
+                desc = translator.t(ACHIEVEMENTS_DEF[ach_id]["desc_key"])
+                panel_title = translator.t("achievement_unlocked_panel_title")
+                console.print(Panel(
+                    f"[bold cyan]{name}[/bold cyan]\n[italic]{desc}[/italic]\n\n✨ [bold]Gained +{reward} XP![/bold]",
+                    title=panel_title, border_style="yellow", expand=False))
+
+    return xp_from_achievements

git_gamify-1.0.0/src/gg_cli/core.py

@@ -0,0 +1,107 @@
+# src/gg_cli/core.py
+"""Core functionalities for data management, user profile handling, and Git repo interactions."""
+
+import json
+import subprocess
+import hashlib
+from datetime import date
+from gg_cli.utils import DATA_DIR
+
+
+def is_in_git_repo() -> bool:
+    """Check if the current directory is inside a Git working tree."""
+    try:
+        # This command returns 'true' if inside a repo, otherwise errors out.
+        output = subprocess.check_output(
+            ['git', 'rev-parse', '--is-inside-work-tree'],
+            text=True,
+            stderr=subprocess.DEVNULL
+        )
+        return output.strip() == 'true'
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def get_current_git_email() -> str | None:
+    """Retrieve the user.email from the local Git configuration."""
+    try:
+        return subprocess.check_output(
+            ['git', 'config', 'user.email'],
+            text=True,
+            stderr=subprocess.DEVNULL
+        ).strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def get_profile_filename(email: str) -> str | None:
+    """Generate a unique, safe filename for a user profile based on their email."""
+    if not email:
+        return None
+    # Use SHA1 hash to anonymize and create a filesystem-safe name.
+    return hashlib.sha1(email.encode('utf-8')).hexdigest() + ".json"
+
+
+def get_default_user_data(email: str | None = None) -> dict:
+    """Return a dictionary containing the default data structure for a new user."""
+    return {
+        "config": {"language": "en", "user_email": email},
+        "user": {"xp": 0, "level": 1},
+        "achievements_unlocked": {},
+        "stats": {
+            "total_commits": 0,
+            "total_pushes": 0,
+            "last_commit_date": "1970-01-01",
+            "last_push_date": "1970-01-01",
+            "consecutive_commit_days": 0
+        }
+    }
+
+
+def load_user_data() -> dict:
+    """
+    Load user data from their JSON profile file.
+
+    Identifies the user by their git email, finds the corresponding profile,
+    and merges it with the default data structure to ensure forward compatibility
+    if new fields are added to the app. Creates a new profile if one doesn't exist.
+    """
+    email = get_current_git_email()
+    if not email:
+        return get_default_user_data()
+
+    filename = get_profile_filename(email)
+    profile_path = DATA_DIR / filename
+
+    if not profile_path.exists():
+        user_data = get_default_user_data(email)
+        save_user_data(user_data)
+        return user_data
+
+    # Start with default data to ensure all keys exist.
+    user_data = get_default_user_data(email)
+    try:
+        with open(profile_path, 'r', encoding='utf-8') as f:
+            disk_data = json.load(f)
+        # Merge saved data into the default structure. This makes the data
+        # robust against schema changes (e.g., adding new stats).
+        for main_key in user_data:
+            if main_key in disk_data and isinstance(user_data[main_key], dict):
+                user_data[main_key].update(disk_data[main_key])
+    except (json.JSONDecodeError, FileNotFoundError):
+        # If the file is corrupted or deleted mid-operation, save a clean default state.
+        save_user_data(user_data)
+
+    return user_data
+
+
+def save_user_data(data: dict) -> None:
+    """Save the user's data dictionary to their corresponding JSON profile file."""
+    email = data.get("config", {}).get("user_email")
+    if not email:
+        return
+
+    filename = get_profile_filename(email)
+    profile_path = DATA_DIR / filename
+    with open(profile_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)

git_gamify-1.0.0/src/gg_cli/definitions/achievements.json

@@ -0,0 +1,70 @@
+{
+  "onboarding": {
+    "first_commit": {
+      "name_key": "ach_first_commit_name",
+      "desc_key": "ach_first_commit_desc",
+      "xp_reward": 50
+    },
+    "first_push": {
+      "name_key": "ach_first_push_name",
+      "desc_key": "ach_first_push_desc",
+      "xp_reward": 75
+    }
+  },
+  "milestone": {
+    "commit_10": {
+      "name_key": "ach_commit_10_name",
+      "desc_key": "ach_commit_10_desc",
+      "xp_reward": 100
+    },
+    "commit_100": {
+      "name_key": "ach_commit_100_name",
+      "desc_key": "ach_commit_100_desc",
+      "xp_reward": 300
+    },
+    "push_50": {
+      "name_key": "ach_push_50_name",
+      "desc_key": "ach_push_50_desc",
+      "xp_reward": 350
+    },
+    "commit_1000": {
+      "name_key": "ach_commit_1000_name",
+      "desc_key": "ach_commit_1000_desc",
+      "xp_reward": 1000
+    }
+  },
+  "consistency": {
+    "combo_3": {
+      "name_key": "ach_combo_3_name",
+      "desc_key": "ach_combo_3_desc",
+      "xp_reward": 120
+    },
+    "combo_7": {
+      "name_key": "ach_combo_7_name",
+      "desc_key": "ach_combo_7_desc",
+      "xp_reward": 300
+    },
+    "combo_30": {
+      "name_key": "ach_combo_30_name",
+      "desc_key": "ach_combo_30_desc",
+      "xp_reward": 1200
+    }
+  },
+  "special": {
+    "midnight_coder": {
+      "name_key": "ach_midnight_coder_name",
+      "desc_key": "ach_midnight_coder_desc",
+      "xp_reward": 150
+    },
+    "firefighter": {
+      "name_key": "ach_firefighter_name",
+      "desc_key": "ach_firefighter_desc",
+      "xp_reward": 200
+    },
+    "storyteller": {
+      "name_key": "ach_storyteller_name",
+      "desc_key": "ach_storyteller_desc",
+      "xp_reward": 100
+    }
+  }
+}

git_gamify-1.0.0/src/gg_cli/definitions/rewards.json

@@ -0,0 +1,24 @@
+{
+  "quotes": {
+    "en": [
+      "Talk is cheap. Show me the code. - Linus Torvalds",
+      "Any fool can write code that a computer can understand. Good programmers write code that humans can understand. - Martin Fowler",
+      "First, solve the problem. Then, write the code. - John Johnson"
+    ],
+    "zh": [
+      "废话少说，放码过来。——林纳斯·托瓦兹",
+      "任何傻瓜都能写出计算机能理解的代码。好的程序员能写出人类能理解的代码。——马丁·福勒",
+      "先解决问题，再写代码。——约翰·约翰逊"
+    ]
+  },
+  "jokes": {
+    "en": [
+      "Why do programmers prefer dark mode? Because light attracts bugs.",
+      "A programmer puts two glasses on his bedside table. One full of water, and one empty. The full one is in case he gets thirsty, and the empty one is in case he doesn't."
+    ],
+    "zh": [
+      "程序员为什么喜欢暗色模式？因为光（light）会吸引bug（虫子）。",
+      "一个程序员在床头放了两个杯子。一个装满了水，一个空的。满的是为了口渴时喝，空的是为了不渴时用。"
+    ]
+  }
+}

git_gamify-1.0.0/src/gg_cli/definitions/rules.json

@@ -0,0 +1,7 @@
+{
+  "internal_commands": [
+    "profile",
+    "config",
+    "help"
+  ]
+}

git_gamify-1.0.0/src/gg_cli/gamify.py

@@ -0,0 +1,199 @@
+# src/gg_cli/gamify.py
+"""The core gamification engine. Calculates XP, manages levels, and processes game logic after Git commands."""
+
+import json
+import random
+import subprocess
+import re
+from datetime import date
+from gg_cli.core import load_user_data, save_user_data
+from gg_cli.translator import Translator
+from gg_cli.utils import console, DEFINITIONS_DIR
+from gg_cli.achievements import check_all_achievements
+from rich.panel import Panel
+
+# Defines the level progression system.
+# Each tuple represents: (level_cap, xp_per_level_in_tier, title_translation_key)
+LEVEL_TIERS = [
+    (10, 100, "level_title_novice"),
+    (20, 250, "level_title_apprentice"),
+    (30, 500, "level_title_journeyman"),
+    (40, 1000, "level_title_adept"),
+    (50, 2500, "level_title_master"),
+]
+
+
+def get_level_info(level: int) -> tuple[int, int, str]:
+    """Retrieves tier information for a given level."""
+    if not isinstance(level, int) or level < 1:
+        level = 1
+    for max_level, xp_per_level, title_key in LEVEL_TIERS:
+        if level <= max_level:
+            return max_level, xp_per_level, title_key
+    # Default to the last tier for levels beyond the defined caps.
+    return LEVEL_TIERS[-1]
+
+
+def get_total_xp_for_level(target_level: int) -> int:
+    """Calculates the total XP required to reach the beginning of a target level."""
+    total_xp = 0
+    current_level = 1
+    while current_level < target_level:
+        _, xp_per_level, _ = get_level_info(current_level)
+        total_xp += xp_per_level
+        current_level += 1
+    return total_xp
+
+
+def get_level_from_xp(xp: int) -> int:
+    """Calculates a user's level based on their total XP."""
+    if not isinstance(xp, int) or xp < 0:
+        xp = 0
+    level = 1
+    xp_needed_for_next_level = 0
+    while True:
+        _, xp_per_level, _ = get_level_info(level)
+        xp_needed_for_next_level += xp_per_level
+        if xp < xp_needed_for_next_level:
+            return level
+        level += 1
+
+
+def load_rewards() -> dict:
+    """Loads random rewards (quotes, jokes) from the JSON definition file."""
+    with open(DEFINITIONS_DIR / 'rewards.json', 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+
+rewards_def = load_rewards()
+
+
+def process_gamify_logic(git_command_args: list[str]) -> None:
+    """
+    The main entry point for all gamification logic.
+
+    This function is called after a successful git command and handles
+    XP calculation, stats updates, and achievement checks.
+    """
+    user_data = load_user_data()
+    if not user_data or not user_data.get("config", {}).get("user_email"):
+        return
+
+    translator = Translator(user_data.get("config", {}).get("language", "en"))
+    command = git_command_args[0] if git_command_args else ""
+    today = date.today()
+    xp_to_add = 0
+    context = {"command": command}
+
+    if command == "commit":
+        # Update commit stats
+        user_data["stats"]["total_commits"] += 1
+        last_commit_date_str = user_data["stats"].get("last_commit_date", "1970-01-01")
+
+        if last_commit_date_str != "1970-01-01":
+            last_commit_date = date.fromisoformat(last_commit_date_str)
+            if (today - last_commit_date).days == 1:
+                user_data["stats"]["consecutive_commit_days"] += 1
+            elif (today - last_commit_date).days > 1:
+                user_data["stats"]["consecutive_commit_days"] = 1
+        else:  # First commit ever for this user.
+            user_data["stats"]["consecutive_commit_days"] = 1
+
+        if last_commit_date_str != today.isoformat():
+            user_data["stats"]["last_commit_date"] = today.isoformat()
+
+        # Calculate XP for the commit
+        xp_to_add += 10  # Base XP
+        xp_to_add += min(user_data["stats"]["consecutive_commit_days"], 15)  # Combo bonus
+
+        # Bonus XP based on code volume
+        try:
+            diff_stats = subprocess.check_output(
+                ["git", "diff", "--shortstat", "HEAD~1", "HEAD"],
+                text=True, stderr=subprocess.DEVNULL
+            ).strip()
+            changes = sum(int(s) for s in diff_stats.split() if s.isdigit())
+            xp_to_add += min(int(changes / 20), 20)
+
+            # Gather context for achievements
+            deletions_match = re.search(r'(\d+)\s+deletions', diff_stats)
+            context["deletions"] = int(deletions_match.group(1)) if deletions_match else 0
+            context["commit_message"] = subprocess.check_output(["git", "log", "-1", "--pretty=%B"], text=True).strip()
+        except Exception:
+            # Ignore errors if not in a state to diff (e.g., first commit).
+            pass
+
+    elif command == "push":
+        # Update push stats
+        user_data["stats"]["total_pushes"] += 1
+        last_push_date = date.fromisoformat(user_data["stats"]["last_push_date"])
+
+        # Calculate XP for the push
+        xp_to_add += 25  # Base XP
+        if today != last_push_date:
+            xp_to_add += 50  # Daily bonus
+            user_data["stats"]["last_push_date"] = today.isoformat()
+
+    # Check for any newly unlocked achievements and add their XP.
+    xp_from_achievements = check_all_achievements(user_data, translator, context)
+    xp_to_add += xp_from_achievements
+
+    if xp_to_add > 0:
+        current_level = user_data.get("user", {}).get("level", 1)
+        current_xp = user_data.get("user", {}).get("xp", 0)
+
+        new_xp = current_xp + xp_to_add
+        new_level = get_level_from_xp(new_xp)
+        user_data["user"] = {"xp": new_xp, "level": new_level}
+
+        # Display XP gain message
+        _, xp_per_level_current, _ = get_level_info(new_level)
+        xp_base_for_current_level = get_total_xp_for_level(new_level)
+        next_level_xp_target = xp_base_for_current_level + xp_per_level_current
+        console.print(translator.t(
+            "xp_gain_message",
+            xp=xp_to_add,
+            level=new_level,
+            current_xp=new_xp,
+            next_level_xp=next_level_xp_target
+        ))
+
+        # Handle level up event
+        if new_level > current_level:
+            _, _, title_key = get_level_info(new_level)
+            console.print(
+                translator.t("level_up_message", level=new_level, title=translator.t(title_key)),
+                style="bold magenta"
+            )
+            # Give a random reward
+            lang = user_data.get("config", {}).get("language", "en")
+            reward_type = random.choice(["quotes", "jokes"])
+            reward = random.choice(rewards_def[reward_type][lang])
+            console.print(Panel(
+                f"[italic cyan]{reward}[/italic cyan]",
+                title=translator.t("random_reward_title"),
+                border_style="green", expand=False
+            ))
+
+            # Give a level up XP bonus
+            _, xp_per_level, _ = get_level_info(new_level)
+            xp_from_bonus = int(xp_per_level * 0.20)
+            user_data["user"]["xp"] += xp_from_bonus
+
+            # Recalculate stats for the bonus message
+            bonus_final_xp = user_data["user"]["xp"]
+            bonus_final_level = get_level_from_xp(bonus_final_xp)
+            _, bonus_xp_per_level, _ = get_level_info(bonus_final_level)
+            bonus_xp_base = get_total_xp_for_level(bonus_final_level)
+            bonus_next_level_target = bonus_xp_base + bonus_xp_per_level
+
+            console.print(translator.t(
+                "xp_gain_message",
+                xp=xp_from_bonus,
+                level=bonus_final_level,
+                current_xp=bonus_final_xp,
+                next_level_xp=bonus_next_level_target
+            ))
+            user_data["user"]["level"] = bonus_final_level
+
+    save_user_data(user_data)

git_gamify-1.0.0/src/gg_cli/locales/en.json

@@ -0,0 +1,43 @@
+{
+  "level_title": "Level",
+  "xp_progress_title": "XP Progress",
+  "profile_email_label": "Email",
+  "achievements_unlocked_title": "Achievements Unlocked",
+  "profile_title": "Git Gamify Profile",
+  "level_up_message": "🎉 LEVEL UP! You have reached Level {level}: {title}! 🎉",
+  "xp_gain_message": "✨ You gained +{xp} XP! Current level {level} ({current_xp}/{next_level_xp}).",
+  "random_reward_title": "A little wisdom for your journey:",
+  "config_language_set": "Language has been set to English.",
+  "achievement_unlocked_panel_title": "🏆 Achievement Unlocked! 🏆",
+
+  "ach_first_commit_name": "First Step",
+  "ach_first_commit_desc": "Complete your very first commit.",
+  "ach_first_push_name": "Sharing is Caring",
+  "ach_first_push_desc": "Complete your very first push.",
+  "ach_commit_10_name": "Getting Started",
+  "ach_commit_10_desc": "Complete 10 commits.",
+  "ach_commit_100_name": "Centurion",
+  "ach_commit_100_desc": "Complete 100 commits.",
+  "ach_push_50_name": "Reliable Contributor",
+  "ach_push_50_desc": "Complete 50 pushes.",
+  "ach_commit_1000_name": "Commit King",
+  "ach_commit_1000_desc": "A true legend. Complete 1000 commits.",
+  "ach_combo_3_name": "Warming Up",
+  "ach_combo_3_desc": "Commit on 3 consecutive days.",
+  "ach_combo_7_name": "Combo Master",
+  "ach_combo_7_desc": "Commit on 7 consecutive days.",
+  "ach_combo_30_name": "Marathon Runner",
+  "ach_combo_30_desc": "A supreme effort. Commit on 30 consecutive days.",
+  "ach_midnight_coder_name": "Midnight Coder",
+  "ach_midnight_coder_desc": "Commit code between midnight and 4 AM.",
+  "ach_firefighter_name": "Firefighter",
+  "ach_firefighter_desc": "Delete more than 500 lines of code in a single commit.",
+  "ach_storyteller_name": "Storyteller",
+  "ach_storyteller_desc": "Write a commit message with more than 50 words.",
+
+  "level_title_novice": "Git Novice",
+  "level_title_apprentice": "Git Apprentice",
+  "level_title_journeyman": "Git Journeyman",
+  "level_title_adept": "Git Adept",
+  "level_title_master": "Git Master"
+}

git_gamify-1.0.0/src/gg_cli/locales/zh.json

@@ -0,0 +1,43 @@
+{
+  "level_title": "等级",
+  "xp_progress_title": "经验值进度",
+  "profile_email_label": "邮箱",
+  "achievements_unlocked_title": "已解锁成就",
+  "profile_title": "Git Gamify 玩家档案",
+  "level_up_message": "🎉 等级提升！你已达到 {level} 级：{title}！🎉",
+  "xp_gain_message": "✨ 你获得了 +{xp} XP！当前等级 {level} ({current_xp}/{next_level_xp})。",
+  "random_reward_title": "一点旅途中的智慧：",
+  "config_language_set": "语言已成功设置为中文。",
+  "achievement_unlocked_panel_title": "🏆 成就解锁！🏆",
+
+  "ach_first_commit_name": "迈出第一步",
+  "ach_first_commit_desc": "完成你的第一次提交。",
+  "ach_first_push_name": "分享的喜悦",
+  "ach_first_push_desc": "完成你的第一次推送。",
+  "ach_commit_10_name": "小试牛刀",
+  "ach_commit_10_desc": "累计完成10次提交。",
+  "ach_commit_100_name": "百战老兵",
+  "ach_commit_100_desc": "累计完成100次提交。",
+  "ach_push_50_name": "稳定贡献者",
+  "ach_push_50_desc": "累计完成50次推送。",
+  "ach_commit_1000_name": "万码奔腾",
+  "ach_commit_1000_desc": "真正的传奇！累计完成1000次提交。",
+  "ach_combo_3_name": "初露锋芒",
+  "ach_combo_3_desc": "连续3天都有提交。",
+  "ach_combo_7_name": "连击大师",
+  "ach_combo_7_desc": "连续7天都有提交。",
+  "ach_combo_30_name": "马拉松选手",
+  "ach_combo_30_desc": "伟大的坚持！连续30天都有提交。",
+  "ach_midnight_coder_name": "午夜码农",
+  "ach_midnight_coder_desc": "在凌晨0点到4点之间提交代码。",
+  "ach_firefighter_name": "救火队员",
+  "ach_firefighter_desc": "在一次提交中删除了超过500行代码。",
+  "ach_storyteller_name": "吟游诗人",
+  "ach_storyteller_desc": "编写一个包含超过50个单词的提交信息。",
+
+  "level_title_novice": "Git 新手",
+  "level_title_apprentice": "Git 学徒",
+  "level_title_journeyman": "Git 行家",
+  "level_title_adept": "Git 高手",
+  "level_title_master": "Git 大师"
+}

git_gamify-1.0.0/src/gg_cli/main.py

@@ -0,0 +1,213 @@
+# src/gg_cli/main.py
+"""The main entry point for the Git-Gamify CLI. Defines all user-facing commands and handles command-line argument parsing."""
+
+import sys
+import subprocess
+import typer
+import os
+import traceback
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Confirm
+from rich.progress_bar import ProgressBar
+from rich.text import Text
+from rich.console import Group
+from gg_cli.core import (
+    is_in_git_repo, load_user_data, save_user_data,
+    get_current_git_email, get_profile_filename, get_default_user_data
+)
+from gg_cli.gamify import process_gamify_logic, get_level_info, get_total_xp_for_level
+from gg_cli.translator import Translator
+from gg_cli.utils import console, DATA_DIR
+
+# Initialize the Typer application.
+app = typer.Typer(
+    help="Run `gg help` for a list of gamify commands.",
+    add_help_option=False,  # We use a custom 'help' command.
+    no_args_is_help=True,   # Show help if no command is provided.
+)
+
+
+def get_translator() -> Translator:
+    """Helper function to get a translator instance based on user's config."""
+    user_data = load_user_data()
+    lang_code = user_data.get("config", {}).get("language", "en")
+    return Translator(lang_code)
+
+
+@app.callback()
+def main_callback(ctx: typer.Context):
+    """
+    A callback that runs before any command.
+
+    Used here to perform prerequisite checks, like ensuring the command
+    (if it's not 'help') is run inside a Git repository.
+    """
+    # Allow 'help' command to run anywhere.
+    if ctx.invoked_subcommand != 'help' and not is_in_git_repo():
+        console.print(f"[bold red]Error:[/bold red] The `gg {ctx.invoked_subcommand}` command must be run inside a Git repository.")
+        raise typer.Exit(code=1)
+
+
+@app.command("help")
+def show_help():
+    """Show the custom Git-Gamify help message."""
+    table = Table(box=None, show_header=False, show_edge=False)
+    table.add_column(style="cyan", justify="left", width=12)
+    table.add_column()
+    table.add_row("profile", "Display user profile, stats, or reset progress.")
+    table.add_row("config", "Get or set configuration values.")
+    table.add_row("help", "Show this help message and exit.")
+    console.print(Panel(
+        Group(
+            Text("Usage: gg COMMAND [OPTIONS]..."),
+            Text("Gamify your Git experience. Your aliased `git` commands are tracked automatically.\n"),
+            Text("[bold]Internal Commands:[/bold]"),
+            table
+        ),
+        title="[bold]Git-Gamify Help[/bold]", border_style="green", expand=False
+    ))
+
+
+@app.command("profile")
+def manage_profile(
+        stats: bool = typer.Option(False, "--stats", "-s", help="Display detailed statistics."),
+        reset: bool = typer.Option(False, "--reset", help="Reset all progress for the current user.")
+):
+    """Display user profile, stats, or reset progress."""
+    if reset:
+        email = get_current_git_email()
+        if not email:
+            console.print("[red]Error: Cannot find git user email. Is git configured?[/red]")
+            raise typer.Exit(code=1)
+
+        profile_path = DATA_DIR / get_profile_filename(email)
+        if Confirm.ask(f"[bold yellow]Are you sure you want to reset all progress for '{email}'?[/bold yellow]"):
+            if profile_path.exists():
+                try:
+                    os.remove(profile_path)
+                    console.print(f"[green]Profile for '{email}' has been successfully reset![/green]")
+                except OSError as e:
+                    console.print(f"[bold red]Error: Could not delete profile file. Reason: {e}[/bold red]")
+            else:
+                console.print(f"[yellow]No profile found for '{email}' to reset.[/yellow]")
+        else:
+            console.print("[cyan]Reset cancelled.[/cyan]")
+        return
+
+    if stats:
+        user_data = load_user_data()
+        s = user_data.get("stats", {})
+        console.print(f"Total commits: {s.get('total_commits', 0)}")
+        console.print(f"Total pushes: {s.get('total_pushes', 0)}")
+        console.print(f"Consecutive commit days: {s.get('consecutive_commit_days', 0)}")
+        return
+
+    # Default profile display
+    translator = get_translator()
+    user_data = load_user_data()
+    # This line now works correctly because get_default_user_data is imported.
+    user = user_data.get("user", get_default_user_data()["user"])
+    profile_email = user_data.get("config", {}).get("user_email")
+
+    # Prepare data for display
+    level = user.get('level', 1)
+    xp = user.get('xp', 0)
+    _, xp_per_level, title_key = get_level_info(level)
+    translated_level_title = translator.t(title_key)
+    xp_current_level_base = get_total_xp_for_level(level)
+    xp_next_level_base = xp_current_level_base + xp_per_level
+    progress_value = xp - xp_current_level_base
+    progress_total = xp_next_level_base - xp_current_level_base
+    if progress_total <= 0: progress_total = 1
+
+    # Build Rich elements for the profile panel
+    progress_bar = ProgressBar(total=progress_total, completed=progress_value, width=20)
+    progress_text = Text(f" {progress_value}/{progress_total} ({progress_value / progress_total:.1%})")
+    progress_table = Table.grid(expand=True)
+    progress_table.add_column(); progress_table.add_column(justify="right");
+    progress_table.add_row(progress_bar, progress_text)
+    profile_text = Text.from_markup(
+        f"  [bold]{translator.t('profile_email_label')}:[/bold] [cyan]{profile_email}[/cyan]\n"
+        f"  [bold]{translator.t('level_title')}:[/bold] {level} - {translated_level_title}\n\n"
+        f"  [bold]{translator.t('xp_progress_title')}:[/bold]"
+    )
+    panel_group = Group(profile_text, progress_table)
+    console.print(Panel(panel_group, title=translator.t("profile_title"), border_style="magenta", padding=(0, 1), expand=False))
+
+    # Display unlocked achievements
+    unlocked_achievements = user_data.get("achievements_unlocked", {})
+    if unlocked_achievements:
+        from gg_cli.achievements import ACHIEVEMENTS_DEF as achievements_def
+        display_items = [f"🏆 {translator.t(achievements_def.get(ach_id, {}).get('name_key', ach_id))}" for ach_id in unlocked_achievements]
+        console.print(Panel("\n".join(display_items), title=translator.t("achievements_unlocked_title"), border_style="yellow", expand=False))
+
+
+@app.command("config")
+def manage_config(
+        set_value: str = typer.Option(None, "--set", help="Set a value (e.g., 'language=zh')."),
+        get_value: str = typer.Option(None, "--get", help="Get a value (e.g., 'language').")
+):
+    """Get or set configuration values."""
+    if not set_value and not get_value:
+        console.print("[yellow]Please provide an option: --set or --get. Run 'gg help' for more info.[/yellow]")
+        return
+
+    user_data = load_user_data()
+    if set_value:
+        try:
+            key, value = set_value.split('=', 1)
+            if key.lower() == 'language':
+                user_data['config']['language'] = value
+                save_user_data(user_data)
+                confirm_translator = Translator(value)
+                console.print(Panel(confirm_translator.t("config_language_set"), border_style="green", expand=False))
+            else:
+                console.print(f"[red]Error: Unknown config key '[cyan]{key}[/cyan]'. Only 'language' is supported.[/red]")
+        except ValueError:
+            console.print("[red]Error: Invalid format. Please use '--set key=value'.[/red]")
+    if get_value:
+        if get_value.lower() == 'language':
+            console.print(user_data.get('config', {}).get('language', 'en'))
+        else:
+            console.print(f"[red]Error: Unknown config key '[cyan]{get_value}[/cyan]'. Only 'language' is supported.[/red]")
+
+
+def run_git_wrapper(git_args: list[str]) -> None:
+    """Execute the real git command and trigger gamification logic on success."""
+    try:
+        result = subprocess.run(['git'] + git_args, capture_output=True, text=True, check=False, encoding='utf-8')
+        if result.stdout:
+            sys.stdout.write(result.stdout)
+        if result.stderr:
+            sys.stderr.write(result.stderr)
+
+        # If the git command was successful, process gamify logic.
+        if result.returncode == 0:
+            command = git_args[0] if git_args else ""
+            if command in ["commit", "push"]:
+                console.print("-" * 20)
+                process_gamify_logic(git_args)
+    except FileNotFoundError:
+        console.print("[bold red]Error: 'git' command not found. Is Git installed and in your PATH?[/bold red]")
+    except Exception:
+        console.print("[bold red]An unexpected error occurred. Full traceback below:[/bold red]")
+        traceback.print_exc()
+
+
+def cli_entry():
+    """
+    The main CLI entry point.
+
+    Determines if the command is a special 'git' wrapper command or a standard
+    internal command to be handled by Typer.
+    """
+    # Check for our special 'git' wrapper command.
+    if len(sys.argv) > 1 and sys.argv[1] == 'git':
+        run_git_wrapper(sys.argv[2:])
+    else:
+        # For all other cases, delegate entirely to Typer.
+        app()
+
+if __name__ == "__main__":
+    cli_entry()

git_gamify-1.0.0/src/gg_cli/translator.py

@@ -0,0 +1,61 @@
+# src/gg_cli/translator.py
+"""Provides internationalization (i18n) support through a Translator class."""
+
+import json
+from gg_cli.utils import LOCALES_DIR, console
+
+
+class Translator:
+    """Manages loading and retrieving translated strings from JSON locale files."""
+
+    def __init__(self, lang_code: str = "en"):
+        """
+        Initializes the Translator for a specific language.
+
+        Args:
+            lang_code: The language code (e.g., "en", "zh") to use for translations.
+        """
+        self.strings = {}
+        # Always load English first as a reliable fallback.
+        self._load_language("en")
+        # If the requested language is not English, try to load it.
+        # It will override the English strings if successful.
+        if lang_code.lower() != "en":
+            self.load_strings(lang_code)
+
+    def _load_language(self, lang_code: str) -> bool:
+        """
+        Internal helper to load a single language file with robust error handling.
+        Returns True on success, False on failure.
+        """
+        lang_file = LOCALES_DIR / f"{lang_code.lower()}.json"
+        try:
+            with open(lang_file, 'r', encoding='utf-8-sig') as f:
+                self.strings.update(json.load(f))
+            return True
+        except FileNotFoundError:
+            console.print(f"[yellow]Warning: Language file for '{lang_code}' not found.[/yellow]")
+        except json.JSONDecodeError:
+            console.print(
+                f"[bold red]Error: Failed to decode language file for '{lang_code}'. The file might be corrupted.[/bold red]")
+        except Exception as e:
+            console.print(
+                f"[bold red]An unexpected error occurred while loading language '{lang_code}': {e}[/bold red]")
+
+        return False
+
+    def load_strings(self, lang_code: str):
+        """
+        Loads the translation strings for the given language, with English as a fallback.
+        """
+        if not self._load_language(lang_code):
+            console.print("[yellow]Falling back to English.[/yellow]")
+            # No need to load English again, it's already there as the base.
+            pass
+
+    def t(self, key: str, **kwargs) -> str:
+        """
+        Retrieves a translated string by its key and formats it with given arguments.
+        """
+        template = self.strings.get(key, key)
+        return template.format(**kwargs)

git_gamify-1.0.0/src/gg_cli/utils.py

@@ -0,0 +1,20 @@
+# src/gg_cli/utils.py
+"""Global utilities and path definitions for the Git-Gamify project."""
+
+from pathlib import Path
+from rich.console import Console
+
+# Global Rich Console instance for consistent output styling.
+console = Console()
+
+# Define key project paths relative to this file's location to ensure they
+# work correctly even when packaged.
+_CODE_DIR = Path(__file__).parent
+DEFINITIONS_DIR = _CODE_DIR / "definitions"
+LOCALES_DIR = _CODE_DIR / "locales"
+
+# Define the user data directory in the user's home folder.
+DATA_DIR = Path.home() / ".git-gamify"
+
+# Ensure the user data directory exists upon import.
+DATA_DIR.mkdir(exist_ok=True)

git_gamify-1.0.0/src/git_gamify.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: git-gamify
+Version: 1.0.0
+Summary: A CLI tool that adds a fun gamification layer to your daily Git usage.
+Author-email: Your Name <your.email@example.com>
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer[all]>=0.9.0

git_gamify-1.0.0/src/git_gamify.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+src/gg_cli/__init__.py
+src/gg_cli/achievements.py
+src/gg_cli/core.py
+src/gg_cli/gamify.py
+src/gg_cli/main.py
+src/gg_cli/translator.py
+src/gg_cli/utils.py
+src/gg_cli/definitions/achievements.json
+src/gg_cli/definitions/rewards.json
+src/gg_cli/definitions/rules.json
+src/gg_cli/locales/en.json
+src/gg_cli/locales/zh.json
+src/git_gamify.egg-info/PKG-INFO
+src/git_gamify.egg-info/SOURCES.txt
+src/git_gamify.egg-info/dependency_links.txt
+src/git_gamify.egg-info/entry_points.txt
+src/git_gamify.egg-info/requires.txt
+src/git_gamify.egg-info/top_level.txt
+tests/test_achievement_system.py
+tests/test_cli_commands.py
+tests/test_gamify_logic.py

git_gamify-1.0.0/src/git_gamify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

git_gamify-1.0.0/src/git_gamify.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gg = gg_cli.main:cli_entry

git_gamify-1.0.0/src/git_gamify.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rich>=13.0.0
+typer[all]>=0.9.0

git_gamify-1.0.0/src/git_gamify.egg-info/top_level.txt

@@ -0,0 +1 @@
+gg_cli

git_gamify-1.0.0/tests/test_achievement_system.py

@@ -0,0 +1,83 @@
+# tests/test_achievement_system.py
+"""Unit tests for the achievement unlocking logic."""
+
+import pytest
+from gg_cli.achievements import check_all_achievements
+from gg_cli.translator import Translator
+
+
+@pytest.fixture
+def mock_translator() -> Translator:
+    """
+    Provides a mock Translator instance that avoids file I/O.
+    The mock `t` method simply returns the key, which is sufficient for logic testing.
+    """
+    translator = Translator()
+    translator.t = lambda key, **kwargs: key
+    return translator
+
+
+@pytest.fixture
+def base_user_data() -> dict:
+    """Provides a clean, default user data structure for each test."""
+    return {
+        "stats": {
+            "total_commits": 0,
+            "total_pushes": 0,
+            "consecutive_commit_days": 0,
+        },
+        "achievements_unlocked": {}
+    }
+
+
+def test_unlock_first_commit(base_user_data: dict, mock_translator: Translator):
+    """Tests that the 'first_commit' achievement unlocks at exactly 1 commit."""
+    # Arrange: Set user stats to meet the condition
+    base_user_data["stats"]["total_commits"] = 1
+
+    # Act: Run the achievement checker
+    xp = check_all_achievements(base_user_data, mock_translator, context={"command": "commit"})
+
+    # Assert: Check that the achievement is unlocked and the correct XP is awarded
+    assert "first_commit" in base_user_data["achievements_unlocked"]
+    assert xp == 50
+
+
+def test_unlock_combo_master_only(base_user_data: dict, mock_translator: Translator):
+    """
+    Tests unlocking a higher-tier achievement ('combo_7') without also getting
+    credit for a lower-tier one ('combo_3') that is already unlocked.
+    """
+    # Arrange: Assume 'combo_3' is already unlocked and the user meets the 'combo_7' condition
+    base_user_data["achievements_unlocked"]["combo_3"] = "2025-01-01"
+    base_user_data["stats"]["consecutive_commit_days"] = 7
+
+    xp = check_all_achievements(base_user_data, mock_translator, context={"command": "commit"})
+
+    assert "combo_7" in base_user_data["achievements_unlocked"]
+    # Assert: The awarded XP should only be from the 'combo_7' achievement.
+    assert xp == 300
+
+
+def test_unlock_firefighter(base_user_data: dict, mock_translator: Translator):
+    """Tests that the 'firefighter' achievement unlocks with enough deletions."""
+    # Arrange: Provide a context with sufficient deletion stats
+    context = {"command": "commit", "deletions": 501}
+
+    xp = check_all_achievements(base_user_data, mock_translator, context)
+
+    assert "firefighter" in base_user_data["achievements_unlocked"]
+    assert xp == 200
+
+
+def test_no_unlock_if_already_unlocked(base_user_data: dict, mock_translator: Translator):
+    """Tests that an already unlocked achievement does not grant XP again."""
+    # Arrange: Set up a user who has already unlocked 'first_commit'
+    base_user_data["stats"]["total_commits"] = 5
+    base_user_data["achievements_unlocked"]["first_commit"] = "2025-01-01"
+
+    # Act: Run the checker again
+    xp = check_all_achievements(base_user_data, mock_translator, context={"command": "commit"})
+
+    # Assert: No new XP should be awarded.
+    assert xp == 0

git_gamify-1.0.0/tests/test_cli_commands.py

@@ -0,0 +1,51 @@
+# tests/test_cli_commands.py
+"""
+End-to-end tests for the CLI commands, simulating user interaction.
+These tests verify command behavior, error handling, and output.
+"""
+
+from typer.testing import CliRunner
+from gg_cli.main import app
+
+# A single CliRunner instance can be reused for all tests.
+runner = CliRunner()
+
+
+def test_cli_help_command():
+    """Tests that `gg help` runs successfully and contains expected text."""
+    result = runner.invoke(app, ["help"])
+
+    assert result.exit_code == 0
+    assert "profile" in result.stdout
+    assert "config" in result.stdout
+
+
+def test_cli_profile_needs_git_repo(monkeypatch):
+    """
+    Tests that running `gg profile` outside a Git repository exits with an error.
+    """
+    # Arrange: Use monkeypatch to simulate being outside a Git repository.
+    # We patch the function at the point of use to ensure the patch takes effect.
+    monkeypatch.setattr('gg_cli.main.is_in_git_repo', lambda: False)
+
+    # Act: Invoke the 'profile' command.
+    result = runner.invoke(app, ["profile"])
+
+    # Assert: The command should fail with a non-zero exit code and show an error message.
+    assert result.exit_code != 0
+    assert "must be run inside a Git repository" in result.stdout
+
+
+def test_cli_help_works_outside_git_repo(monkeypatch):
+    """
+    Tests that the `gg help` command is accessible even when outside a Git repository.
+    """
+    # Arrange: Simulate being outside a Git repository.
+    monkeypatch.setattr('gg_cli.main.is_in_git_repo', lambda: False)
+
+    # Act: Invoke the 'help' command.
+    result = runner.invoke(app, ["help"])
+
+    # Assert: The command should run successfully with a zero exit code.
+    assert result.exit_code == 0
+    assert "Usage: gg COMMAND" in result.stdout

git_gamify-1.0.0/tests/test_gamify_logic.py

@@ -0,0 +1,56 @@
+# tests/test_gamify_logic.py
+"""
+Unit tests for the core gamification numerical logic, such as level and XP calculations.
+These tests ensure the mathematical correctness of the leveling system.
+"""
+
+import pytest
+from gg_cli.gamify import get_level_from_xp, get_total_xp_for_level, get_level_info
+
+@pytest.mark.parametrize("xp, expected_level", [
+    (0, 1),      # Initial state
+    (99, 1),     # Just before leveling up
+    (100, 2),    # Exactly at the threshold for level 2
+    (199, 2),    # In the middle of level 2
+    (999, 10),   # Just before leaving the first tier
+    (1000, 11),  # Exactly at the threshold for level 11 (10 * 100 XP)
+    (1249, 11),  # In the middle of level 11
+    (3499, 20),  # Just before leaving the second tier
+    (3500, 21),  # Exactly at the threshold for level 21 (10*100 + 10*250 XP)
+])
+def test_get_level_from_xp_scenarios(xp, expected_level):
+    """
+    Tests that get_level_from_xp returns the correct level for various XP values,
+    covering initial, intermediate, and boundary conditions.
+    """
+    assert get_level_from_xp(xp) == expected_level
+
+@pytest.mark.parametrize("target_level, expected_total_xp", [
+    (1, 0),       # No XP required to reach level 1
+    (2, 100),     # 100 XP required to reach level 2
+    (3, 200),     # 100 (for L2) + 100 (for L3) = 200 XP
+    (11, 1000),   # 10 levels * 100 XP/level = 1000 XP
+    (12, 1250),   # 1000 (for L1-10) + 250 (for L11) = 1250 XP
+    (21, 3500),   # 1000 (for L1-10) + 2500 (for L11-20) = 3500 XP
+])
+def test_get_total_xp_for_level_scenarios(target_level, expected_total_xp):
+    """
+    Tests that get_total_xp_for_level correctly calculates the cumulative XP
+    needed to reach a specific target level.
+    """
+    assert get_total_xp_for_level(target_level) == expected_total_xp
+
+def test_get_level_info_boundaries():
+    """
+    Tests that get_level_info returns the correct tier information
+    at the boundaries between level tiers.
+    """
+    # Level 10 should be in the first tier (100 XP/level)
+    _, xp_per_level_10, title_key_10 = get_level_info(10)
+    assert xp_per_level_10 == 100
+    assert title_key_10 == "level_title_novice"
+
+    # Level 11 should be in the second tier (250 XP/level)
+    _, xp_per_level_11, title_key_11 = get_level_info(11)
+    assert xp_per_level_11 == 250
+    assert title_key_11 == "level_title_apprentice"