@intentsolutionsio/devops-automation-pack 1.0.0

package/skills/generating-conventional-commits/assets/commit_message_template.txt

@@ -0,0 +1,114 @@
+# Commit Message Template
+
+This template provides a standardized format for creating clear and informative commit messages. Using this template will improve team communication, code review, and project maintainability.
+
+## Format
+
+```
+<type>(<scope>): <subject>
+
+[optional body]
+
+[optional footer(s)]
+```
+
+## Sections
+
+### Type
+
+The type of commit. Choose from the following:
+
+*   **feat:** A new feature
+*   **fix:** A bug fix
+*   **docs:** Documentation only changes
+*   **style:** Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc.)
+*   **refactor:** A code change that neither fixes a bug nor adds a feature
+*   **perf:** A code change that improves performance
+*   **test:** Adding missing tests or correcting existing tests
+*   **build:** Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
+*   **ci:** Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
+*   **chore:** Other changes that don't modify src or test files
+*   **revert:** Reverts a previous commit
+
+**Example:** `feat(user-authentication): Implement password reset functionality`
+
+### Scope
+
+The scope of the commit. This could be a module, component, or area of the codebase affected by the change.  Keep it concise.
+
+**Example:** `feat(api): Add endpoint for retrieving user profiles`
+
+### Subject
+
+A brief and concise description of the change. Use the imperative, present tense: "change" not "changed" nor "changes".
+
+*   Limit to 50 characters.
+*   Do not end with a period.
+
+**Example:** `fix(layout): Correct alignment issues on mobile devices`
+
+### Body (Optional)
+
+A more detailed explanation of the change.  Use the imperative, present tense.  Explain the *why* and *how*.
+
+*   Wrap lines at 72 characters.
+*   Can include multiple paragraphs.
+*   Use bullet points for lists when appropriate.
+
+**Example:**
+
+```
+This commit addresses a critical bug in the user authentication module.  The previous implementation allowed users to bypass the password reset process under certain circumstances.
+
+This was achieved by:
+
+*   Adding a validation check to ensure the password reset token is valid.
+*   Implementing rate limiting to prevent brute-force attacks.
+*   Improving error handling to provide more informative feedback to the user.
+```
+
+### Footer (Optional)
+
+*   **Breaking Changes:**  If the commit introduces a breaking change, describe the change, justification, and migration notes. Start with `BREAKING CHANGE:`.
+*   **Related Issues:** Refer to related issues using `Closes #<issue_number>`, `Fixes #<issue_number>`, or `See #<issue_number>`.
+*   **Co-authored-by:** Credit collaborators using `Co-authored-by: Name <email@example.com>`.
+
+**Example - Breaking Change:**
+
+```
+BREAKING CHANGE:  The API endpoint for retrieving user profiles has been renamed from `/users` to `/profiles`.
+
+Migration: Update all client applications to use the new endpoint.
+```
+
+**Example - Issue Fix:**
+
+```
+Fixes #123:  Resolved issue where users were unable to log in.
+```
+
+## Example Commit Message
+
+```
+feat(payment-gateway): Integrate Stripe payment processing
+
+This commit adds support for Stripe payment processing to the application.
+
+The following changes were made:
+
+*   Implemented the Stripe API integration.
+*   Added a new payment form to the checkout page.
+*   Updated the database schema to store payment information.
+
+Closes #456: Implement Stripe integration
+```
+
+## Best Practices
+
+*   Write clear and concise commit messages.
+*   Use the imperative, present tense.
+*   Limit the subject line to 50 characters.
+*   Provide context in the body of the message.
+*   Include relevant information in the footer.
+*   Review your commit messages before pushing them.
+*   Be consistent with your commit message style.

package/skills/generating-conventional-commits/assets/example_code_diff.txt

