smart-commit-tool 0.1.0__tar.gz → 1.0.1__tar.gz

smart_commit_tool-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Makar Pavlovich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+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.

smart_commit_tool-1.0.1/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: smart-commit-tool
+Version: 1.0.1
+Summary: Automated pre-push workflow manager with built-in code quality enforcement and smart branch protection.
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: colorama
+Requires-Dist: tomli; python_version < '3.11'
+Description-Content-Type: text/markdown
+
+# 🚀 Smart Commit
+
+[English](README.md) | [Русский](README.ru.md)
+
+**Smart Commit** is a universal CLI tool designed to streamline and secure your Git workflow. It orchestrates linting, testing, committing, and pushing into a single, bulletproof operation.
+
+**The Golden Rule:** If your tests fail, your code doesn't ship.
+
+---
+
+## ✨ Key Features
+
+* 🌍 **Language Agnostic**: Works seamlessly with Python, JS, Go, Rust, Dart, or any other stack.
+* ⚡ **All-in-One Command**: Replaces the tedious `lint -> test -> add -> commit -> push` routine.
+* 🛡️ **Branch Protection**: Safeguards your `main`, `master`, or `prod` branches from accidental direct pushes.
+* 🔧 **Zero-Setup**: Install via `pip` and configure in under a minute using a single file.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install smart-commit-tool
+
+```
+
+> **Note:** Once installed, the tool is available via the simple and concise `smart-commit` command.
+
+---
+
+## 🔧 Configuration (`pyproject.toml`)
+
+Smart Commit leverages `pyproject.toml` for its configuration. Simply create this file in your project root (even if you aren't using Python for your main project).
+
+```toml
+[tool.smart_commit]
+repository_url = "https://github.com/youruser/yourrepo.git"
+protected_branches = ["main", "master", "prod"]
+
+# List any shell commands you want to run BEFORE the push.
+# If any command returns a non-zero exit code, the process aborts.
+commands = [
+    "ruff check .",      # Python Linter
+    "pytest -v",         # Python Tests
+    "npm run lint",      # Node.js Linter
+    "go test ./..."      # Go Tests
+]
+
+```
+
+---
+
+## 🚀 Usage
+
+Navigate to your project root (where your `pyproject.toml` is located) and run:
+
+```bash
+smart-commit
+
+```
+
+### CLI Arguments
+
+| Flag | Description |
+| --- | --- |
+| `-b, --branch` | Specify target branch (skips interactive prompt) |
+| `-m, --message` | Set commit message (skips interactive prompt) |
+
+---
+
+## 🔄 How It Works (The Algorithm)
+
+1. **Environment Sanity Check**: Verifies Git initialization and remote repository connectivity.
+2. **Branch Guard**: If you attempt to push to a protected branch, the tool prompts you to create a new feature branch instead.
+3. **Pre-push Validation**: Sequentially executes your defined `commands`. If any step fails, the entire process stops immediately to keep your remote clean.
+4. **Optimized Push**: Automatically handles `add` and `commit`. If the remote branch has moved forward, it helps you `rebase` to ensure a linear, clean history.
+
+---
+
+## 📄 License
+Distributed under the MIT License. Feel free to use, modify, and share!

smart_commit_tool-1.0.1/README.md

@@ -0,0 +1,81 @@
+# 🚀 Smart Commit
+
+[English](README.md) | [Русский](README.ru.md)
+
+**Smart Commit** is a universal CLI tool designed to streamline and secure your Git workflow. It orchestrates linting, testing, committing, and pushing into a single, bulletproof operation.
+
+**The Golden Rule:** If your tests fail, your code doesn't ship.
+
+---
+
+## ✨ Key Features
+
+* 🌍 **Language Agnostic**: Works seamlessly with Python, JS, Go, Rust, Dart, or any other stack.
+* ⚡ **All-in-One Command**: Replaces the tedious `lint -> test -> add -> commit -> push` routine.
+* 🛡️ **Branch Protection**: Safeguards your `main`, `master`, or `prod` branches from accidental direct pushes.
+* 🔧 **Zero-Setup**: Install via `pip` and configure in under a minute using a single file.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install smart-commit-tool
+
+```
+
+> **Note:** Once installed, the tool is available via the simple and concise `smart-commit` command.
+
+---
+
+## 🔧 Configuration (`pyproject.toml`)
+
+Smart Commit leverages `pyproject.toml` for its configuration. Simply create this file in your project root (even if you aren't using Python for your main project).
+
+```toml
+[tool.smart_commit]
+repository_url = "https://github.com/youruser/yourrepo.git"
+protected_branches = ["main", "master", "prod"]
+
+# List any shell commands you want to run BEFORE the push.
+# If any command returns a non-zero exit code, the process aborts.
+commands = [
+    "ruff check .",      # Python Linter
+    "pytest -v",         # Python Tests
+    "npm run lint",      # Node.js Linter
+    "go test ./..."      # Go Tests
+]
+
+```
+
+---
+
+## 🚀 Usage
+
+Navigate to your project root (where your `pyproject.toml` is located) and run:
+
+```bash
+smart-commit
+
+```
+
+### CLI Arguments
+
+| Flag | Description |
+| --- | --- |
+| `-b, --branch` | Specify target branch (skips interactive prompt) |
+| `-m, --message` | Set commit message (skips interactive prompt) |
+
+---
+
+## 🔄 How It Works (The Algorithm)
+
+1. **Environment Sanity Check**: Verifies Git initialization and remote repository connectivity.
+2. **Branch Guard**: If you attempt to push to a protected branch, the tool prompts you to create a new feature branch instead.
+3. **Pre-push Validation**: Sequentially executes your defined `commands`. If any step fails, the entire process stops immediately to keep your remote clean.
+4. **Optimized Push**: Automatically handles `add` and `commit`. If the remote branch has moved forward, it helps you `rebase` to ensure a linear, clean history.
+
+---
+
+## 📄 License
+Distributed under the MIT License. Feel free to use, modify, and share!

smart_commit_tool-1.0.1/README.ru.md

@@ -0,0 +1,80 @@
+# 🚀 Smart Commit
+[English](README.md) | [Русский](README.ru.md)
+
+**Smart Commit** — это универсальный CLI-инструмент для автоматизации Git-воркфлоу. Он объединяет проверки, тесты, коммит и пуш в одну безопасную операцию.
+
+**Главный принцип:** если тесты не прошли — код не улетит в репозиторий.
+
+---
+
+## ✨ Почему это удобно?
+
+* 🌍 **Языковой агностик**: Работает с Python, JS, Go, Rust, Dart и любым другим стеком.
+* ⚡ **Всё в одной команде**: Заменяет рутину `lint -> test -> add -> commit -> push`.
+* 🛡️ **Защита веток**: Больше никаких случайных пушей в `main` или `prod`.
+* 🔧 **Zero-Setup**: Устанавливается через `pip`, настраивается за 1 минуту в одном файле.
+
+---
+
+## 📦 Установка
+
+```bash
+pip install smart-commit-tool
+
+```
+
+> **Важно:** После установки вам доступна короткая и удобная команда `smart-commit`.
+
+---
+
+## 🔧 Настройка (pyproject.toml)
+
+Инструмент использует файл `pyproject.toml` для конфигурации. Создайте его в корне вашего проекта (даже если вы не пишете на Python).
+
+```toml
+[tool.smart_commit]
+repository_url = "https://github.com/youruser/yourrepo.git"
+protected_branches = ["main", "master", "prod"]
+
+# Здесь вы просто перечисляете через запятую любые консольные команды,
+# которые должны успешно выполниться ПЕРЕД тем, как код уйдет в Git.
+commands = [
+    "ruff check .",      # Линтер
+    "pytest -v",         # Тесты
+    "npm run lint",      # Можно запускать команды любого языка!
+    "go test ./..."      # Инструмент универсален
+]
+
+```
+
+---
+
+## 🚀 Как пользоваться
+
+Перейдите в папку проекта, где лежит ваш `pyproject.toml`, и запустите:
+
+```bash
+smart-commit
+
+```
+
+### Параметры запуска
+
+| Флаг | Описание |
+| --- | --- |
+| `-b, --branch` | Сразу указать ветку (пропустит интерактивный выбор) |
+| `-m, --message` | Сразу указать сообщение коммита |
+
+---
+
+## 🔄 Как это работает (Алгоритм)
+
+1. **Проверка окружения**: Инструмент проверяет наличие Git и связь с удаленным репозиторием.
+2. **Branch Guard**: Если вы пытаетесь пушить в защищенную ветку (`main`), скрипт предложит создать новую ветку.
+3. **Валидация (Pre-push)**: Последовательно запускаются ваши `commands`. Если любая из них вернет ошибку — процесс мгновенно прерывается.
+4. **Умный Push**: Инструмент сам сделает `add`, `commit` и отправит код. Если на сервере появились новые изменения, он предложит сделать `rebase`, чтобы история оставалась чистой.
+
+---
+
+## 📄 Лицензия
+Распространяется под лицензией **MIT**. Пользуйтесь, меняйте и делитесь с друзьями!

{smart_commit_tool-0.1.0 → smart_commit_tool-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smart-commit-tool"
-version = "0.1.0"
+version = "1.0.1"
 description = "Automated pre-push workflow manager with built-in code quality enforcement and smart branch protection."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -17,7 +17,7 @@ dependencies = [
 smart-commit = "smart_commit.cli:main"
 
 [tool.smart_commit]
-repository_url = "https://github.com/mokinprokin/smart_commit.git"
+repository_url = "https://github.com/mokinprokin/SmartCommit.git"
 commands = ["ruff check ."]
 protected_branches = ["main", "master", "prod", "release"]
 

smart_commit_tool-1.0.1/src/smart_commit/cli.py

@@ -0,0 +1,65 @@
+import argparse
+import sys
+from .exceptions import SmartCommitError
+from .config import ConfigService
+from .services.security import SecurityService
+from .services.git import GitService
+from .services.validator import ValidatorService
+from .logger import Console, logger
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Smart Commit & Push Tool")
+    parser.add_argument("-b", "--branch", help="Specify target branch")
+    parser.add_argument("-m", "--message", help="Commit message")
+    args = parser.parse_args()
+
+    try:
+        logger.info("=== Smart Commit Process Started ===")
+
+        config = ConfigService.load_or_create()
+        protected_branches = config.get("protected_branches", ["main", "master"])
+        commands = config.get("commands", [])
+
+        GitService.ensure_repo()
+        SecurityService.ensure_gitignore()
+        SecurityService.check_env_leaks()
+
+        current_branch = GitService.get_current_branch()
+        branch = args.branch or current_branch
+        GitService.switch_branch(branch)
+        if branch in protected_branches:
+            Console.warning(
+                f"You are pushing directly to a protected branch: '{branch}'."
+            )
+            ans = input("Are you sure you want to continue? [y/N]: ").strip().lower()
+            if ans != "y":
+                raise SmartCommitError("Operation cancelled by user.")
+
+        message = args.message
+        if not message:
+            message = input("📝 Enter commit message: ").strip()
+
+        if not message:
+            raise SmartCommitError("Commit message cannot be empty.")
+
+        ValidatorService.check_conventional_commit(message)
+        if commands:
+            Console.info("--- 🛠 RUNNING PIPELINE (from pyproject.toml) ---")
+            ValidatorService.run_commands(commands)
+
+        Console.info("--- 🚀 FINALIZING COMMIT ---")
+        GitService.smart_stage()
+        GitService.commit(message)
+        GitService.push_with_retry(branch)
+
+    except SmartCommitError as e:
+        Console.error(str(e))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        Console.warning("\nProcess interrupted by user.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

smart_commit_tool-1.0.1/src/smart_commit/config.py

@@ -0,0 +1,50 @@
+import sys
+from pathlib import Path
+from .exceptions import SmartCommitError
+from .logger import Console, logger
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+class ConfigService:
+    DEFAULT_CONFIG = """
+# Auto-generated by Smart Commit
+[tool.smart_commit]
+repository_url = ""
+commands = ["echo 'Running pre-commit pipeline...'"]
+protected_branches = ["main", "master", "prod", "release"]
+"""
+
+    @classmethod
+    def load_or_create(cls) -> dict:
+        """Reads configuration. If the section is missing, appends default settings."""
+        path = Path("pyproject.toml")
+
+        if not path.exists():
+            Console.warning("pyproject.toml not found. Creating a base file...")
+            path.touch()
+
+        try:
+            with open(path, "rb") as f:
+                data = tomllib.load(f)
+        except Exception as e:
+            raise SmartCommitError(f"Failed to parse pyproject.toml: {e}")
+
+        config = data.get("tool", {}).get("smart_commit")
+
+        if config is None:
+            Console.info(
+                "Section [tool.smart_commit] not found. Generating default pipeline..."
+            )
+            logger.info("Appending default tool.smart_commit to pyproject.toml")
+            with open(path, "a", encoding="utf-8") as f:
+                f.write(cls.DEFAULT_CONFIG)
+
+            with open(path, "rb") as f:
+                data = tomllib.load(f)
+            config = data.get("tool", {}).get("smart_commit", {})
+
+        return config

smart_commit_tool-1.0.1/src/smart_commit/exceptions.py

@@ -0,0 +1,14 @@
+class SmartCommitError(Exception):
+    detail = "Unknown error"
+
+    def __init__(self, *args):
+        message = args[0] if args else self.detail
+        super().__init__(message)
+
+
+class GitOperationError(SmartCommitError):
+    detail = "Git execution failed"
+
+
+class ValidationError(SmartCommitError):
+    detail = "Validation check failed"

smart_commit_tool-1.0.1/src/smart_commit/logger.py

@@ -0,0 +1,32 @@
+import logging
+from colorama import init, Fore, Style
+
+init(autoreset=True)
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger("SmartCommit")
+
+
+class Console:
+    @staticmethod
+    def info(msg: str):
+        print(f"{Fore.CYAN}ℹ️  {msg}")
+        logger.info(msg)
+
+    @staticmethod
+    def success(msg: str):
+        print(f"{Fore.GREEN}{Style.BRIGHT}✅ {msg}")
+        logger.info(f"SUCCESS: {msg}")
+
+    @staticmethod
+    def warning(msg: str):
+        print(f"{Fore.YELLOW}⚠️  {msg}")
+        logger.warning(msg)
+
+    @staticmethod
+    def error(msg: str):
+        print(f"{Fore.RED}{Style.BRIGHT}❌ {msg}")
+        logger.error(msg)

smart_commit_tool-1.0.1/src/smart_commit/services/git.py

@@ -0,0 +1,104 @@
+import subprocess
+from pathlib import Path
+from ..exceptions import GitOperationError
+from ..logger import Console, logger
+
+
+class GitService:
+    @classmethod
+    def _run(cls, cmd: list[str], silent: bool = True) -> subprocess.CompletedProcess:
+        """Internal helper for executing Git commands."""
+        logger.debug(f"Git CMD: {' '.join(cmd)}")
+        return subprocess.run(cmd, capture_output=silent, text=True)
+
+    @classmethod
+    def ensure_repo(cls):
+        """Checks for repository initialization and Detached HEAD state."""
+        if not Path(".git").exists():
+            Console.warning("Git not initialized. Initializing now...")
+            cls._run(["git", "init"])
+
+        res = cls._run(["git", "branch", "--show-current"])
+        if not res.stdout.strip():
+            raise GitOperationError(
+                "You are in a DETACHED HEAD state. Process stopped for safety."
+            )
+
+    @classmethod
+    def get_current_branch(cls) -> str:
+        return cls._run(["git", "branch", "--show-current"]).stdout.strip()
+
+    @classmethod
+    def switch_branch(cls, branch: str):
+        """Safely switches to the target branch or creates it."""
+        current = cls.get_current_branch()
+        if current != branch:
+            Console.info(f"🌿 Switching branch: {current} ➔ {branch}")
+            has_commits = cls._run(["git", "rev-parse", "HEAD"]).returncode == 0
+
+            if not has_commits:
+                res = cls._run(["git", "branch", "-M", branch])
+            else:
+                res = cls._run(["git", "checkout", "-B", branch])
+
+            if res.returncode != 0:
+                error_msg = res.stderr.strip() or res.stdout.strip()
+                raise GitOperationError(f"Failed to switch branch: {error_msg}")
+
+    @classmethod
+    def has_staged_changes(cls) -> bool:
+        """Checks if there are files already in the staging area."""
+        res = cls._run(["git", "diff", "--cached", "--quiet"])
+        return res.returncode != 0
+
+    @classmethod
+    def smart_stage(cls):
+        """Intelligent file staging."""
+        if cls.has_staged_changes():
+            Console.info("Staged files detected. Committing current index only.")
+        else:
+            Console.warning("No files in the staging area.")
+            ans = (
+                input("Would you like to stage all changes (git add .)? [y/N]: ")
+                .strip()
+                .lower()
+            )
+            if ans == "y":
+                cls._run(["git", "add", "."])
+            else:
+                raise GitOperationError("Nothing to commit. Operation cancelled.")
+
+    @classmethod
+    def commit(cls, message: str):
+        """Commits changes and extracts Git output if it fails."""
+        res = cls._run(["git", "commit", "-m", message])
+        if res.returncode != 0:
+            error_msg = res.stderr.strip() or res.stdout.strip()
+            raise GitOperationError(f"Commit failed. Git says:\n{error_msg}")
+
+    @classmethod
+    def push_with_retry(cls, branch: str):
+        """Pushes to remote, attempting a pull --rebase if rejected."""
+        Console.info(f"Pushing to branch: {branch}...")
+        res = cls._run(["git", "push", "-u", "origin", branch])
+
+        if res.returncode == 0:
+            Console.success(f"Code successfully pushed to origin/{branch}!")
+            return
+
+        Console.warning("Push rejected. Remote changes detected.")
+        Console.info("Synchronizing (pull --rebase)...")
+        pull_res = cls._run(["git", "pull", "origin", branch, "--rebase"])
+
+        if pull_res.returncode != 0:
+            error_msg = pull_res.stderr.strip() or pull_res.stdout.strip()
+            raise GitOperationError(
+                f"🛑 Rebase conflict detected!\nGit says: {error_msg}"
+            )
+
+        Console.success("Sync successful. Retrying push...")
+        push_retry = cls._run(["git", "push", "-u", "origin", branch])
+
+        if push_retry.returncode != 0:
+            error_msg = push_retry.stderr.strip() or push_retry.stdout.strip()
+            raise GitOperationError(f"Final push failed after rebase:\n{error_msg}")

smart_commit_tool-1.0.1/src/smart_commit/services/security.py

@@ -0,0 +1,86 @@
+import subprocess
+from pathlib import Path
+from ..logger import Console, logger
+
+
+class SecurityService:
+    BASE_GITIGNORE = """
+# Universal .gitignore generated by Smart Commit
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+env/
+.env*
+!.env.example
+.vscode/
+.idea/
+dist/
+build/
+*.egg-info/
+node_modules/
+.DS_Store
+.smart_commit.log
+"""
+
+    @classmethod
+    def ensure_gitignore(cls):
+        """Ensures .gitignore exists or creates a secure default."""
+        path = Path(".gitignore")
+        if not path.exists():
+            Console.warning(
+                ".gitignore not found. Creating a secure default configuration..."
+            )
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(cls.BASE_GITIGNORE.lstrip())
+            logger.info("Created default .gitignore")
+
+    @classmethod
+    def check_env_leaks(cls):
+        """
+        Scans for .env* files and uses Git to check if they are ignored.
+        Prevents accidental leaks of secrets.
+        """
+        Console.info("🛡️ Scanning for potential secret leaks (.env files)...")
+
+        env_files = [
+            f
+            for f in Path(".").rglob(".env*")
+            if not any(
+                part in ["venv", ".venv", "env", "node_modules", ".git"]
+                for part in f.parts
+            )
+        ]
+
+        leaked_files = []
+
+        for env_file in env_files:
+            res = subprocess.run(
+                ["git", "check-ignore", "-q", str(env_file)], capture_output=True
+            )
+            if res.returncode == 1:
+                leaked_files.append(str(env_file))
+
+        if leaked_files:
+            Console.error(
+                "CRITICAL SECURITY RISK: .env files found that are NOT in .gitignore!"
+            )
+            for lf in leaked_files:
+                print(f"  👉 {lf}")
+
+            ans = (
+                input("🛑 Add these files to .gitignore automatically? [Y/n]: ")
+                .strip()
+                .lower()
+            )
+            if ans != "n":
+                with open(".gitignore", "a", encoding="utf-8") as f:
+                    f.write("\n# Auto-added by Smart Commit to prevent leaks\n")
+                    for lf in leaked_files:
+                        f.write(f"{lf}\n")
+                Console.success("Files successfully added to .gitignore.")
+            else:
+                Console.warning(
+                    "Action declined. Please be careful: secrets might be pushed!"
+                )

smart_commit_tool-1.0.1/src/smart_commit/services/validator.py

@@ -0,0 +1,28 @@
+import subprocess
+import re
+from ..exceptions import ValidationError
+from ..logger import Console, logger
+
+
+class ValidatorService:
+    @classmethod
+    def check_conventional_commit(cls, message: str):
+        """Validates message against Conventional Commits standard."""
+        pattern = r"^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:\s.+"
+        if not re.match(pattern, message):
+            logger.warning(f"Non-conventional commit message: {message}")
+            Console.warning(
+                "Commit message does not follow Conventional Commits (e.g., 'feat: add auth')."
+            )
+
+    @classmethod
+    def run_commands(cls, commands: list[str]):
+        """Runs pre-commit pipeline commands (linters, tests)."""
+        for cmd in commands:
+            Console.info(f"Executing: {cmd}")
+            logger.info(f"Running validation command: {cmd}")
+            res = subprocess.run(cmd, shell=True)
+            if res.returncode != 0:
+                raise ValidationError(
+                    f"Pipeline failed at: '{cmd}'. Please fix the issues!"
+                )

smart_commit_tool-0.1.0/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.4
-Name: smart-commit-tool
-Version: 0.1.0
-Summary: Automated pre-push workflow manager with built-in code quality enforcement and smart branch protection.
-Requires-Python: >=3.11
-Requires-Dist: colorama
-Requires-Dist: tomli; python_version < '3.11'
-Description-Content-Type: text/markdown
-
-# 🚀 Smart Commit Tool
-
-Smart Commit Tool is a robust Git wrapper designed for developers who value code quality. It automates the "Pre-check → Commit → Sync → Push" workflow, ensuring that no broken code ever reaches your remote repository.
-
-## ✨ Features
-
-- ⚡ **Automated Validations**: Runs your test suites (Ruff, Pytest, etc.) before every push.
-- 🛡️ **Branch Protection**: Prevents accidental pushes to sensitive branches like `main` or `prod`.
-- 🔄 **Optimistic Sync**: Automatically handles `pull --rebase` only when conflicts occur, keeping your history clean.
-- 🎨 **Terminal UX**: Full color-coded feedback and interactive prompts for a better developer experience.
-- ⚙️ **Configurable**: Managed entirely via your existing `pyproject.toml`.
-
-## 📦 Installation
-
-Since the project uses `hatchling`, you can install it locally in editable mode (perfect for development):
-
-```bash
-pip install smart-commit
-```
-
-After installation, the `smart-commit` command will be available in your terminal.
-
-## 🚀 Usage
-
-Simply run the command in your project root:
-
-```bash
-smart-commit
-```
-
-### CLI Arguments
-
-| Argument      | Description                                       |
-|---------------|---------------------------------------------------|
-| `-b, --branch`| Specify the target branch (skips interactive prompt) |
-| `-m, --message`| Set the commit message (skips interactive prompt) |
-
-## 🔧 Configuration
-
-Add the following section to your `pyproject.toml` to customize the behavior:
-
-```toml
-[tool.smart_commit]
-repository_url = "https://github.com/youruser/yourrepo.git"
-protected_branches = ["main", "master", "prod", "release"]
-commands = [
-    "ruff check .",
-    "pytest",
-    ...
-]
-```
-
-### How it works:
-
-1. **Environment Check**: Ensures Git is initialized and the remote URL is correct.
-2. **Branch Guard**: If you are on a protected branch, it prompts you to switch to a new one.
-3. **Validation**: Runs every command in your `commands` list. If one fails, the process stops.
-4. **Smart Push**: Attempts a push. If the remote has changed, it performs a rebase and retries automatically.
-
-## 🛠 Tech Stack
-
-- Python 3.11+
-- **Colorama**: For cross-platform terminal styling.
-- **Tomli/Tomllib**: For seamless configuration parsing.
-- **Hatchling**: Modern build backend.
-
-## 📄 License
-
-Distributed under the MIT License. See `LICENSE` for more information.

smart_commit_tool-0.1.0/README.md

@@ -1,69 +0,0 @@
-# 🚀 Smart Commit Tool
-
-Smart Commit Tool is a robust Git wrapper designed for developers who value code quality. It automates the "Pre-check → Commit → Sync → Push" workflow, ensuring that no broken code ever reaches your remote repository.
-
-## ✨ Features
-
-- ⚡ **Automated Validations**: Runs your test suites (Ruff, Pytest, etc.) before every push.
-- 🛡️ **Branch Protection**: Prevents accidental pushes to sensitive branches like `main` or `prod`.
-- 🔄 **Optimistic Sync**: Automatically handles `pull --rebase` only when conflicts occur, keeping your history clean.
-- 🎨 **Terminal UX**: Full color-coded feedback and interactive prompts for a better developer experience.
-- ⚙️ **Configurable**: Managed entirely via your existing `pyproject.toml`.
-
-## 📦 Installation
-
-Since the project uses `hatchling`, you can install it locally in editable mode (perfect for development):
-
-```bash
-pip install smart-commit
-```
-
-After installation, the `smart-commit` command will be available in your terminal.
-
-## 🚀 Usage
-
-Simply run the command in your project root:
-
-```bash
-smart-commit
-```
-
-### CLI Arguments
-
-| Argument      | Description                                       |
-|---------------|---------------------------------------------------|
-| `-b, --branch`| Specify the target branch (skips interactive prompt) |
-| `-m, --message`| Set the commit message (skips interactive prompt) |
-
-## 🔧 Configuration
-
-Add the following section to your `pyproject.toml` to customize the behavior:
-
-```toml
-[tool.smart_commit]
-repository_url = "https://github.com/youruser/yourrepo.git"
-protected_branches = ["main", "master", "prod", "release"]
-commands = [
-    "ruff check .",
-    "pytest",
-    ...
-]
-```
-
-### How it works:
-
-1. **Environment Check**: Ensures Git is initialized and the remote URL is correct.
-2. **Branch Guard**: If you are on a protected branch, it prompts you to switch to a new one.
-3. **Validation**: Runs every command in your `commands` list. If one fails, the process stops.
-4. **Smart Push**: Attempts a push. If the remote has changed, it performs a rebase and retries automatically.
-
-## 🛠 Tech Stack
-
-- Python 3.11+
-- **Colorama**: For cross-platform terminal styling.
-- **Tomli/Tomllib**: For seamless configuration parsing.
-- **Hatchling**: Modern build backend.
-
-## 📄 License
-
-Distributed under the MIT License. See `LICENSE` for more information.

smart_commit_tool-0.1.0/src/smart_commit/cli.py

@@ -1,214 +0,0 @@
-import subprocess
-import sys
-import argparse
-from pathlib import Path
-from typing import Any
-from colorama import init, Fore, Style
-
-# Initialize colorama for cross-platform colored output
-init(autoreset=True)
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib
-
-
-class SmartCommitError(Exception):
-    """Base class for script-related errors."""
-
-    pass
-
-
-def run_cmd(
-    cmd: list[str] | str, silent: bool = False, use_shell: bool = False
-) -> subprocess.CompletedProcess[str]:
-    """
-    Executes a shell command.
-    Prefer passing a list of arguments (use_shell=False) for internal git commands.
-    """
-    if not silent:
-        display_cmd = cmd if isinstance(cmd, str) else " ".join(cmd)
-        print(f"{Fore.CYAN}🛠  Executing: {Style.BRIGHT}{display_cmd}")
-
-    result = subprocess.run(cmd, shell=use_shell, capture_output=silent, text=True)
-    return result
-
-
-def ensure_gitignore() -> None:
-    """Creates a standard .gitignore for Python if it doesn't exist."""
-    if not Path(".gitignore").exists():
-        print(f"{Fore.YELLOW}📝 .gitignore not found. Creating a standard one...")
-        content = (
-            "__pycache__/\n*.py[cod]\n*$py.class\n.venv/\nvenv/\n"
-            ".env\n.vscode/\ndist/\nbuild/\n*.egg-info/\n"
-        )
-        with open(".gitignore", "w", encoding="utf-8") as f:
-            f.write(content)
-
-
-def get_config() -> dict[str, Any]:
-    """Reads configuration from pyproject.toml."""
-    path = Path("pyproject.toml")
-    if not path.exists():
-        raise SmartCommitError(
-            "pyproject.toml not found. Please run the command in the project root."
-        )
-
-    with open(path, "rb") as f:
-        data = tomllib.load(f)
-        return data.get("tool", {}).get("smart_commit", {})
-
-
-def ensure_git_setup(expected_url: str) -> None:
-    """Checks and configures Git repository and remote."""
-    if not Path(".git").exists():
-        print(f"{Fore.YELLOW}📁 Git not initialized. Initializing repository...")
-        run_cmd(["git", "init"])
-
-    res = run_cmd(["git", "remote", "get-url", "origin"], silent=True)
-    current_url = res.stdout.strip()
-
-    if res.returncode != 0:
-        print(f"{Fore.CYAN}🔗 Adding remote origin: {expected_url}")
-        run_cmd(["git", "remote", "add", "origin", expected_url])
-    elif expected_url not in current_url:
-        print(f"{Fore.YELLOW}🔄 Updating repository URL to: {expected_url}")
-        run_cmd(["git", "remote", "set-url", "origin", expected_url])
-    else:
-        print(f"{Fore.GREEN}✅ Git repository is correctly configured.")
-
-
-def switch_branch(branch: str) -> None:
-    """Safely switches branches, handling unborn (empty) repositories."""
-    has_commits = run_cmd(["git", "rev-parse", "HEAD"], silent=True).returncode == 0
-
-    if not has_commits:
-        run_cmd(["git", "branch", "-M", branch], silent=True)
-    else:
-        run_cmd(["git", "checkout", "-B", branch], silent=True)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Smart Commit & Push Tool")
-    parser.add_argument("-b", "--branch", help="Specify branch (skips prompt)")
-    parser.add_argument("-m", "--message", help="Commit message (skips prompt)")
-    args = parser.parse_args()
-
-    try:
-        config = get_config()
-        repo_url = config.get("repository_url")
-        commands: list[str] = config.get("commands", [])
-        protected_branches = config.get(
-            "protected_branches", ["main", "master", "prod", "production"]
-        )
-
-        if not repo_url:
-            raise SmartCommitError(
-                "In pyproject.toml, [tool.smart_commit].repository_url is missing."
-            )
-
-        ensure_git_setup(repo_url)
-        ensure_gitignore()
-
-        print(f"\n{Fore.MAGENTA}{Style.BRIGHT}--- 🚀 SMART COMMIT PRE-CHECK ---")
-
-        branch = args.branch
-        if not branch:
-            current_branch = run_cmd(
-                ["git", "branch", "--show-current"], silent=True
-            ).stdout.strip()
-
-            if current_branch:
-                user_input = input(f"{Fore.BLUE}🌿 Branch [{current_branch}]: ").strip()
-                branch = user_input if user_input else current_branch
-            else:
-                branch = input(f"{Fore.BLUE}🌿 Branch name (e.g., main): ").strip()
-
-        message = args.message
-        if not message:
-            message = input(f"{Fore.BLUE}📝 Commit message: ").strip()
-
-        if not branch or not message:
-            raise SmartCommitError("Branch and message cannot be empty.")
-
-        if branch in protected_branches:
-            print(
-                f"\n{Fore.RED}{Style.BRIGHT}⚠️  WARNING: You are pushing directly to a protected branch: '{branch}'."
-            )
-            choice = (
-                input(
-                    f"{Fore.YELLOW}Continue? [y (yes) / n (cancel) / b (create new branch)]: "
-                )
-                .lower()
-                .strip()
-            )
-
-            if choice == "n":
-                raise SmartCommitError("Operation cancelled by user.")
-            elif choice == "b":
-                new_branch = input(f"{Fore.BLUE}Enter new branch name: ").strip()
-                if not new_branch:
-                    raise SmartCommitError("Branch name cannot be empty.")
-                branch = new_branch
-                print(f"{Fore.CYAN}🌿 Switching to new branch '{branch}'...")
-            elif choice != "y":
-                raise SmartCommitError("Invalid input. Operation cancelled.")
-
-        switch_branch(branch)
-
-        print(f"\n{Fore.MAGENTA}{Style.BRIGHT}--- 🛠 RUNNING VALIDATIONS ---")
-        for cmd in commands:
-            if run_cmd(cmd, use_shell=True).returncode != 0:
-                raise SmartCommitError(
-                    f"Validation failed for: '{cmd}'. Please fix the issues and try again!"
-                )
-
-        print(f"\n{Fore.MAGENTA}{Style.BRIGHT}--- ✅ ALL CHECKS PASSED. PUSHING... ---")
-
-        if run_cmd(["git", "add", "."]).returncode != 0:
-            raise SmartCommitError("Error occurred during 'git add'.")
-
-        if run_cmd(["git", "commit", "-m", message]).returncode != 0:
-            print(f"{Fore.YELLOW}ℹ️  No changes to commit or commit error occurred.")
-
-        print(f"{Fore.CYAN}📤 Pushing changes to {Style.BRIGHT}{branch}...")
-        push_res = run_cmd(["git", "push", "-u", "origin", branch], silent=True)
-
-        if push_res.returncode == 0:
-            print(
-                f"\n{Fore.GREEN}{Style.BRIGHT}🎉 Success! Code validated and pushed to '{branch}'."
-            )
-            return
-
-        print(f"{Fore.YELLOW}⚠️  Push rejected. Remote changes detected.")
-        print(f"{Fore.CYAN}📥 Synchronizing (pull --rebase)...")
-
-        pull_res = run_cmd(["git", "pull", "origin", branch, "--rebase"], silent=True)
-
-        if pull_res.returncode != 0:
-            raise SmartCommitError(
-                "🛑 Conflict detected during pull!\n"
-                "Please resolve conflicts manually (git rebase --continue) and run the script again."
-            )
-
-        print(f"{Fore.GREEN}🔄 Sync successful. Retrying push...")
-        push_res_retry = run_cmd(["git", "push", "-u", "origin", branch])
-
-        if push_res_retry.returncode == 0:
-            print(
-                f"\n{Fore.GREEN}{Style.BRIGHT}🎉 Success! Changes synchronized and pushed to '{branch}'."
-            )
-        else:
-            raise SmartCommitError("Failed to push changes after rebase.")
-
-    except SmartCommitError as e:
-        print(f"\n{Fore.RED}{Style.BRIGHT}❌ Error: {e}")
-        sys.exit(1)
-    except KeyboardInterrupt:
-        print(f"\n{Fore.YELLOW}Process interrupted by user.")
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()