smart-commit-tool 2.0.3__tar.gz → 3.0.1__tar.gz

{smart_commit_tool-2.0.3 → smart_commit_tool-3.0.1}/.github/workflows/smart_commit_ci.yml

@@ -12,7 +12,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # Runs the pipeline on multiple Python versions automatically
         python-version: ["3.10", "3.11", "3.12"]
 
     steps:
@@ -23,18 +22,20 @@ jobs:
           uses: actions/setup-python@v5
           with:
             python-version: ${{ matrix.python-version }}
-            cache: 'pip' # Speeds up consecutive runs
+            cache: 'pip'
 
         - name: Install Dependencies (Adaptive Smart Installer)
           run: |
             python -m pip install --upgrade pip
             
+            # Ensure local bin is in PATH for all subsequent steps
+            echo "$HOME/.local/bin" >> $GITHUB_PATH
+            
             echo "🔍 Detecting package manager..."
             
             if [ -f "poetry.lock" ] || [ -f "pyproject.toml" ] && grep -q "tool.poetry" "pyproject.toml"; then
                 echo "🚀 Poetry detected!"
                 pip install poetry
-                # Force poetry to install globally so custom commands work without 'poetry run'
                 poetry config virtualenvs.create false
                 poetry install --no-interaction --no-ansi
                 
@@ -52,12 +53,10 @@ jobs:
             elif [ -f "requirements.txt" ]; then
                 echo "🚀 Standard requirements.txt detected!"
                 pip install -r requirements.txt
-                # Install package itself if setup.py exists
                 if [ -f "setup.py" ]; then pip install -e .; fi
                 
             elif [ -f "pyproject.toml" ]; then
-                echo "🚀 Standard PEP 621 pyproject.toml detected (Hatch, Flit, Setuptools)!"
-                # Attempt to install with dev dependencies if available, otherwise regular install
+                echo "🚀 Standard PEP 621 pyproject.toml detected!"
                 pip install -e .[dev] || pip install -e .
                 
             else