@@ -0,0 +1,64 @@
+# Example Code Diff for Commit Message Generation
+
+This document provides an example code diff that can be used by the `devops-automation-pack` plugin to generate commit messages.  The `example_code_diff.txt` file should contain the raw diff output. This file is used as input for plugins like `generate_commit_message` within the `devops-automation-pack`.
+
+## Purpose
+
+The purpose of this file is to provide a clear and concise example of a code diff, which the `generate_commit_message` plugin uses to create informative and helpful commit messages.  This helps developers write better commit messages, improving code maintainability and collaboration.
+
+## File Contents (example_code_diff.txt)
+
+```
+--- a/example.py
++++ b/example.py
+@@ -1,4 +1,5 @@
+ def hello_world():
+-    print("Hello, world!")
++    message = "Hello, world!"
++    print(message)
+ 
+ hello_world()
+
+```
+
+## Explanation
+
+The above diff shows a simple change to the `example.py` file.  Specifically, it shows:
+
+*   **`--- a/example.py`**:  Indicates the original file (`example.py`) before the changes.
+*   **`+++ b/example.py`**:  Indicates the modified file (`example.py`) after the changes.
+*   **`@@ -1,4 +1,5 @@`**:  Indicates the line numbers that were changed.  `-1,4` means lines 1 through 4 in the original file. `+1,5` means lines 1 through 5 in the modified file.
+*   **`-    print("Hello, world!")`**:  The line that was removed (indicated by the `-`).
+*   **`+    message = "Hello, world!"`**: The first line added (indicated by the `+`).
+*   **`+    print(message)`**:  The second line added (indicated by the `+`).
+
+## How to Use This File
+
+1.  **Replace the contents:**  Replace the contents of the `example_code_diff.txt` file with a real code diff that you want to use to generate a commit message. You can obtain this diff using `git diff` or a similar tool.
+2.  **Integrate with the plugin:** Refer to the `devops-automation-pack` plugin documentation for instructions on how to use this file as input for the `generate_commit_message` plugin (or similar plugins that utilize diffs). The plugin will typically read the content of this file and use it to intelligently generate a suggested commit message.
+
+## Example Plugin Usage (Conceptual)
+
+```
+# Example Python code demonstrating how the plugin might use the diff file
+# (This is an illustrative example and might not be the exact API)
+
+from devops_automation_pack import generate_commit_message
+
+with open("example_code_diff.txt", "r") as f:
+  code_diff = f.read()
+
+commit_message = generate_commit_message(code_diff)
+print(commit_message)
+```
+
+## Best Practices
+
+*   **Ensure the diff is clean:**  Make sure the diff is free of merge conflicts or other extraneous information. A clean diff will result in a better commit message.
+*   **Review the generated message:** Always review the generated commit message before committing the changes.  The AI-generated message is a suggestion, and you should always ensure it accurately reflects the changes made.
+*   **Use descriptive diffs:** The more descriptive the diff, the better the AI will be able to understand the changes and generate a relevant commit message.
+
+## Troubleshooting
+
+*   **Plugin not generating a message:**  Double-check that the `example_code_diff.txt` file exists and contains valid diff output.
+*   **Poor quality message:**  Try simplifying the diff or providing additional context to the plugin (if the plugin supports it).  Also, remember to always review and edit the generated message.

package/skills/generating-conventional-commits/references/README.md

@@ -0,0 +1,4 @@
+# References
+
+Bundled resources for devops-automation-pack skill
+

package/skills/generating-conventional-commits/scripts/README.md

@@ -0,0 +1,7 @@
+# Scripts
+
+Bundled resources for devops-automation-pack skill
+
+- [x] validate_commit_message.py: Validates a commit message against the conventional commits specification.
+- [x] generate_commit_message.py: Generates a commit message based on code diffs.
+- [x] suggest_commit_type.py: Suggests the commit type (feat, fix, chore, etc.) based on the changes.

