Commit בעזרת GPT 🪄

~/learn-git$ git init
Initialized empty Git repository in ~/learn-git/.git/

~/learn-git$ echo hello > file.txt
~/learn-git$ git add .
~/learn-git$ git commit -m "initial"
[master (root-commit) 865ed74] initial
 1 file changed, 1 insertion(+)
 create mode 100644 file.txt

~/learn-git$ git diff
diff --git a/file.txt b/file.txt
index ce01362..3b18e51 100644
--- a/file.txt
+++ b/file.txt
@@ -1 +1 @@
-hello
+hello world

I need a detailed and specific commit message for the following Git code changes.
The message should reflect the actual code modifications, improvements, or fixes made.
Please provide the message in JSON format, with distinct sections for a summary
message, bullet points detailing specific changes, and any necessary warnings about
the code, such as potential issues or areas needing attention.

Changes:
--- a/file.txt
+++ b/file.txt
@@ -1 +1 @@
-hello
+hello world

The response should be technically specific, aligning closely with the provided code changes, and 
avoiding generic or placeholder text.
Be concise and on-point, without providing excess information.

... 
Please format the response as follows:
{{
    "message": "A concise summary, specifically describing the key change or improvement. Must be 72 chars or less",
    "bullets": [
        "Specific detail about a particular code change, including file and function names if applicable",
        "Description of another specific change, noting how it affects the functionality or structure of the code",
        ...
    ],
    "warnings": [
        "Optional. Necessary warnings or notes of caution about specific parts of the changes",
        ...
    ]
}}

git diff --cached --name-only

git diff --cached { path }

# class: `git_commands`
def get_git_diffs():
    """Get diffs of staged changes in the repository."""
    subprocess.run(['git', 'add', '.'])  # Ensure all changes are staged
    changed_files = subprocess.check_output(['git', 'diff', '--cached', '--name-only']).decode().splitlines()
    diff_output = ""

    for file in changed_files:
        diff_output += f"\n📄 {file}\n"
        diff_output += "-" * len(file) + "\n"
        file_diff = subprocess.check_output(['git', 'diff', '--cached', file]).decode()
        diff_output += file_diff + "\n"

    return diff_output

# class: `openai_integration`
def generate_commit_message(diffs):
    """Generate a commit message using GPT-4 and format the response as JSON."""
    # 1. Environment Setup: Retrieve API Key
    openai_api_key = os.getenv("OPENAI_API_KEY")
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {openai_api_key}'
    }

    # 2. Prompt Construction: Define the request for GPT-4
    prompt = f"""
        I need a detailed and specific commit message for the following Git code changes.
        The message should reflect the actual code modifications, improvements, or fixes made.
        Please provide the message in JSON format, with distinct sections for a summary
        message, bullet points detailing specific changes, and any necessary warnings about
        the code, such as potential issues or areas needing attention.

        Changes:
        {diffs}

        Please format the response as follows:
        {{
            "message": "A concise summary, specifically describing the key change or improvement. Must be 72 chars or less",
            "bullets": [
                "Specific detail about a particular code change, including file and function names if applicable",
                "Description of another specific change, noting how it affects the functionality or structure of the code",
                ...
            ],
            "warnings": [
                "Optional. Necessary warnings or notes of caution about specific parts of the changes",
                ...
            ]
        }}

        The response should be technically specific, aligning closely with the provided code changes, and avoiding generic or placeholder text.
        Be concise and on-point, without providing excess information.
    """

    # 3. API Call: Send the request to OpenAI's API
    data = {
        "model": "gpt-4-1106-preview",
        "messages": [
            {"role": "system", "content": "You are an assistant, and you only reply with JSON."},
            {"role": "user", "content": prompt}
        ],
        "response_format": {
            "type": "json_object"
        }
    }

    response = requests.post(
        'https://api.openai.com/v1/chat/completions',
        headers=headers,
        data=json.dumps(data)
    )

    # 4. Response Handling: Parse and format the API response
    response_json = response.json()
    response_text = response_json['choices'][0]['message']['content']
    try:
        formatted_response = json.loads(response_text)
    except json.JSONDecodeError:
        formatted_response = {"message": "Failed to parse response", "bullets": []}

    return formatted_response

# class: `main`
suggested_message_json = generate_commit_message(diffs)
suggested_message_json.get("warnings", [])
print_warnings(warnings)

# class: `cli_utilities`
def print_warnings(warnings):
    """Prints warnings in a formatted manner."""
    if warnings:
        for warning in warnings:
            print(f"- {warning}")
    else:
        print("\n✅ No warnings.")

# class: `openai_integration`
def format_commit_message_from_json(commit_json):
    """Format the commit message from JSON to a string."""
    message_str = commit_json.get("message", "")
    bullets = commit_json.get("bullets", [])
    
    formatted_bullets = "\n".join(f"- {bullet}" for bullet in bullets)
    return f"{message_str}\n\n{formatted_bullets}"

# class: `main`
print("📬 Suggested commit message:")
suggested_message = format_commit_message_from_json(suggested_message_json)
print(suggested_message)

print("\n👇 Choose an action:")
user_decision = input("1️⃣ Use the current commit message\n"
                      "2️⃣ Generate a new commit message\n"
                      "3️⃣ Edit the current commit message\n"
                      "Your choice (1/2/3): ").strip()

if user_decision == '1':
    commit_message = suggested_message
    break
elif user_decision == '2':
    continue
elif user_decision == '3':
    commit_message = edit_message_in_editor(suggested_message)
    break
else:
    print("❌ Invalid choice. Please enter 1, 2, or 3.")

# class: `cli_utilities`
def edit_message_in_editor(message):
    """Open the message in a text editor (Nano) for editing."""
    with tempfile.NamedTemporaryFile(suffix=".tmp", delete=False, mode='w+') as tf:
        tf_path = tf.name
        tf.write(message)
        tf.flush()

    editor = os.getenv('EDITOR', 'nano')  # Use Nano or the default editor set in the environment
    subprocess.call([editor, tf_path])

    with open(tf_path, "r") as tf:
        edited_message = tf.read()

    os.remove(tf_path)  # Clean up the temporary file
    return edited_message

# class: `git_commands`
def stage_changes():
    """Stage all changes in the repository."""
    subprocess.run(['git', 'add', '.'])
    
def commit_changes(commit_message):
    """Commit changes with a given message."""
    subprocess.run(['git', 'commit', '-m', commit_message])

def push_changes(branch_name='main'):
    """Push changes to the remote repository."""
    subprocess.run(['git', 'push', 'origin', branch_name])

# class: `setup`
setup(
    name='gpit',
    version='0.0.3',
    packages=find_packages(),
    install_requires=[
        'requests',
    ],
    entry_points={
        'console_scripts': [
            'gpit=gpit.main:main',
        ],
    },
    author='Ofir Steinherz',
    author_email='ofir.steinherz@gmail.com',
    description='GPT-Powered Commit Assistance'
)

install:
  #Install the package
	pip install .

clean:
	#Clean unnecessary package upload generated files
	rm -rf dist/
	rm -rf build/
	rm -rf *.egg-info
	find . -name '__pycache__' -exec rm -rf {} +

upload:
	#Upload new version to PyPI
	rm -rf dist/
	python3 setup.py sdist bdist_wheel
	twine upload dist/*