refactor(interpreter): improve commit message generation and push process

enhance clarity by updating instructions and restructuring functions related to commit message generation from AI responses. streamline git operations by combining actions and renaming functions for better readability.

scripts/interpreter/gen_commit.py

@@ -4,34 +4,21 @@ import subprocess
 from dotenv import load_dotenv
 from interpreter import OpenInterpreter
 
-# Load environment variables from .env
-load_dotenv()
-
-# Constants
-COMMIT_CONVENTION_PATH = os.path.join(os.path.dirname(__file__), "resources/commit_convention.md")
-GIT_COMMANDS_PATH = os.path.join(os.path.dirname(__file__), "resources/git_commit.md")
+load_dotenv()  # Load environment variables from .env
 
 
-def parse_cli_args():
-    """
-    Parse and validate command-line arguments.
-    Returns:
-        tuple: (git_user, git_pass, git_repo, project_path)
-    """
+def get_git_credentials():
+    """Retrieve Git credentials and project path from command-line arguments."""
     if len(sys.argv) != 5:
-        sys.exit("Usage: python gen_commit.py <GIT_USER> <GIT_PASS> <GIT_REPO> <PROJECT_PATH>")
+        print(
+            "Usage: python gen_commit.py <GIT_USER> <GIT_PASS> <GIT_REPO> <PROJECT_PATH>"
+        )
+        sys.exit(1)
     return sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
 
 
-def run_shell_command(command, cwd=None):
-    """
-    Execute a shell command and return the output.
-    Args:
-        command (str): Command to run.
-        cwd (str): Optional working directory.
-    Returns:
-        str: Command output.
-    """
+def run_command(command, cwd=None):
+    """Run a shell command and return the output."""
     try:
         result = subprocess.run(
             command,
@@ -44,80 +31,83 @@ def run_shell_command(command, cwd=None):
         )
         return result.stdout.strip()
     except subprocess.CalledProcessError as e:
-        print(f"[ERROR] Command failed: {command}\n{e.stderr}")
+        print(f"Command failed: {command}\n{e.stderr}")
         return ""
 
 
-def read_file(path):
-    """Read the contents of a file."""
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read()
+def gen_commit(project_path):
+    """Use OpenInterpreter to generate a commit message based on git diff."""
 
-
-def generate_commit_message(project_path):
-    """
-    Use OpenInterpreter to generate a commit message based on the git diff.
-    Args:
-        project_path (str): Path to the project directory.
-    Returns:
-        str: Generated commit message.
-    """
     agent = OpenInterpreter()
     agent.llm.model = "gpt-4o"
     agent.auto_run = True
 
-    convention = read_file(COMMIT_CONVENTION_PATH)
-    git_commands = read_file(GIT_COMMANDS_PATH)
+    # Read both convention and git commit files
+    convention_path = os.path.join(
+        os.path.dirname(__file__), "resources/commit_convention.md"
+    )
+    git_commit_path = os.path.join(os.path.dirname(__file__), "resources/git_commit.md")
+
+    with open(convention_path, "r") as f:
+        convention_content = f.read()
+    with open(git_commit_path, "r") as f:
+        git_commit_content = f.read()
 
     agent.system_message = f"""
     Your name is Bifrost.
     You are a helpful assistant that generates commit messages based on uncommitted code.
 
-    Rules:
+    Follow these rules:
     1. Use English.
-    2. Follow this format:
-    {convention}
-
-    3. Use these git commands to analyze changes:
-    {git_commands}
-
-    4. Return only the commit message. No explanations or extra output.
+    2. Be concise and follow this format:
+    {convention_content}
+    
+    3. Use these git commands to analyze changes as you see fit:
+    {git_commit_content}
+    
+    4. Only return the commit message. Do not add explanation or extra output.
     """
 
     prompt = f"""
+    Generate a commit message based on the following changes in the project directory:
+
+    First, change directory:
     cd {project_path}
-    Check for uncommitted changes in the repository and generate a commit message accordingly.
+
+    Then check the uncommitted changes.
+
+    Then generate a commit message according to the changes.
     """
 
     response = agent.chat(prompt)
 
-    if isinstance(response, list):
-        for item in reversed(response):
-            if isinstance(item, dict) and "content" in item:
-                return item["content"].strip()
+    # Extract just the content from the response
+    if isinstance(response, list) and len(response) > 0:
+        if isinstance(response[-1], dict) and "content" in response[-1]:
+            return response[-1]["content"].strip()
 
     return str(response).strip()
 
 
-def commit_and_push_code():
-    """
-    Pull, generate commit message, commit changes, and push to remote repository.
-    """
-    git_user, git_pass, git_repo, project_path = parse_cli_args()
+def push_code():
+    """Pull, commit, and push code with AI-generated message."""
+    git_user, git_pass, git_repo, project_path = get_git_credentials()
 
+    # Change to project path
     os.chdir(project_path)
 
-    commit_msg = generate_commit_message(project_path)
-    print(f"Generated Commit Message:\n{commit_msg}\n")
+    # Generate commit message
+    commit_msg = gen_commit(project_path)
+    print(f"Generated commit message:\n{commit_msg}\n")
 
+    # Pull, add, commit, and push
     remote_url = f"https://{git_user}:{git_pass}@{git_repo}"
 
-    # Run Git commands
-    run_shell_command(f"git pull {remote_url} || true")
-    run_shell_command("git add .")
-    run_shell_command(f'git commit -m "{commit_msg}" || true')
-    run_shell_command(f"git push {remote_url} || true")
+    run_command(f"git pull {remote_url} || true")
+    run_command("git add .")
+    run_command(f'git commit -m "{commit_msg}" || true')
+    run_command(f"git push {remote_url} || true")
 
 
 if __name__ == "__main__":
-    commit_and_push_code()
+    push_code()