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()  # 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")
 
 
-def parse_cli_args():
+def get_git_credentials():
-    """
+    """Retrieve Git credentials and project path from command-line arguments."""
-    Parse and validate command-line arguments.
-    Returns:
-        tuple: (git_user, git_pass, git_repo, project_path)
-    """
     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):
+def run_command(command, cwd=None):
-    """
+    """Run a shell command and return the output."""
-    Execute a shell command and return the output.
-    Args:
-        command (str): Command to run.
-        cwd (str): Optional working directory.
-    Returns:
-        str: Command 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):
+def gen_commit(project_path):
-    """Read the contents of a file."""
+    """Use OpenInterpreter to generate a commit message based on git diff."""
-    with open(path, "r", encoding="utf-8") as f:
-        return f.read()
 
-
-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)
+    # Read both convention and git commit files
-    git_commands = read_file(GIT_COMMANDS_PATH)
+    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:
+    2. Be concise and follow this format:
-    {convention}
+    {convention_content}
     
-    3. Use these git commands to analyze changes:
+    3. Use these git commands to analyze changes as you see fit:
-    {git_commands}
+    {git_commit_content}
     
-    4. Return only the commit message. No explanations or extra output.
+    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):
+    # Extract just the content from the response
-        for item in reversed(response):
+    if isinstance(response, list) and len(response) > 0:
-            if isinstance(item, dict) and "content" in item:
+        if isinstance(response[-1], dict) and "content" in response[-1]:
-                return item["content"].strip()
+            return response[-1]["content"].strip()
 
     return str(response).strip()
 
 
-def commit_and_push_code():
+def push_code():
-    """
+    """Pull, commit, and push code with AI-generated message."""
-    Pull, generate commit message, commit changes, and push to remote repository.
+    git_user, git_pass, git_repo, project_path = get_git_credentials()
-    """
-    git_user, git_pass, git_repo, project_path = parse_cli_args()
 
+    # Change to project path
     os.chdir(project_path)
 
-    commit_msg = generate_commit_message(project_path)
+    # Generate commit message
-    print(f"Generated Commit Message:\n{commit_msg}\n")
+    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_command(f"git pull {remote_url} || true")
-    run_shell_command(f"git pull {remote_url} || true")
+    run_command("git add .")
-    run_shell_command("git add .")
+    run_command(f'git commit -m "{commit_msg}" || true')
-    run_shell_command(f'git commit -m "{commit_msg}" || true')
+    run_command(f"git push {remote_url} || true")
-    run_shell_command(f"git push {remote_url} || true")
 
 
 if __name__ == "__main__":
-    commit_and_push_code()
+    push_code()