package/skills/generating-conventional-commits/scripts/generate_commit_message.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+Generate conventional commit messages based on code diffs.
+
+This script analyzes git diffs and generates appropriate commit messages
+following the conventional commits specification. It examines the types
+of changes made and suggests an appropriate message format.
+"""
+
+import argparse
+import sys
+import subprocess
+import json
+from pathlib import Path
+from typing import Tuple, Optional
+
+
+def get_git_diff(staged_only: bool = False) -> str:
+    """
+    Get the current git diff.
+
+    Args:
+        staged_only: If True, get only staged changes. Otherwise get unstaged.
+
+    Returns:
+        The git diff output as a string
+    """
+    try:
+        cmd = ['git', 'diff']
+        if staged_only:
+            cmd.append('--cached')
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+
+        if result.returncode != 0:
+            return ""
+
+        return result.stdout
+    except FileNotFoundError:
+        return ""
+
+
+def get_diff_from_file(filepath: str) -> str:
+    """
+    Read diff from a file.
+
+    Args:
+        filepath: Path to the diff file
+
+    Returns:
+        The diff content as a string
+    """
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except FileNotFoundError:
+        print(f"Error: File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    except IOError as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def analyze_diff(diff_content: str) -> Tuple[str, str, str]:
+    """
+    Analyze diff content to suggest commit type and scope.
+
+    Args:
+        diff_content: The git diff content
+
+    Returns:
+        Tuple of (commit_type, scope, description)
+    """
+    # Initialize counters for different change types
+    has_tests = False
+    has_docs = False
+    has_style = False
+    has_feature = False
+    has_fix = False
+    files_changed = []
+
+    lines = diff_content.split('\n')
+
+    for line in lines:
+        # Track which files are being modified
+        if line.startswith('diff --git'):
+            # Extract filename
+            parts = line.split(' ')
+            if len(parts) >= 4:
+                filepath = parts[3]
+                files_changed.append(filepath)
+
+        # Detect test files
+        if 'test' in line.lower() or 'spec' in line.lower():
+            has_tests = True
+
+        # Detect documentation changes
+        if any(x in line.lower() for x in ['.md', 'readme', 'docs/', 'documentation']):
+            has_docs = True
+
+        # Detect style changes (formatting, whitespace)
+        if line.startswith('-') and line.lstrip('-').strip():
+            if len(line.lstrip('-').strip()) < 20:  # Short lines likely style
+                has_style = True
+
+        # Detect feature additions (new functions, classes)
+        if any(x in line for x in ['def ', 'class ', 'function ', 'const ', 'let ']):
+            if line.startswith('+'):
+                has_feature = True
+
+        # Detect bug fixes (removing problematic code)
+        if 'bug' in line.lower() or 'fix' in line.lower():
+            has_fix = True
+
+    # Determine commit type
+    if has_fix:
+        commit_type = 'fix'
+    elif has_feature:
+        commit_type = 'feat'
+    elif has_tests:
+        commit_type = 'test'
+    elif has_docs:
+        commit_type = 'docs'
+    elif has_style:
+        commit_type = 'style'
+    else:
+        commit_type = 'refactor'
+
+    # Determine scope from files changed
+    scope = ''
+    if files_changed:
+        # Extract directory or module name from first file
+        first_file = files_changed[0]
+        parts = Path(first_file).parts
+        if len(parts) > 1:
+            scope = parts[0]
+
+    # Create description
+    description = f"Update code based on diff analysis"
+
+    return commit_type, scope, description
+
+
+def generate_message(
+    commit_type: str,
+    scope: Optional[str],
+    subject: str,
+    body: Optional[str] = None,
+    footer: Optional[str] = None
+) -> str:
+    """
+    Generate a conventional commit message.
+
+    Args:
+        commit_type: Type of commit (feat, fix, docs, etc.)
+        scope: Optional scope of the change
+        subject: Brief description of the change
+        body: Optional detailed body
+        footer: Optional footer (e.g., Closes #123)
+
+    Returns:
+        Formatted conventional commit message
+    """
+    # Build the subject line
+    if scope:
+        subject_line = f"{commit_type}({scope}): {subject}"
+    else:
+        subject_line = f"{commit_type}: {subject}"
+
+    # Ensure subject starts with lowercase
+    parts = subject_line.split(': ', 1)
+    if len(parts) == 2:
+        subject_line = f"{parts[0]}: {parts[1][0].lower()}{parts[1][1:] if len(parts[1]) > 1 else ''}"
+
+    # Build full message
+    message = subject_line
+
+    if body:
+        message += f"\n\n{body}"
+
+    if footer:
+        message += f"\n\n{footer}"
+
+    return message
+
+
+def main():
+    """Main entry point for the commit message generation script."""
+    parser = argparse.ArgumentParser(
+        description="Generate conventional commit messages based on code diffs",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate from staged changes
+  %(prog)s --staged
+
+  # Generate from unstaged changes
+  %(prog)s --unstaged
+
+  # Generate from a diff file
+  %(prog)s --file changes.diff
+
+  # Generate with custom subject
+  %(prog)s --staged --subject "implement new authentication"
+
+  # Output as JSON
+  %(prog)s --staged --format json
+        """
+    )
+
+    input_group = parser.add_mutually_exclusive_group()
+    input_group.add_argument(
+        '--staged',
+        action='store_true',
+        help='Analyze staged changes (default)'
+    )
+    input_group.add_argument(
+        '--unstaged',
+        action='store_true',
+        help='Analyze unstaged changes'
+    )
+    input_group.add_argument(
+        '--file',
+        type=str,
+        help='Path to diff file'
+    )
+
+    parser.add_argument(
+        '--subject',
+        type=str,
+        help='Custom subject for the commit message'
+    )
+    parser.add_argument(
+        '--body',
+        type=str,
+        help='Optional body text'
+    )
+    parser.add_argument(
+        '--footer',
+        type=str,
+        help='Optional footer (e.g., Closes #123)'
+    )
+    parser.add_argument(
+        '--format',
+        choices=['text', 'json'],
+        default='text',
+        help='Output format (default: text)'
+    )
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Enable verbose output'
+    )
+
+    args = parser.parse_args()
+
+    # Get diff content
+    if args.file:
+        diff_content = get_diff_from_file(args.file)
+    elif args.unstaged:
+        diff_content = get_git_diff(staged_only=False)
+    else:  # Default to staged
+        diff_content = get_git_diff(staged_only=True)
+
+    if not diff_content:
+        print("Error: No changes to analyze", file=sys.stderr)
+        return 1
+
+    # Analyze the diff
+    commit_type, scope, _ = analyze_diff(diff_content)
+
+    # Use custom subject if provided
+    subject = args.subject or "update code"
+
+    # Generate message
+    message = generate_message(
+        commit_type,
+        scope if scope else None,
+        subject,
+        args.body,
+        args.footer
+    )
+
+    # Output result
+    if args.format == 'json':
+        output = {
+            'type': commit_type,
+            'scope': scope or None,
+            'subject': subject,
+            'body': args.body,
+            'footer': args.footer,
+            'message': message
+        }
+        print(json.dumps(output, indent=2))
+    else:
+        print(message)
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())