refactor: add version check decorator and update handling

- Add `check_version_before_command` decorator to `config`, `init`, `info`, `commit`, and `help` commands
- Implement `check_version_update` utility function to check for new version and handle updates
- Cache version check results to avoid frequent API calls
- Provide option to update package if new version is available

This refactor ensures that users are notified of new versions and can easily update the package, improving the user experience.

Author: Undertone0809

gcop/__main__.py

@@ -1,6 +1,7 @@
 import os
 import subprocess
 from enum import Enum
+from functools import wraps
 from pathlib import Path
 from typing import Callable, Dict, List, Literal, Optional
 
@@ -15,6 +16,7 @@
 
 from gcop import prompt, version
 from gcop.config import ModelConfig, gcop_config
+from gcop.utils import check_version_update
 
 load_dotenv()
 
@@ -90,7 +92,19 @@ def generate_commit_message(
     )
 
 
+def check_version_before_command(f: Callable) -> Callable:
+    """Decorator to check version before executing any command."""
+
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        check_version_update(console)
+        return f(*args, **kwargs)
+
+    return wrapper
+
+
 @app.command(name="config")
+@check_version_before_command
 def config_command(from_init: bool = False):
     """Open the config file in the default editor."""
     initial_content = (
@@ -112,6 +126,7 @@ def config_command(from_init: bool = False):
 
 
 @app.command(name="init")
+@check_version_before_command
 def init_command():
     """Add command into git config"""
     try:
@@ -174,6 +189,7 @@ def init_command():
 
 
 @app.command(name="info")
+@check_version_before_command
 def info_command():
     """Display detailed information about the current git repository."""
     try:
@@ -399,8 +415,14 @@ def info_command():
 
 
 @app.command(name="commit")
+@check_version_before_command
 def commit_command(
-    instruction: Optional[str] = None, previous_commit_message: Optional[str] = None
+    instruction: Optional[str] = typer.Option(
+        None, help="Additional instruction for commit message generation"
+    ),
+    previous_commit_message: Optional[str] = typer.Option(
+        None, help="Previous commit message to refine"
+    ),
 ):
     """Generate a git commit message based on the staged changes and commit the
     changes.
@@ -410,11 +432,6 @@ def commit_command(
     select "retry". If you want to retry the commit message generation with new
     feedback, please select "retry by feedback". If you want to exit the commit
     process, please select "exit".
-
-    Args:
-        instruction(Optional[str]): additional instruction. Defaults to None.
-        previous_commit_message(Optional[str]): previous commit message. Defaults to
-            None.
     """
     diff: str = get_git_diff("--staged")
 
@@ -451,19 +468,9 @@ def commit_command(
 
     actions[response]()
 
-    # # request pypi to get the latest version
-    # # TODO optimize logic, everyday check the latest version one time
-    # response = requests.get("https://pypi.org/pypi/gcop/json")
-    # latest_version = response.json()["info"]["version"]
-    # if version != latest_version:
-    #     console.print(f"[bold]A new version of gcop is available: {latest_version}[/]") # noqa
-    #     console.print(f"[bold]Your current version: {version}[/]")
-    #     console.print(
-    #         "[bold]Please consider upgrading by running: pip install -U gcop[/]"
-    #     )
-
 
 @app.command(name="help")
+@check_version_before_command
 def help_command():
     """Show help message"""
     help_message = """

gcop/utils/__init__.py

@@ -1,10 +1,47 @@
+import json
 import os
+import subprocess
 import tempfile
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional, Tuple
 
+import questionary
+import requests
 import yaml
+from rich.console import Console
 
+from gcop import version
 
-def convert_backslashes(path: str):
+
+@dataclass
+class VersionMetadata:
+    """Version metadata for caching version information."""
+
+    last_check: Optional[datetime] = None
+    latest_version: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "VersionMetadata":
+        """Create VersionMetadata from dictionary."""
+        last_check = None
+        if data.get("last_check"):
+            try:
+                last_check = datetime.fromisoformat(data["last_check"])
+            except (ValueError, TypeError):
+                last_check = None
+
+        return cls(last_check=last_check, latest_version=data.get("latest_version"))
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "last_check": self.last_check.isoformat() if self.last_check else None,
+            "latest_version": self.latest_version,
+        }
+
+
+def convert_backslashes(path: str) -> str:
     """Convert all \\ to / of file path."""
     return path.replace("\\", "/")
 
@@ -54,3 +91,75 @@ def read_yaml(file_path: str) -> dict:
     with open(file_path, "r") as file:
         config = yaml.safe_load(file)
         return config
+
+
+def _load_metadata(metadata_path: str) -> VersionMetadata:
+    """Load version metadata from file or create new if not exists.
+
+    Args:
+        metadata_path(str): Path to metadata file
+
+    Returns:
+        VersionMetadata: Loaded or new metadata object
+    """
+    if os.path.exists(metadata_path):
+        try:
+            with open(metadata_path, "r") as f:
+                return VersionMetadata.from_dict(json.load(f))
+        except (json.JSONDecodeError, IOError):
+            # If file is corrupted, create new metadata
+            pass
+
+    os.makedirs(os.path.dirname(metadata_path), exist_ok=True)
+
+    metadata = VersionMetadata()
+
+    with open(metadata_path, "w") as f:
+        json.dump(metadata.to_dict(), f)
+
+    return metadata
+
+
+def check_version_update(console: Console) -> None:
+    """Check for new version of gcop using cached data.
+    Only checks PyPI once per day and caches the result.
+
+    Args:
+        console: Rich console instance for output
+    """
+    metadata_path = os.path.join(get_default_storage_path(), "metadata.json")
+    current_time = datetime.now()
+
+    metadata = _load_metadata(metadata_path)
+
+    if metadata.last_check and current_time - metadata.last_check <= timedelta(days=1):
+        return
+
+    try:
+        response = requests.get("https://pypi.org/pypi/gcop/json", timeout=1)
+        latest_version = response.json()["info"]["version"]
+
+        metadata = VersionMetadata(
+            last_check=current_time, latest_version=latest_version
+        )
+        with open(metadata_path, "w") as f:
+            json.dump(metadata.to_dict(), f)
+
+        if latest_version != version:
+            should_update = questionary.confirm(
+                f"A new version of gcop is available: {latest_version} "
+                f"(current: {version}). Would you like to update now?"
+            ).ask()
+
+            if should_update:
+                try:
+                    console.print("[yellow]Updating gcop...[/]")
+                    subprocess.run(["pip", "install", "-U", "gcop"], check=True)
+                    console.print("[green]Update successful![/]")
+                    subprocess.run(["gcop", "init"], check=True)
+                    console.print("[green]GCOP reinitialized successfully![/]")
+                except subprocess.CalledProcessError as e:
+                    console.print(f"[red]Failed to update gcop: {e}[/]")
+
+    except Exception:
+        pass

pyproject.toml

@@ -5,7 +5,7 @@ requires = ["poetry-core"]
 
 [tool.poetry]
 name = "gcop"
-version = "1.5.1"
+version = "1.6.0"
 description = "gcop is your git AI copilot."
 readme = "README.md"
 authors = ["gcop <zeeland4work@gmail.com>"]