gitauto-cli 1.1.0__py3-none-any.whl

gitauto.py

@@ -0,0 +1,708 @@
+#!/usr/bin/env python3
+"""
+GitAuto — AI-powered git workflow automation.
+
+Usage:
+    gitauto                  Run full workflow (add → commit → push)
+    gitauto setup            Configure AI provider and API key
+    gitauto --no-push        Skip push step
+    gitauto --no-ai          Skip AI commit message generation
+    gitauto --force-push     Force push to remote (destructive)
+    gitauto --branch <n>     Switch to or create branch before committing
+    gitauto -v / --version   Print version
+"""
+
+import importlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, NamedTuple, Optional
+
+__version__ = "1.1.0"
+
+AI_VENV     = Path.home() / ".gitauto" / "ai_venv"
+CONFIG_DIR  = Path.home() / ".gitauto"
+CONFIG_FILE = CONFIG_DIR  / "config.json"
+
+SUPPORTED_PROVIDERS = ("openai", "anthropic", "gemini")
+
+
+class CommandResult(NamedTuple):
+    ok:     bool
+    stdout: str
+    stderr: str
+
+
+class Colors:
+    HEADER = "\033[95m"
+    CYAN   = "\033[96m"
+    GREEN  = "\033[92m"
+    YELLOW = "\033[93m"
+    RED    = "\033[91m"
+    END    = "\033[0m"
+    BOLD   = "\033[1m"
+
+
+def _venv_site_packages(venv: Path) -> Optional[Path]:
+    if os.name == "nt":
+        candidate = venv / "Lib" / "site-packages"
+    else:
+        pyver     = f"{sys.version_info.major}.{sys.version_info.minor}"
+        candidate = venv / "lib" / f"python{pyver}" / "site-packages"
+    return candidate if candidate.exists() else None
+
+
+def _inject_venv_path(venv: Path) -> None:
+    site_pkg = _venv_site_packages(venv)
+    if site_pkg and str(site_pkg) not in sys.path:
+        sys.path.insert(0, str(site_pkg))
+
+
+if AI_VENV.exists():
+    _inject_venv_path(AI_VENV)
+
+
+class GitAuto:
+    def __init__(self, *, no_push: bool = False, no_ai: bool = False,
+                 force_push: bool = False, branch: Optional[str] = None) -> None:
+        self.no_push       = no_push
+        self.no_ai         = no_ai
+        self.force_push    = force_push
+        self.target_branch = branch
+        self.config        = self._load_config()
+        self.interactive   = sys.stdin.isatty()
+
+    def _load_config(self) -> dict:
+        if CONFIG_FILE.exists():
+            try:
+                return json.loads(CONFIG_FILE.read_text())
+            except (json.JSONDecodeError, OSError) as exc:
+                self._print_warning(f"Could not read config ({exc}); starting fresh.")
+        return {}
+
+    def _save_config(self, config: dict) -> None:
+        CONFIG_DIR.mkdir(exist_ok=True)
+        CONFIG_FILE.write_text(json.dumps(config))
+        try:
+            os.chmod(CONFIG_FILE, 0o600)
+        except OSError:
+            pass
+        self.config = config
+
+    @property
+    def api_key(self) -> Optional[str]:
+        return self.config.get("api_key")
+
+    @property
+    def provider(self) -> Optional[str]:
+        return self.config.get("provider")
+
+    def _print_header(self, text: str) -> None:
+        bar = "=" * 32
+        print(f"\n{Colors.HEADER}{Colors.BOLD}{bar}{Colors.END}")
+        print(f"{Colors.HEADER}{Colors.BOLD}{text.center(32)}{Colors.END}")
+        print(f"{Colors.HEADER}{Colors.BOLD}{bar}{Colors.END}\n")
+
+    def _print_success(self, text: str) -> None:
+        print(f"{Colors.GREEN}✓ {text}{Colors.END}")
+
+    def _print_error(self, text: str) -> None:
+        print(f"{Colors.RED}✗ {text}{Colors.END}")
+
+    def _print_info(self, text: str) -> None:
+        print(f"{Colors.CYAN}ℹ {text}{Colors.END}")
+
+    def _print_warning(self, text: str) -> None:
+        print(f"{Colors.YELLOW}⚠ {text}{Colors.END}")
+
+    def _run(self, command: List[str], *, capture: bool = True) -> CommandResult:
+        try:
+            if capture:
+                result = subprocess.run(command, capture_output=True, text=True, check=False)
+                return CommandResult(result.returncode == 0, result.stdout.strip(), result.stderr.strip())
+            result = subprocess.run(command, check=False)
+            return CommandResult(result.returncode == 0, "", "")
+        except OSError as exc:
+            return CommandResult(False, "", str(exc))
+
+    def is_git_repo(self) -> bool:
+        return self._run(["git", "rev-parse", "--git-dir"]).ok
+
+    def get_status(self) -> str:
+        result = self._run(["git", "status", "--short"])
+        return result.stdout if result.ok else ""
+
+    def get_diff(self) -> str:
+        result = self._run(["git", "diff", "--cached"])
+        if result.ok and result.stdout:
+            return result.stdout
+        result = self._run(["git", "diff"])
+        return result.stdout if result.ok else ""
+
+    def get_current_branch(self) -> str:
+        result = self._run(["git", "branch", "--show-current"])
+        return result.stdout if result.ok else "main"
+
+    def get_remote_url(self) -> str:
+        result = self._run(["git", "remote", "get-url", "origin"])
+        return result.stdout if result.ok else "No remote configured"
+
+    def _ensure_ai_library(self, provider: str) -> None:
+        install_map = {
+            "openai":    ("openai",    "openai"),
+            "anthropic": ("anthropic", "anthropic"),
+            "gemini":    ("google.genai", "google-genai"),
+        }
+        module_name, package_name = install_map[provider]
+        if provider == "gemini":
+            self._ensure_gemini_venv(package_name)
+            return
+        try:
+            importlib.import_module(module_name)
+        except ImportError:
+            self._print_info(f"Installing {package_name}...")
+            try:
+                subprocess.check_call(
+                    [sys.executable, "-m", "pip", "install", "--quiet", package_name]
+                )
+            except subprocess.CalledProcessError as exc:
+                raise RuntimeError(f"Failed to install {package_name}: {exc}") from exc
+
+    def _ensure_gemini_venv(self, package_name: str) -> None:
+        if not AI_VENV.exists():
+            self._print_info("Creating Gemini virtual environment...")
+            subprocess.check_call([sys.executable, "-m", "venv", str(AI_VENV)])
+        try:
+            importlib.import_module("google.genai")
+        except ImportError:
+            self._print_info("Installing Gemini AI in venv...")
+            python_bin = (
+                AI_VENV / "Scripts" / "python.exe"
+                if os.name == "nt"
+                else AI_VENV / "bin" / "python"
+            )
+            try:
+                subprocess.check_call(
+                    [str(python_bin), "-m", "pip", "install", "--quiet", package_name]
+                )
+            except subprocess.CalledProcessError as exc:
+                raise RuntimeError(f"Failed to install {package_name}: {exc}") from exc
+            _inject_venv_path(AI_VENV)
+
+    def generate_commit_message(self, diff: str) -> Optional[str]:
+        if not self.api_key or not self.provider:
+            return None
+        try:
+            self._ensure_ai_library(self.provider)
+        except RuntimeError as exc:
+            self._print_error(str(exc))
+            return None
+        prompt = (
+            "Generate a very short (one-line, imperative tense, <=50 chars) "
+            "git commit message summarising the changes below:\n\n"
+            f"{diff[:3000]}"
+        )
+        try:
+            return self._call_ai(prompt)
+        except Exception as exc:
+            self._handle_ai_error(exc)
+            return None
+
+    def _handle_ai_error(self, exc: Exception) -> None:
+        msg = str(exc).lower()
+        if "credit balance is too low" in msg or "insufficient_quota" in msg:
+            self._print_error("AI API credits exhausted.")
+            self._print_info("Top up your account and retry, or run: gitauto --no-ai")
+            if self.provider == "anthropic":
+                self._print_info("Billing: https://console.anthropic.com/settings/billing")
+            elif self.provider == "openai":
+                self._print_info("Billing: https://platform.openai.com/account/billing")
+        elif "invalid api key" in msg or "authentication" in msg or "401" in msg:
+            self._print_error("Invalid API key.")
+            self._print_info("Reconfigure with: gitauto setup")
+        elif "rate limit" in msg or "429" in msg:
+            self._print_error("AI rate limit hit.")
+            self._print_info("Wait a moment and retry, or run: gitauto --no-ai")
+        else:
+            self._print_error(f"AI generation failed: {exc}")
+
+    def _call_ai(self, prompt: str) -> Optional[str]:
+        if self.provider == "openai":
+            import openai
+            client   = openai.OpenAI(api_key=self.api_key)
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=50,
+            )
+            return response.choices[0].message.content.strip()
+
+        if self.provider == "anthropic":
+            import anthropic
+            client = anthropic.Anthropic(api_key=self.api_key)
+            msg    = client.messages.create(
+                model="claude-3-5-sonnet-20241022",
+                max_tokens=100,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            return msg.content[0].text.strip()
+
+        if self.provider == "gemini":
+            genai  = importlib.import_module("google.genai")
+            client = genai.Client(api_key=self.api_key)
+            response = client.models.generate_content(
+                model="gemini-2.5-flash",
+                contents=prompt,
+            )
+            return response.text.strip() if response.text else None
+
+        raise ValueError(f"Unknown provider: {self.provider!r}")
+
+    def _get_commit_message(self) -> Optional[str]:
+        use_ai = bool(self.api_key and self.provider and not self.no_ai)
+
+        if not self.interactive:
+            return (
+                self.generate_commit_message(self.get_diff()) if use_ai else None
+            ) or "Auto commit"
+
+        if not use_ai:
+            if not self.no_ai:
+                self._print_warning("AI not configured -- run: gitauto setup")
+            return input("Commit message: ").strip() or None
+
+        if input("Generate commit message with AI? (y/n) [y]: ").strip().lower() not in ("", "y"):
+            return input("Commit message: ").strip() or None
+
+        diff = self.get_diff()
+        if not diff:
+            self._print_warning("Nothing staged -- enter message manually.")
+            return input("Commit message: ").strip() or None
+
+        while True:
+            self._print_info(f"Generating via {self.provider}...")
+            msg = self.generate_commit_message(diff)
+
+            if not msg:
+                self._print_info("Falling back to manual input.")
+                return input("Commit message: ").strip() or None
+
+            print(f"\n  {Colors.GREEN}{msg}{Colors.END}")
+            choice = input("Use this? (y / r=regenerate / m=manual) [y]: ").strip().lower() or "y"
+
+            if choice == "y":
+                return msg
+            if choice == "r":
+                continue
+            return input("Commit message: ").strip() or None
+
+    def _push(self, branch: str) -> bool:
+        if self.force_push:
+            self._print_warning("Force pushing -- this overwrites remote history.")
+            result = self._run(["git", "push", "--force", "origin", branch])
+            if result.ok:
+                self._print_success(f"Force-pushed to origin/{branch}")
+                return True
+            self._print_error(f"Force push failed: {result.stderr}")
+            return False
+
+        self._print_info(f"Pushing to origin/{branch}...")
+        result = self._run(["git", "push", "origin", branch])
+        if result.ok:
+            self._print_success(f"Pushed to origin/{branch}")
+            return True
+
+        if "has no upstream" in result.stderr or "no upstream" in result.stderr.lower():
+            self._print_info("New branch -- setting upstream automatically...")
+            result = self._run(["git", "push", "--set-upstream", "origin", branch])
+            if result.ok:
+                self._print_success(f"Pushed and upstream set for origin/{branch}")
+                return True
+            self._print_error(f"Failed to set upstream: {result.stderr}")
+            return False
+
+        rejected = any(
+            k in result.stderr.lower()
+            for k in ("fetch first", "non-fast-forward", "rejected")
+        )
+        if rejected:
+            self._print_info("Remote has new commits -- rebasing automatically...")
+            rebase = self._run(["git", "pull", "--rebase", "origin", branch])
+            if not rebase.ok:
+                self._print_error("Auto-rebase failed -- conflicts need manual resolution.")
+                self._print_info("Your repo is in rebase state. To resolve:")
+                self._print_info("  1. Open conflicted files and fix the markers")
+                self._print_info("  2. git add .")
+                self._print_info("  3. git rebase --continue")
+                self._print_info(f"  4. git push origin {branch}")
+                self._print_info("Or to cancel: git rebase --abort")
+                return False
+
+            result = self._run(["git", "push", "origin", branch])
+            if result.ok:
+                self._print_success(f"Pushed to origin/{branch} after rebase.")
+                return True
+            self._print_error(f"Push failed after rebase: {result.stderr}")
+            return False
+
+        self._print_error(f"Push failed: {result.stderr}")
+        return False
+
+    def _switch_branch(self, name: str) -> str:
+        result = self._run(["git", "checkout", name])
+        if result.ok:
+            self._print_success(f"Switched to branch: {name}")
+            return name
+
+        self._print_info(f"Branch '{name}' not found -- creating it...")
+        result = self._run(["git", "checkout", "-b", name])
+        if result.ok:
+            self._print_success(f"Created and switched to: {name}")
+            return name
+
+        self._print_error(f"Could not switch/create branch '{name}': {result.stderr}")
+        return self.get_current_branch()
+
+    def setup_ai(self) -> None:
+        self._print_header("GitAuto AI Setup")
+        raw = input(f"Provider ({'/'.join(SUPPORTED_PROVIDERS)}): ").strip().lower()
+        if raw not in SUPPORTED_PROVIDERS:
+            self._print_warning("Unrecognised provider. Skipped.")
+            return
+        api_key = input(f"API key for {raw}: ").strip()
+        if not api_key:
+            self._print_warning("No API key entered. Skipped.")
+            return
+        self._save_config({"provider": raw, "api_key": api_key})
+        self._print_success(f"{raw} configured successfully.")
+
+    def run(self) -> None:
+        self._print_header(f"GitAuto v{__version__}")
+
+        if not self.is_git_repo():
+            self._print_error("Not a git repository. Run 'git init' first.")
+            sys.exit(1)
+
+        self._print_info(f"Remote : {self.get_remote_url()}")
+
+        current_branch = self.get_current_branch()
+        if self.target_branch and self.target_branch != current_branch:
+            current_branch = self._switch_branch(self.target_branch)
+
+        self._print_info(f"Branch : {current_branch}")
+
+        status = self.get_status()
+        if not status:
+            self._print_warning("No changes detected -- nothing to commit.")
+            sys.exit(0)
+
+        print(f"\n{Colors.CYAN}Changes:{Colors.END}\n{status}\n")
+
+        files = "."
+        if self.interactive:
+            files = input("Files to add (. for all) [.]: ").strip() or "."
+
+        add_cmd = ["git", "add"] + (["."] if files == "." else files.split())
+        result  = self._run(add_cmd)
+        if not result.ok:
+            self._print_error(f"Failed to stage files: {result.stderr}")
+            sys.exit(1)
+        self._print_success(f"Staged: {files}")
+
+        commit_message = self._get_commit_message()
+        if not commit_message:
+            self._print_error("Commit message cannot be empty.")
+            sys.exit(1)
+
+        result = self._run(["git", "commit", "-m", commit_message])
+        if not result.ok:
+            self._print_error(f"Commit failed: {result.stderr}")
+            sys.exit(1)
+        self._print_success(f"Committed: {commit_message}")
+
+        if self.no_push:
+            self._print_info("Skipping push (--no-push).")
+            self._print_header("Done!")
+            return
+
+        do_push = True
+        if self.interactive:
+            do_push = input("Push to remote? (y/n) [y]: ").strip().lower() in ("", "y")
+
+        if do_push:
+            self._push(current_branch)
+
+        self._print_header("Done!")
+
+
+
+# ---------------------------------------------------------------------------
+# CLI strings
+# ---------------------------------------------------------------------------
+
+HELP_TEXT = (
+    "\n"
+    "\033[95m\033[1m  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\033[0m\n"
+    "\033[95m\033[1m  \u2551    GitAuto \u2014 AI Git Automation       \u2551\033[0m\n"
+    "\033[95m\033[1m  \u255a\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d\033[0m\n"
+    "\n"
+    "\033[96m  Commands:\033[0m\n"
+    "  gitauto                  Run full workflow  (add -> commit -> push)\n"
+    "  gitauto setup            Configure AI provider and API key\n"
+    "  gitauto upgrade          Upgrade to the latest version\n"
+    "  gitauto uninstall        Remove GitAuto from your system\n"
+    "\n"
+    "\033[96m  Options:\033[0m\n"
+    "  --no-push                Commit only, skip push\n"
+    "  --no-ai                  Skip AI, enter commit message manually\n"
+    "  --force-push             Force push to remote  (destructive)\n"
+    "  --branch, -b <n>      Switch to or create branch before committing\n"
+    "  -v, --version            Print current version\n"
+    "  -h, --help               Show this message\n"
+    "\n"
+    "\033[96m  Examples:\033[0m\n"
+    "  gitauto                          Full AI-powered workflow\n"
+    "  gitauto --no-push                Commit only, no push\n"
+    "  gitauto --branch feature/login   Switch branch then commit and push\n"
+    "  gitauto --force-push             Force push current branch\n"
+    "  gitauto --no-ai                  Manual commit message, no AI\n"
+    "\n"
+    "\033[93m  Tip: Run 'gitauto setup' first to configure your AI provider.\033[0m\n"
+)
+
+WELCOME_TEXT = (
+    "\n"
+    "\033[92m\033[1m  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\033[0m\n"
+    "\033[92m\033[1m  \u2551     GitAuto is ready to use!         \u2551\033[0m\n"
+    "\033[92m\033[1m  \u255a\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d\033[0m\n"
+    "\n"
+    "\033[96m  Available commands:\033[0m\n"
+    "  gitauto                Run full workflow  (add -> commit -> push)\n"
+    "  gitauto setup          Configure AI provider and API key\n"
+    "  gitauto upgrade        Upgrade to the latest version\n"
+    "  gitauto uninstall      Remove GitAuto from your system\n"
+    "  gitauto --no-push      Commit only, skip push\n"
+    "  gitauto --no-ai        Skip AI, enter commit message manually\n"
+    "  gitauto --force-push   Force push  (destructive)\n"
+    "  gitauto --branch <n>   Switch or create branch before committing\n"
+    "  gitauto --help         Show all commands and options\n"
+    "\n"
+    "\033[93m  Get started:  gitauto setup\033[0m\n"
+)
+
+# Known valid arguments — anything outside this set is rejected
+_VALID_ARGS = {
+    "-v", "--version",
+    "-h", "--help",
+    "setup", "--setup",
+    "upgrade", "--upgrade",
+    "uninstall", "--uninstall",
+    "--no-push",
+    "--no-ai",
+    "--force-push",
+    "--branch", "-b",
+    "--pre-commit", "--commit-msg",  # git hook passthrough
+}
+
+# Shell rc files the old install.sh may have written to
+_RC_FILES = [
+    Path.home() / ".bashrc",
+    Path.home() / ".bash_profile",
+    Path.home() / ".zshrc",
+]
+_OLD_PATH_LINE    = 'export PATH="$HOME/.local/bin:$PATH"'
+_OLD_PATH_COMMENT = "# Added by GitAuto installer"
+
+
+# ---------------------------------------------------------------------------
+# CLI helpers
+# ---------------------------------------------------------------------------
+
+
+def _print_help() -> None:
+    print(HELP_TEXT)
+
+
+def _first_run_check() -> None:
+    """Print welcome message exactly once after fresh install."""
+    marker = CONFIG_DIR / ".welcomed"
+    if not marker.exists():
+        print(WELCOME_TEXT)
+        CONFIG_DIR.mkdir(exist_ok=True)
+        marker.touch()
+
+
+def _find_pipx() -> Optional[str]:
+    import shutil
+    return shutil.which("pipx")
+
+
+def _run_pipx(*args: str) -> int:
+    pipx = _find_pipx()
+    if not pipx:
+        print(f"{Colors.RED}pipx not found. Install it: pip install pipx{Colors.END}")
+        return 1
+    return subprocess.run([pipx, *args], check=False).returncode
+
+
+def _clean_old_rc_entries() -> None:
+    """Remove PATH lines written by the old install.sh from shell rc files."""
+    cleaned_any = False
+    for rcfile in _RC_FILES:
+        if not rcfile.exists():
+            continue
+        lines = rcfile.read_text().splitlines(keepends=True)
+        filtered = [
+            line for line in lines
+            if _OLD_PATH_COMMENT not in line and _OLD_PATH_LINE not in line
+        ]
+        if len(filtered) != len(lines):
+            rcfile.write_text("".join(filtered))
+            print(f"{Colors.GREEN}✓ Cleaned old PATH entry from {rcfile}{Colors.END}")
+            cleaned_any = True
+    if not cleaned_any:
+        print(f"{Colors.CYAN}ℹ No old PATH entries found in shell config files.{Colors.END}")
+
+
+def _cmd_upgrade() -> None:
+    print(f"{Colors.CYAN}ℹ Upgrading GitAuto via pipx...{Colors.END}")
+    code = _run_pipx("upgrade", "gitauto")
+    if code == 0:
+        print(f"{Colors.GREEN}✓ GitAuto upgraded successfully.{Colors.END}")
+    else:
+        print(f"{Colors.RED}✗ Upgrade failed. Try manually: pipx upgrade gitauto{Colors.END}")
+    sys.exit(code)
+
+
+def _cmd_uninstall() -> None:
+    print(f"{Colors.YELLOW}⚠ This will remove GitAuto and all its data.{Colors.END}")
+    confirm = input("Are you sure? (y/N): ").strip().lower()
+    if confirm != "y":
+        print(f"{Colors.CYAN}ℹ Uninstall cancelled.{Colors.END}")
+        sys.exit(0)
+
+    import shutil as _shutil
+    if CONFIG_DIR.exists():
+        _shutil.rmtree(CONFIG_DIR)
+        print(f"{Colors.GREEN}✓ Removed config: {CONFIG_DIR}{Colors.END}")
+
+    _clean_old_rc_entries()
+
+    print(f"{Colors.CYAN}ℹ Running: pipx uninstall gitauto{Colors.END}")
+    code = _run_pipx("uninstall", "gitauto")
+    if code == 0:
+        print(f"{Colors.GREEN}✓ GitAuto uninstalled successfully.{Colors.END}")
+        print(f"{Colors.CYAN}ℹ Restart your shell: exec $SHELL{Colors.END}")
+    else:
+        print(f"{Colors.RED}✗ pipx uninstall failed. Try: pipx uninstall gitauto{Colors.END}")
+    sys.exit(code)
+
+
+# ---------------------------------------------------------------------------
+# Argument parser
+# ---------------------------------------------------------------------------
+
+
+def _parse_args() -> dict:
+    args = sys.argv[1:]
+    opts: dict = {
+        "no_push":    False,
+        "no_ai":      False,
+        "force_push": False,
+        "branch":     None,
+        "setup":      False,
+        "version":    False,
+        "help":       False,
+        "upgrade":    False,
+        "uninstall":  False,
+    }
+
+    i = 0
+    while i < len(args):
+        a = args[i].lower()
+
+        # Reject anything that is not a known argument
+        if a not in _VALID_ARGS:
+            print(f"{Colors.RED}✗ Unknown argument: '{args[i]}'{Colors.END}")
+            print(f"{Colors.CYAN}ℹ Run 'gitauto --help' to see valid commands.{Colors.END}")
+            sys.exit(1)
+
+        if a in ("-v", "--version"):
+            opts["version"] = True
+        elif a in ("-h", "--help"):
+            opts["help"] = True
+        elif a in ("setup", "--setup"):
+            opts["setup"] = True
+        elif a in ("upgrade", "--upgrade"):
+            opts["upgrade"] = True
+        elif a in ("uninstall", "--uninstall"):
+            opts["uninstall"] = True
+        elif a == "--no-push":
+            opts["no_push"] = True
+        elif a == "--no-ai":
+            opts["no_ai"] = True
+        elif a == "--force-push":
+            opts["force_push"] = True
+        elif a in ("--branch", "-b"):
+            i += 1
+            if i >= len(args):
+                print(f"{Colors.RED}✗ --branch requires a branch name.{Colors.END}")
+                sys.exit(1)
+            opts["branch"] = args[i]
+        elif a in ("--pre-commit", "--commit-msg"):
+            sys.exit(0)
+
+        i += 1
+
+    return opts
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    opts = _parse_args()
+
+    if opts["help"]:
+        _print_help()
+        sys.exit(0)
+
+    if opts["version"]:
+        print(f"GitAuto v{__version__}")
+        sys.exit(0)
+
+    if opts["upgrade"]:
+        _cmd_upgrade()
+
+    if opts["uninstall"]:
+        _cmd_uninstall()
+
+    _first_run_check()
+
+    bot = GitAuto(
+        no_push=opts["no_push"],
+        no_ai=opts["no_ai"],
+        force_push=opts["force_push"],
+        branch=opts["branch"],
+    )
+
+    if opts["setup"]:
+        bot.setup_ai()
+        sys.exit(0)
+
+    try:
+        bot.run()
+    except KeyboardInterrupt:
+        print(f"\n{Colors.YELLOW}Aborted.{Colors.END}")
+        sys.exit(1)
+    except Exception as exc:
+        print(f"\n{Colors.RED}Unexpected error: {exc}{Colors.END}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

gitauto_cli-1.1.0.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: gitauto-cli
+Version: 1.1.0
+Summary: AI-powered git workflow automation
+License: MIT
+Keywords: git,automation,ai,cli,devtools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# GitAuto
+
+![Version](https://img.shields.io/badge/version-1.1.0-blue)
+![Python](https://img.shields.io/badge/Python-3.8%2B-blue)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+AI-powered Git workflow automation. Stage, commit, and push in one command.
+
+---
+
+## Install
+
+```bash
+pipx install gitauto-cli
+```
+
+> Need pipx? `pip install pipx && pipx ensurepath && exec $SHELL`
+
+---
+
+## Setup
+
+```bash
+gitauto setup
+```
+
+Choose a provider (OpenAI / Anthropic / Gemini) and paste your API key. Skippable — works without AI too.
+
+---
+
+## Usage
+
+```bash
+gitauto
+```
+
+```
+Changes:
+ M src/app.py
+
+Files to add (. for all) [.]: .
+✓ Staged: .
+
+Generate commit message with AI? (y/n) [y]: y
+ℹ Generating via anthropic...
+
+  Add input validation to user registration
+
+Use this? (y / r=regenerate / m=manual) [y]: y
+✓ Committed: Add input validation to user registration
+
+Push to remote? (y/n) [y]: y
+✓ Pushed to origin/main
+```
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `gitauto` | Full workflow — add → commit → push |
+| `gitauto setup` | Configure AI provider and API key |
+| `gitauto upgrade` | Upgrade to latest version |
+| `gitauto uninstall` | Remove GitAuto from your system |
+| `gitauto --no-push` | Commit only, skip push |
+| `gitauto --no-ai` | Skip AI, type message manually |
+| `gitauto --force-push` | Force push ⚠️ destructive |
+| `gitauto --branch <n>` | Switch or create branch before committing |
+| `gitauto --help` | Show all commands |
+
+---
+
+## License
+
+MIT

gitauto_cli-1.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+gitauto.py,sha256=FCUqRRL6hmVNNHYRnvlSGnd9reWYiQN8ACr7JZE6FcI,26479
+gitauto_cli-1.1.0.dist-info/licenses/LICENSE.md,sha256=zvNKRgvo41DB3YYVH-vqDdvpgOMYKSr57FJ3r0Fs2T8,1005
+gitauto_cli-1.1.0.dist-info/METADATA,sha256=oo3_ntivyqIsouiBQzoKjdjvrjgVQ55a18Z-gmunSns,2153
+gitauto_cli-1.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+gitauto_cli-1.1.0.dist-info/entry_points.txt,sha256=FArNKL5QoSyQtjf1W0cG-Q3_XW9JSZXKXFDTssRJG2o,41
+gitauto_cli-1.1.0.dist-info/top_level.txt,sha256=b2_wnEEruSNF-EJN5w08ofYBX0kZclHTS5dSESvuJR8,8
+gitauto_cli-1.1.0.dist-info/RECORD,,

gitauto_cli-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gitauto_cli-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gitauto = gitauto:main

gitauto_cli-1.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+GitAuto – Non-Commercial License (2025)
+
+Copyright (c) 2025 Wizdomic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software **for personal, educational, or
+non-commercial purposes only**.
+
+Commercial use, sale, or distribution for profit is **strictly prohibited**.
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING
+FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE..

gitauto_cli-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gitauto