{smart_commit_tool-2.0.3 → smart_commit_tool-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-commit-tool
-Version: 2.0.3
+Version: 3.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

{smart_commit_tool-2.0.3 → smart_commit_tool-3.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smart-commit-tool"
-version = "2.0.3"
+version = "3.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"

smart_commit_tool-3.0.1/smart_commit/cli.py

@@ -0,0 +1,70 @@
+import argparse
+import sys
+from .services import (
+    config as config_service,
+    git as git_service,
+    security as security_service,
+    runner as runner_service,
+)
+from .services.logger import logger
+
+
+def interactive_input(prompt: str, default: str = "") -> str:
+    """Запрашивает ввод у пользователя, если флаг не передан."""
+    suffix = f" [{default}]" if default else ""
+    value = input(f"{prompt}{suffix}: ").strip()
+    return value if value else default
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Smart Git Commit Tool")
+    parser.add_argument("-b", "--branch", help="Имя ветки")
+    parser.add_argument("-m", "--message", help="Сообщение коммита")
+    parser.add_argument("-r", "--remote", help="Remote (например, origin)")
+
+    args = parser.parse_args()
+
+    logger.info("Инициализация Smart Commit...")
+
+    # 1. Сбор параметров (Fallback на интерактивный ввод)
+    branch = args.branch or interactive_input("Введите имя ветки")
+    message = args.message or interactive_input("Введите сообщение коммита")
+    remote = args.remote or interactive_input("Введите remote", default="origin")
+
+    if not branch or not message:
+        logger.error("Ветка и сообщение коммита обязательны!")
+        sys.exit(1)
+
+    # 2. Загрузка конфига
+    config = config_service.load_config()
+
+    # 3. Валидация ветки
+    git_service.check_protected(branch, config.get("protected_branches", []))
+    git_service.ensure_branch(branch)
+
+    # 4. Добавление файлов в индекс (чтобы сканер секретов увидел их)
+    git_service.add_all()
+
+    # 5. Секьюрити чек
+    staged_files = git_service.get_staged_files()
+    if not staged_files:
+        logger.warning("Нет изменений для коммита.")
+        sys.exit(0)
+
+    if security_service.check_secrets(staged_files):
+        # Удаляем из индекса файлы, которые только что попали в gitignore
+        git_service.run_cmd(["git", "rm", "-r", "--cached", "."])
+        git_service.add_all()
+
+    # 6. Запуск кастомных команд (ruff, тесты и т.д.)
+    runner_service.run_pre_commands(config.get("commands", []))
+
+    # 7. Финализация (Commit & Push)
+    git_service.commit(message)
+    git_service.push(remote, branch)
+
+    logger.success("Smart Commit завершил работу!")
+
+
+if __name__ == "__main__":
+    main()

smart_commit_tool-3.0.1/smart_commit/services/config.py

@@ -0,0 +1,31 @@
+import os
+from pathlib import Path
+from .logger import logger
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
+def load_config() -> dict:
+    """Загружает секцию [tool.smart_commit] из pyproject.toml."""
+    config_path = Path(os.getcwd()) / "pyproject.toml"
+
+    default_config = {
+        "repository_url": "",
+        "commands": [],
+        "protected_branches": ["main", "master"],
+    }
+
+    if not config_path.exists():
+        logger.warning("pyproject.toml не найден. Используются настройки по умолчанию.")
+        return default_config
+
+    try:
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+            return data.get("tool", {}).get("smart_commit", default_config)
+    except Exception as e:
+        logger.error(f"Ошибка чтения конфига: {e}")
+        return default_config

smart_commit_tool-3.0.1/smart_commit/services/git.py

@@ -0,0 +1,53 @@
+import subprocess
+import sys
+from .logger import logger
+
+
+def run_cmd(cmd: list[str], check=True) -> str:
+    """Выполняет bash-команду и возвращает вывод."""
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if check and result.returncode != 0:
+        logger.error(f"Ошибка Git: {result.stderr.strip()}")
+        sys.exit(1)
+    return result.stdout.strip()
+
+
+def check_protected(branch: str, protected_branches: list[str]):
+    """Блокирует пуш в защищенные ветки."""
+    if branch in protected_branches:
+        logger.error(f"Прямой коммит в защищенную ветку '{branch}' запрещен!")
+        sys.exit(1)
+
+
+def ensure_branch(branch: str):
+    """Проверяет наличие ветки. Если нет - создает."""
+    result = subprocess.run(["git", "checkout", branch], capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.info(f"Ветка '{branch}' не найдена. Создаю новую...")
+        run_cmd(["git", "checkout", "-b", branch])
+    else:
+        logger.info(f"Переключено на ветку '{branch}'.")
+
+
+def add_all():
+    run_cmd(["git", "add", "."])
+    logger.info("Файлы добавлены в индекс (git add).")
+
+
+def get_staged_files() -> list[str]:
+    """Возвращает список файлов, готовых к коммиту."""
+    output = run_cmd(["git", "diff", "--cached", "--name-only"])
+    return [f for f in output.split("\n") if f]
+
+
+def commit(message: str):
+    run_cmd(
+        ["git", "commit", "-m", message], check=False
+    )  # check=False, чтобы обработать "nothing to commit"
+    logger.info(f"Коммит создан: '{message}'")
+
+
+def push(remote: str, branch: str):
+    logger.info(f"Отправка изменений в {remote}/{branch}...")
+    run_cmd(["git", "push", "-u", remote, branch])
+    logger.success("Push успешно завершен!")

smart_commit_tool-3.0.1/smart_commit/services/logger.py

@@ -0,0 +1,26 @@
+import sys
+from colorama import Fore, Style, init
+
+
+init(autoreset=True)
+
+
+class Logger:
+    @staticmethod
+    def info(msg: str):
+        print(f"{Fore.CYAN}[INFO]{Style.RESET_ALL} {msg}")
+
+    @staticmethod
+    def success(msg: str):
+        print(f"{Fore.GREEN}[SUCCESS]{Style.RESET_ALL} {msg}")
+
+    @staticmethod
+    def warning(msg: str):
+        print(f"{Fore.YELLOW}[WARNING]{Style.RESET_ALL} {msg}")
+
+    @staticmethod
+    def error(msg: str):
+        print(f"{Fore.RED}[ERROR]{Style.RESET_ALL} {msg}", file=sys.stderr)
+
+
+logger = Logger()

smart_commit_tool-3.0.1/smart_commit/services/runner.py

@@ -0,0 +1,20 @@
+import subprocess
+import sys
+from .logger import logger
+
+
+def run_pre_commands(commands: list[str]):
+    """Запускает команды из конфига перед коммитом."""
+    if not commands:
+        return
+
+    logger.info("Запуск pre-commit команд...")
+    for cmd in commands:
+        logger.info(f"Выполнение: {cmd}")
+        result = subprocess.run(cmd, shell=True)
+
+        if result.returncode != 0:
+            logger.error(f"Команда '{cmd}' завершилась с ошибкой!")
+            sys.exit(1)
+
+    logger.success("Все pre-commit команды выполнены успешно.")

smart_commit_tool-3.0.1/smart_commit/services/security.py

@@ -0,0 +1,59 @@
+import os
+import re
+import sys
+from .logger import logger
+
+SECRET_PATTERNS = [
+    re.compile(
+        r'(?i)(api[_-]?key|secret|password|token)\s*[:=]\s*["\'][a-zA-Z0-9\-_]{10,}["\']'
+    ),
+    re.compile(r"-----BEGIN (RSA|OPENSSH|PRIVATE) KEY-----"),
+]
+
+SUSPICIOUS_FILES = [".env", ".env.local", "secrets.json"]
+
+
+def check_secrets(staged_files: list[str]) -> bool:
+    """
+    Проверяет файлы на наличие секретов.
+    Возвращает True, если был изменен .gitignore (требуется повторный git add).
+    """
+    secrets_found = []
+
+    for file_path in staged_files:
+        if not os.path.exists(file_path):
+            continue
+
+        file_name = os.path.basename(file_path)
+
+        if file_name in SUSPICIOUS_FILES:
+            secrets_found.append(file_path)
+            continue
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+                if any(pattern.search(content) for pattern in SECRET_PATTERNS):
+                    secrets_found.append(file_path)
+        except UnicodeDecodeError:
+            pass
+
+    if not secrets_found:
+        return False
+
+    logger.warning("ОБНАРУЖЕНЫ ВОЗМОЖНЫЕ УТЕЧКИ СЕКРЕТОВ!")
+    for s in secrets_found:
+        logger.warning(f" -> {s}")
+
+    answer = input("Добавить эти файлы в .gitignore? [y/N]: ").strip().lower()
+    if answer == "y":
+        with open(".gitignore", "a", encoding="utf-8") as f:
+            f.write("\n# Auto-added by Smart Commit\n")
+            for s in secrets_found:
+                f.write(f"{s}\n")
+
+        logger.success("Файлы добавлены в .gitignore.")
+        return True
+
+    logger.error("Коммит прерван из-за угрозы безопасности. Очистите секреты вручную.")
+    sys.exit(1)

smart_commit_tool-2.0.3/src/smart_commit/cli.py

@@ -1,105 +0,0 @@
-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 .services.ci import CIService
-from .logger import Console, logger
-from .constants import TOOL_NAME, DEFAULT_PROTECTED_BRANCHES
-
-
-def run_ci_generation_flow():
-    """Dedicated flow for 'smart-commit generate-action' command."""
-    logger.info("=== CI Generation Flow Started ===")
-    config = ConfigService.load_or_create()
-    commands = config.get("commands", [])
-    protected_branches = config.get("protected_branches", DEFAULT_PROTECTED_BRANCHES)
-
-    GitService.ensure_repo()
-
-    CIService.generate_github_action(commands, protected_branches)
-    CIService.prompt_and_push()
-
-    sys.exit(0)
-
-
-def main():
-    if len(sys.argv) > 1 and sys.argv[1] == "generate-action":
-        try:
-            run_ci_generation_flow()
-        except SmartCommitError as e:
-            Console.error(str(e))
-            sys.exit(1)
-        except KeyboardInterrupt:
-            Console.warning("\nProcess interrupted by user.")
-            sys.exit(0)
-
-    parser = argparse.ArgumentParser(description=TOOL_NAME)
-    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", DEFAULT_PROTECTED_BRANCHES
-        )
-        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.")
-
-        has_changes = GitService.has_any_changes()
-        message = args.message
-
-        if has_changes:
-            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 WORKFLOW ---")
-
-        if has_changes:
-            GitService.smart_stage()
-            GitService.commit(message)
-        else:
-            Console.info(
-                "Working directory is clean. Skipping commit phase and proceeding to push."
-            )
-
-        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-2.0.3/src/smart_commit/config.py

@@ -1,41 +0,0 @@
-import sys
-from .exceptions import SmartCommitError
-from .logger import Console, logger
-from .constants import PYPROJECT_FILE, DEFAULT_TOML_CONFIG
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib
-
-
-class ConfigService:
-    @classmethod
-    def load_or_create(cls) -> dict:
-        """Reads configuration. If the section is missing, appends default settings."""
-        if not PYPROJECT_FILE.exists():
-            Console.warning(f"{PYPROJECT_FILE.name} not found. Creating a base file...")
-            PYPROJECT_FILE.touch()
-
-        try:
-            with open(PYPROJECT_FILE, "rb") as f:
-                data = tomllib.load(f)
-        except Exception as e:
-            raise SmartCommitError(f"Failed to parse {PYPROJECT_FILE.name}: {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(f"Appending default tool.smart_commit to {PYPROJECT_FILE.name}")
-
-            with open(PYPROJECT_FILE, "a", encoding="utf-8") as f:
-                f.write(DEFAULT_TOML_CONFIG)
-
-            with open(PYPROJECT_FILE, "rb") as f:
-                data = tomllib.load(f)
-            config = data.get("tool", {}).get("smart_commit", {})
-
-        return config

smart_commit_tool-2.0.3/src/smart_commit/constants.py

@@ -1,115 +0,0 @@
-from pathlib import Path
-
-TOOL_NAME = "Smart Commit & Push Tool"
-PYPROJECT_FILE = Path("pyproject.toml")
-LOG_FILE = ".smart_commit.log"
-
-DEFAULT_PROTECTED_BRANCHES = ["main", "master", "prod", "release"]
-
-DEFAULT_TOML_CONFIG = """
-# Auto-generated by Smart Commit
-[tool.smart_commit]
-repository_url = ""
-commands = ["echo 'Running pre-commit pipeline...'"]
-protected_branches = ["main", "master", "prod", "release"]
-"""
-
-GITIGNORE_FILE = Path(".gitignore")
-EXCLUDED_SCAN_DIRS = ["venv", ".venv", "env", "node_modules", ".git", "__pycache__"]
-
-BASE_GITIGNORE = """
-# Universal .gitignore generated by Smart Commit
-__pycache__/
-*.py[cod]
-*$py.class
-.venv/
-venv/
-env/
-.env*
-*.env
-!.env.example
-.vscode/
-.idea/
-dist/
-build/
-*.egg-info/
-node_modules/
-.DS_Store
-.smart_commit.log
-"""
-
-WORKFLOW_DIR = Path(".github/workflows")
-WORKFLOW_FILE = WORKFLOW_DIR / "smart_commit_ci.yml"
-CI_COMMIT_MESSAGE = "ci: auto-generate GitHub Actions workflow via Smart Commit"
-
-GITHUB_ACTION_TEMPLATE = """name: Smart Commit CI Pipeline
-
-on:
-  push:
-    branches: [ __BRANCHES__ ]
-  pull_request:
-    branches: [ __BRANCHES__ ]
-
-jobs:
-  validate:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10", "3.11", "3.12"]
-
-    steps:
-        - name: Checkout Repository
-          uses: actions/checkout@v4
-
-        - name: Set up Python ${{ matrix.python-version }}
-          uses: actions/setup-python@v5
-          with:
-            python-version: ${{ matrix.python-version }}
-            cache: 'pip'
-
-        - name: Install Dependencies (Adaptive Smart Installer)
-          run: |
-            python -m pip install --upgrade pip
-            
-            # Ensure local bin is in PATH for all subsequent steps
-            echo "$HOME/.local/bin" >> $GITHUB_PATH
-            
-            echo "🔍 Detecting package manager..."
-            
-            if [ -f "poetry.lock" ] || [ -f "pyproject.toml" ] && grep -q "tool.poetry" "pyproject.toml"; then
-                echo "🚀 Poetry detected!"
-                pip install poetry
-                poetry config virtualenvs.create false
-                poetry install --no-interaction --no-ansi
-                
-            elif [ -f "Pipfile.lock" ] || [ -f "Pipfile" ]; then
-                echo "🚀 Pipenv detected!"
-                pip install pipenv
-                pipenv install --system --dev
-                
-            elif [ -f "pdm.lock" ] || [ -f "pyproject.toml" ] && grep -q "tool.pdm" "pyproject.toml"; then
-                echo "🚀 PDM detected!"
-                pip install pdm
-                pdm config python.use_venv false
-                pdm install
-                
-            elif [ -f "requirements.txt" ]; then
-                echo "🚀 Standard requirements.txt detected!"
-                pip install -r requirements.txt
-                if [ -f "setup.py" ]; then pip install -e .; fi
-                
-            elif [ -f "pyproject.toml" ]; then
-                echo "🚀 Standard PEP 621 pyproject.toml detected!"
-                pip install -e .[dev] || pip install -e .
-                
-            else
-                echo "⚠️ No known package manager found. Skipping dependency installation."
-            fi
-
-__COMMANDS__
-"""
-
-CONVENTIONAL_COMMIT_PATTERN = (
-    r"^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:\s.+"
-)

smart_commit_tool-2.0.3/src/smart_commit/exceptions.py

@@ -1,14 +0,0 @@
-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-2.0.3/src/smart_commit/logger.py

@@ -1,32 +0,0 @@
-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-2.0.3/src/smart_commit/services/ci.py

@@ -1,66 +0,0 @@
-from ..logger import Console, logger
-from ..exceptions import SmartCommitError
-from .git import GitService
-from ..constants import (
-    WORKFLOW_DIR,
-    WORKFLOW_FILE,
-    GITHUB_ACTION_TEMPLATE,
-    CI_COMMIT_MESSAGE,
-)
-
-
-class CIService:
-    @classmethod
-    def generate_github_action(cls, commands: list[str], protected_branches: list[str]):
-        """Generates a GitHub Actions workflow file dynamically based on pyproject.toml commands."""
-        Console.info("⚙️ Generating GitHub Actions workflow...")
-
-        branches_yaml = ", ".join(f'"{b}"' for b in protected_branches)
-
-        if not commands:
-            commands_yaml = (
-                '        - run: echo "No commands defined in pyproject.toml"'
-            )
-        else:
-            commands_yaml = "\n".join(
-                f"        - name: Run '{cmd}'\n          run: {cmd}" for cmd in commands
-            )
-
-        workflow_content = GITHUB_ACTION_TEMPLATE.replace("__BRANCHES__", branches_yaml)
-        workflow_content = workflow_content.replace("__COMMANDS__", commands_yaml)
-
-        try:
-            WORKFLOW_DIR.mkdir(parents=True, exist_ok=True)
-            with open(WORKFLOW_FILE, "w", encoding="utf-8") as f:
-                f.write(workflow_content)
-
-            Console.success(f"GitHub Action successfully created at: {WORKFLOW_FILE}")
-            logger.info("Generated GitHub Action workflow file.")
-
-        except Exception as e:
-            raise SmartCommitError(f"Failed to generate CI workflow: {e}")
-
-    @classmethod
-    def prompt_and_push(cls):
-        """Asks the user if they want to instantly commit and push the new Action."""
-        ans = (
-            input("🚀 Do you want to commit and push this GitHub Action now? [y/N]: ")
-            .strip()
-            .lower()
-        )
-        if ans != "y":
-            Console.info("Action saved locally. You can commit it manually later.")
-            return
-
-        try:
-            branch = GitService.get_current_branch()
-
-            GitService._run(["git", "add", str(WORKFLOW_FILE)])
-
-            GitService.commit(CI_COMMIT_MESSAGE)
-            Console.info(f"Committed: '{CI_COMMIT_MESSAGE}'")
-
-            GitService.push_with_retry(branch)
-
-        except Exception as e:
-            raise SmartCommitError(f"Failed to push CI configuration: {e}")

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

@@ -1,129 +0,0 @@
-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 with combined output."""
-        logger.debug(f"Git CMD: {' '.join(cmd)}")
-        return subprocess.run(cmd, capture_output=True, text=True)
-
-    @classmethod
-    def ensure_repo(cls):
-        """Checks for repository initialization, Detached HEAD, and ongoing merges/rebases."""
-        git_dir = Path(".git")
-        if not git_dir.exists():
-            Console.warning("Git not initialized. Initializing now...")
-            cls._run(["git", "init"])
-        is_rebase = (git_dir / "rebase-apply").exists() or (
-            git_dir / "rebase-merge"
-        ).exists()
-        is_merge = (git_dir / "MERGE_HEAD").exists()
-
-        if is_rebase or is_merge:
-            raise GitOperationError(
-                "🛑 Git is currently in the middle of a REBASE or MERGE.\n"
-                "Please resolve conflicts manually or run 'git rebase --abort', then try again."
-            )
-
-        res = cls._run(["git", "branch", "--show-current"])
-        if not res.stdout.strip():
-            raise GitOperationError(
-                "You are in a DETACHED HEAD state. Please switch to a branch (e.g., 'git checkout main')."
-            )
-
-    @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_any_changes(cls) -> bool:
-        """Checks if there are any staged, unstaged, or untracked changes."""
-        res = cls._run(["git", "status", "--porcelain"])
-        return bool(res.stdout.strip())
-
-    @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. Ignores 'nothing to commit' errors to allow push-only flows."""
-        res = cls._run(["git", "commit", "-m", message])
-
-        if res.returncode != 0:
-            output = (res.stdout + res.stderr).lower()
-            if "nothing to commit" in output or "working tree clean" in output:
-                return
-
-            raise GitOperationError(
-                f"Commit failed. Git says:\n{res.stderr or res.stdout}"
-            )
-
-    @classmethod
-    def push_with_retry(cls, branch: str):
-        """Pushes to remote, attempting a pull --rebase if rejected or diverged."""
-        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 or branches diverged. Remote changes detected.")
-        Console.info("Synchronizing via 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()
-            cls._run(["git", "rebase", "--abort"])
-            raise GitOperationError(
-                f"🛑 Rebase conflict! Conflicts were detected with remote files.\n"
-                f"Sync aborted. Please resolve manually. Git says:\n{error_msg}"
-            )
-
-        Console.success("Sync successful. Retrying final 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-2.0.3/src/smart_commit/services/security.py

@@ -1,68 +0,0 @@
-import subprocess
-from pathlib import Path
-from ..logger import Console, logger
-from ..constants import GITIGNORE_FILE, BASE_GITIGNORE, EXCLUDED_SCAN_DIRS
-
-
-class SecurityService:
-    @classmethod
-    def ensure_gitignore(cls):
-        """Ensures .gitignore exists or creates a secure default."""
-        if not GITIGNORE_FILE.exists():
-            Console.warning(
-                f"{GITIGNORE_FILE.name} not found. Creating a secure default configuration..."
-            )
-            with open(GITIGNORE_FILE, "w", encoding="utf-8") as f:
-                f.write(BASE_GITIGNORE.lstrip())
-            logger.info("Created default .gitignore")
-
-    @classmethod
-    def check_env_leaks(cls):
-        """
-        Scans for .env files (e.g. .env.local, .test.env, prod.env)
-        and uses Git to check if they are ignored.
-        Prevents accidental leaks of secrets.
-        """
-        Console.info("🛡️ Scanning for potential secret leaks (.env files)...")
-
-        raw_files = set(Path(".").rglob(".env*")) | set(Path(".").rglob("*.env"))
-
-        env_files = [
-            f
-            for f in raw_files
-            if f.is_file() and not any(part in EXCLUDED_SCAN_DIRS 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(
-                f"CRITICAL SECURITY RISK: .env files found that are NOT in {GITIGNORE_FILE.name}!"
-            )
-            for lf in leaked_files:
-                print(f"  👉 {lf}")
-
-            ans = (
-                input(
-                    f"🛑 Add these files to {GITIGNORE_FILE.name} automatically? [Y/n]: "
-                )
-                .strip()
-                .lower()
-            )
-            if ans != "n":
-                with open(GITIGNORE_FILE, "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(f"Files successfully added to {GITIGNORE_FILE.name}.")
-            else:
-                Console.warning(
-                    "Action declined. Please be careful: secrets might be pushed!"
-                )

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

@@ -1,28 +0,0 @@
-import subprocess
-import re
-from ..exceptions import ValidationError
-from ..logger import Console, logger
-from ..constants import CONVENTIONAL_COMMIT_PATTERN
-
-
-class ValidatorService:
-    @classmethod
-    def check_conventional_commit(cls, message: str):
-        """Validates message against Conventional Commits standard."""
-        if not re.match(CONVENTIONAL_COMMIT_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!"
-                )