smart-commit-tool 1.1.0__tar.gz → 2.0.1__tar.gz

{smart_commit_tool-1.1.0 → smart_commit_tool-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-commit-tool
-Version: 1.1.0
+Version: 2.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-1.1.0 → smart_commit_tool-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smart-commit-tool"
-version = "1.1.0"
+version = "2.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-2.0.1/src/smart_commit/cli.py

@@ -0,0 +1,105 @@
+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.1/src/smart_commit/config.py

@@ -0,0 +1,41 @@
+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.1/src/smart_commit/constants.py

@@ -0,0 +1,116 @@
+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:
+        # Runs the pipeline on multiple Python versions automatically
+        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' # Speeds up consecutive runs
+
+        - name: Install Dependencies (Adaptive Smart Installer)
+          run: |
+            python -m pip install --upgrade pip
+            
+            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
+                
+            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
+                # 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
+                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.1/src/smart_commit/services/ci.py

@@ -0,0 +1,66 @@
+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-1.1.0 → smart_commit_tool-2.0.1}/src/smart_commit/services/security.py

@@ -1,40 +1,19 @@
 import subprocess
 from pathlib import Path
 from ..logger import Console, logger
+from ..constants import GITIGNORE_FILE, BASE_GITIGNORE, EXCLUDED_SCAN_DIRS
 
 
 class SecurityService:
-    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
-"""
-
     @classmethod
     def ensure_gitignore(cls):
         """Ensures .gitignore exists or creates a secure default."""
-        path = Path(".gitignore")
-        if not path.exists():
+        if not GITIGNORE_FILE.exists():
             Console.warning(
-                ".gitignore not found. Creating a secure default configuration..."
+                f"{GITIGNORE_FILE.name} not found. Creating a secure default configuration..."
             )
-            with open(path, "w", encoding="utf-8") as f:
-                f.write(cls.BASE_GITIGNORE.lstrip())
+            with open(GITIGNORE_FILE, "w", encoding="utf-8") as f:
+                f.write(BASE_GITIGNORE.lstrip())
             logger.info("Created default .gitignore")
 
     @classmethod
@@ -51,11 +30,7 @@ node_modules/
         env_files = [
             f
             for f in raw_files
-            if f.is_file()
-            and not any(
-                part in ["venv", ".venv", "env", "node_modules", ".git", "__pycache__"]
-                for part in f.parts
-            )
+            if f.is_file() and not any(part in EXCLUDED_SCAN_DIRS for part in f.parts)
         ]
 
         leaked_files = []
@@ -69,22 +44,24 @@ node_modules/
 
         if leaked_files:
             Console.error(
-                "CRITICAL SECURITY RISK: .env files found that are NOT in .gitignore!"
+                f"CRITICAL SECURITY RISK: .env files found that are NOT in {GITIGNORE_FILE.name}!"
             )
             for lf in leaked_files:
                 print(f"  👉 {lf}")
 
             ans = (
-                input("🛑 Add these files to .gitignore automatically? [Y/n]: ")
+                input(
+                    f"🛑 Add these files to {GITIGNORE_FILE.name} automatically? [Y/n]: "
+                )
                 .strip()
                 .lower()
             )
             if ans != "n":
-                with open(".gitignore", "a", encoding="utf-8") as f:
+                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("Files successfully added to .gitignore.")
+                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-1.1.0 → smart_commit_tool-2.0.1}/src/smart_commit/services/validator.py

@@ -2,14 +2,14 @@ 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."""
-        pattern = r"^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:\s.+"
-        if not re.match(pattern, message):
+        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')."

smart_commit_tool-1.1.0/src/smart_commit/cli.py

@@ -1,65 +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 .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.1.0/src/smart_commit/config.py

@@ -1,50 +0,0 @@
-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