|
|
@@ -0,0 +1,888 @@
|
|
|
+import subprocess
|
|
|
+import google.generativeai as genai
|
|
|
+import os
|
|
|
+import argparse
|
|
|
+import sys
|
|
|
+import datetime
|
|
|
+import re
|
|
|
+import logging
|
|
|
+import tempfile
|
|
|
+
|
|
|
+# --- Configuration ---
|
|
|
+
|
|
|
+# Configure logging
|
|
|
+logging.basicConfig(level=logging.WARN, format="%(levelname)s: %(message)s")
|
|
|
+
|
|
|
+# Attempt to get API key from environment variable
|
|
|
+API_KEY = os.getenv("GEMINI_API_KEY")
|
|
|
+if not API_KEY:
|
|
|
+ logging.error("GEMINI_API_KEY environment variable not set.")
|
|
|
+ logging.error(
|
|
|
+ "Please obtain an API key from Google AI Studio (https://aistudio.google.com/app/apikey)"
|
|
|
+ )
|
|
|
+ logging.error("and set it as an environment variable:")
|
|
|
+ logging.error(" export GEMINI_API_KEY='YOUR_API_KEY' (Linux/macOS)")
|
|
|
+ logging.error(" set GEMINI_API_KEY=YOUR_API_KEY (Windows CMD)")
|
|
|
+ logging.error(" $env:GEMINI_API_KEY='YOUR_API_KEY' (Windows PowerShell)")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+# Configure the Gemini AI Client
|
|
|
+try:
|
|
|
+ genai.configure(api_key=API_KEY)
|
|
|
+ # Use a model suitable for complex reasoning like code analysis.
|
|
|
+ # Adjust model name if needed (e.g., 'gemini-1.5-flash-latest').
|
|
|
+ MODEL_NAME = os.getenv("GEMINI_MODEL")
|
|
|
+ if not MODEL_NAME:
|
|
|
+ logging.error("GEMINI_MODEL environment variable not set.")
|
|
|
+ logging.error(
|
|
|
+ "Please set the desired Gemini model name (e.g., 'gemini-1.5-flash-latest')."
|
|
|
+ )
|
|
|
+ logging.error(" export GEMINI_MODEL='gemini-1.5-flash-latest' (Linux/macOS)")
|
|
|
+ logging.error(" set GEMINI_MODEL=gemini-1.5-flash-latest (Windows CMD)")
|
|
|
+ logging.error(
|
|
|
+ " $env:GEMINI_MODEL='gemini-1.5-flash-latest' (Windows PowerShell)"
|
|
|
+ )
|
|
|
+ sys.exit(1)
|
|
|
+ model = genai.GenerativeModel(MODEL_NAME)
|
|
|
+ logging.info(f"Using Gemini model: {MODEL_NAME}")
|
|
|
+except Exception as e:
|
|
|
+ logging.error(f"Error configuring Gemini AI: {e}")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+# --- Git Helper Functions ---
|
|
|
+
|
|
|
+
|
|
|
+def run_git_command(command_list, check=True, capture_output=True, env=None):
|
|
|
+ """
|
|
|
+ Runs a Git command as a list of arguments and returns its stdout.
|
|
|
+ Handles errors and returns None on failure if check=True.
|
|
|
+ Allows passing environment variables.
|
|
|
+ """
|
|
|
+ full_command = []
|
|
|
+ try:
|
|
|
+ full_command = ["git"] + command_list
|
|
|
+ logging.debug(f"Running command: {' '.join(full_command)}")
|
|
|
+ cmd_env = os.environ.copy()
|
|
|
+ if env:
|
|
|
+ cmd_env.update(env)
|
|
|
+ result = subprocess.run(
|
|
|
+ full_command,
|
|
|
+ check=check,
|
|
|
+ capture_output=capture_output,
|
|
|
+ text=True,
|
|
|
+ encoding="utf-8",
|
|
|
+ errors="replace",
|
|
|
+ env=cmd_env,
|
|
|
+ )
|
|
|
+ logging.debug(f"Command successful. Output:\n{result.stdout[:200]}...")
|
|
|
+ return result.stdout.strip() if capture_output else ""
|
|
|
+ except subprocess.CalledProcessError as e:
|
|
|
+ logging.error(f"Error executing Git command: {' '.join(full_command)}")
|
|
|
+ stderr_safe = (
|
|
|
+ e.stderr.strip().encode("utf-8", "replace").decode("utf-8")
|
|
|
+ if e.stderr
|
|
|
+ else ""
|
|
|
+ )
|
|
|
+ stdout_safe = (
|
|
|
+ e.stdout.strip().encode("utf-8", "replace").decode("utf-8")
|
|
|
+ if e.stdout
|
|
|
+ else ""
|
|
|
+ )
|
|
|
+ logging.error(f"Exit Code: {e.returncode}")
|
|
|
+ if stderr_safe:
|
|
|
+ logging.error(f"Stderr: {stderr_safe}")
|
|
|
+ if stdout_safe:
|
|
|
+ logging.error(f"Stdout: {stdout_safe}")
|
|
|
+ return None
|
|
|
+ except FileNotFoundError:
|
|
|
+ logging.error(
|
|
|
+ "Error: 'git' command not found. Is Git installed and in your PATH?"
|
|
|
+ )
|
|
|
+ sys.exit(1)
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"An unexpected error occurred running git: {e}")
|
|
|
+ return None
|
|
|
+
|
|
|
+
|
|
|
+def check_git_repository():
|
|
|
+ """Checks if the current directory is the root of a Git repository."""
|
|
|
+ output = run_git_command(["rev-parse", "--is-inside-work-tree"])
|
|
|
+ return output == "true"
|
|
|
+
|
|
|
+
|
|
|
+def get_current_branch():
|
|
|
+ """Gets the current active Git branch name."""
|
|
|
+ return run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
|
|
|
+
|
|
|
+
|
|
|
+def create_backup_branch(branch_name):
|
|
|
+ """Creates a timestamped backup branch from the given branch name."""
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
|
|
|
+ backup_branch_name = f"{branch_name}-backup-{timestamp}"
|
|
|
+ logging.info(
|
|
|
+ f"Attempting to create backup branch: {backup_branch_name} from {branch_name}"
|
|
|
+ )
|
|
|
+ output = run_git_command(["branch", backup_branch_name, branch_name])
|
|
|
+ if output is not None:
|
|
|
+ logging.info(f"Successfully created backup branch: {backup_branch_name}")
|
|
|
+ return backup_branch_name
|
|
|
+ else:
|
|
|
+ logging.error("Failed to create backup branch.")
|
|
|
+ return None
|
|
|
+
|
|
|
+
|
|
|
+def get_commit_range(upstream_ref, current_branch):
|
|
|
+ """
|
|
|
+ Determines the commit range (merge_base..current_branch).
|
|
|
+ Returns the range string and the merge base hash.
|
|
|
+ """
|
|
|
+ logging.info(
|
|
|
+ f"Finding merge base between '{upstream_ref}' and '{current_branch}'..."
|
|
|
+ )
|
|
|
+ merge_base = run_git_command(["merge-base", upstream_ref, current_branch])
|
|
|
+ if not merge_base:
|
|
|
+ logging.error(
|
|
|
+ f"Could not find merge base between '{upstream_ref}' and '{current_branch}'."
|
|
|
+ )
|
|
|
+ logging.error(
|
|
|
+ f"Ensure '{upstream_ref}' is a valid reference (branch, commit, tag)"
|
|
|
+ )
|
|
|
+ logging.error("and that it has been fetched (e.g., 'git fetch origin').")
|
|
|
+ return None, None # Indicate failure
|
|
|
+
|
|
|
+ logging.info(f"Found merge base: {merge_base}")
|
|
|
+ commit_range = f"{merge_base}..{current_branch}"
|
|
|
+ return commit_range, merge_base
|
|
|
+
|
|
|
+
|
|
|
+def get_commits_in_range(commit_range):
|
|
|
+ """Gets a list of commit hashes and subjects in the specified range (oldest first)."""
|
|
|
+ log_output = run_git_command(
|
|
|
+ ["log", "--pretty=format:%h %s", "--reverse", commit_range]
|
|
|
+ )
|
|
|
+ if log_output is not None:
|
|
|
+ commits = log_output.splitlines()
|
|
|
+ logging.info(f"Found {len(commits)} commits in range {commit_range}.")
|
|
|
+ return commits
|
|
|
+ return [] # Return empty list on failure or no commits
|
|
|
+
|
|
|
+
|
|
|
+def get_changed_files_in_range(commit_range):
|
|
|
+ """
|
|
|
+ Gets a list of files changed in the specified range and generates
|
|
|
+ a simple directory structure string representation.
|
|
|
+ """
|
|
|
+ diff_output = run_git_command(["diff", "--name-only", commit_range])
|
|
|
+ if diff_output is not None:
|
|
|
+ files = diff_output.splitlines()
|
|
|
+ logging.info(f"Found {len(files)} changed files in range {commit_range}.")
|
|
|
+
|
|
|
+ # Basic tree structure representation
|
|
|
+ tree = {}
|
|
|
+ for file_path in files:
|
|
|
+ parts = file_path.replace("\\", "/").split("/")
|
|
|
+ node = tree
|
|
|
+ for i, part in enumerate(parts):
|
|
|
+ if not part:
|
|
|
+ continue
|
|
|
+ if i == len(parts) - 1:
|
|
|
+ node[part] = "file"
|
|
|
+ else:
|
|
|
+ if part not in node:
|
|
|
+ node[part] = {}
|
|
|
+ if isinstance(node[part], dict):
|
|
|
+ node = node[part]
|
|
|
+ else:
|
|
|
+ logging.warning(
|
|
|
+ f"Path conflict building file tree for: {file_path}"
|
|
|
+ )
|
|
|
+ break
|
|
|
+
|
|
|
+ def format_tree(d, indent=0):
|
|
|
+ lines = []
|
|
|
+ for key, value in sorted(d.items()):
|
|
|
+ prefix = " " * indent
|
|
|
+ if isinstance(value, dict):
|
|
|
+ lines.append(f"{prefix}📁 {key}/")
|
|
|
+ lines.extend(format_tree(value, indent + 1))
|
|
|
+ else:
|
|
|
+ lines.append(f"{prefix}📄 {key}")
|
|
|
+ return lines
|
|
|
+
|
|
|
+ tree_str = "\n".join(format_tree(tree))
|
|
|
+ return tree_str, files
|
|
|
+ return "", []
|
|
|
+
|
|
|
+
|
|
|
+def get_diff_in_range(commit_range):
|
|
|
+ """Gets the combined diffstat and patch for the specified range."""
|
|
|
+ diff_output = run_git_command(["diff", "--patch-with-stat", commit_range])
|
|
|
+ if diff_output is not None:
|
|
|
+ logging.info(
|
|
|
+ f"Generated diff for range {commit_range} (length: {len(diff_output)} chars)."
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ logging.warning(f"Could not generate diff for range {commit_range}.")
|
|
|
+ return diff_output if diff_output is not None else ""
|
|
|
+
|
|
|
+
|
|
|
+def get_file_content_at_commit(commit_hash, file_path):
|
|
|
+ """Gets the content of a specific file at a specific commit hash."""
|
|
|
+ logging.info(f"Fetching content of '{file_path}' at commit {commit_hash[:7]}...")
|
|
|
+ content = run_git_command(["show", f"{commit_hash}:{file_path}"])
|
|
|
+ if content is None:
|
|
|
+ logging.warning(
|
|
|
+ f"Could not retrieve content for {file_path} at {commit_hash[:7]}."
|
|
|
+ )
|
|
|
+ return None
|
|
|
+ return content
|
|
|
+
|
|
|
+
|
|
|
+# --- AI Interaction ---
|
|
|
+
|
|
|
+
|
|
|
+def generate_fixup_suggestion_prompt(
|
|
|
+ commit_range, merge_base, commits, file_structure, diff
|
|
|
+):
|
|
|
+ """
|
|
|
+ Creates a prompt asking the AI specifically to identify potential
|
|
|
+ fixup candidates within the commit range.
|
|
|
+ Returns suggestions in a parsable format.
|
|
|
+ """
|
|
|
+
|
|
|
+ commit_list_str = (
|
|
|
+ "\n".join([f"- {c}" for c in commits]) if commits else "No commits in range."
|
|
|
+ )
|
|
|
+
|
|
|
+ prompt = f"""
|
|
|
+You are an expert Git assistant. Your task is to analyze the provided Git commit history and identify commits within the range `{commit_range}` that should be combined using `fixup` during an interactive rebase (`git rebase -i {merge_base}`).
|
|
|
+
|
|
|
+**Goal:** Identify commits that are minor corrections or direct continuations of the immediately preceding commit, where the commit message can be discarded.
|
|
|
+
|
|
|
+**Git Commit Message Conventions (for context):**
|
|
|
+* Subject: Imperative, < 50 chars, capitalized, no period. Use types like `feat:`, `fix:`, `refactor:`, etc.
|
|
|
+* Body: Explain 'what' and 'why', wrap at 72 chars.
|
|
|
+
|
|
|
+**Provided Context:**
|
|
|
+
|
|
|
+1. **Commit Range:** `{commit_range}`
|
|
|
+2. **Merge Base Hash:** `{merge_base}`
|
|
|
+3. **Commits in Range (Oldest First - Short Hash & Subject):**
|
|
|
+```
|
|
|
+{commit_list_str}
|
|
|
+```
|
|
|
+4. **Changed Files Structure in Range:**
|
|
|
+```
|
|
|
+{file_structure if file_structure else "No files changed or unable to list."}
|
|
|
+```
|
|
|
+5. **Combined Diff for the Range (`git diff --patch-with-stat {commit_range}`):**
|
|
|
+```diff
|
|
|
+{diff if diff else "No differences found or unable to get diff."}
|
|
|
+```
|
|
|
+
|
|
|
+**Instructions:**
|
|
|
+
|
|
|
+1. Analyze the commits, their messages, the changed files, and the diff.
|
|
|
+2. Identify commits from the list that are strong candidates for being combined into their **immediately preceding commit** using `fixup` (combine changes, discard message). Focus on small fixes, typo corrections, or direct continuations where the commit message isn't valuable.
|
|
|
+3. For each suggestion, output *only* a line in the following format:
|
|
|
+ `FIXUP: <hash_to_fixup> INTO <preceding_hash>`
|
|
|
+ Use the short commit hashes provided in the commit list.
|
|
|
+4. Provide *only* lines in the `FIXUP:` format. Do not include explanations, introductory text, or any other formatting. If no fixups are suggested, output nothing.
|
|
|
+
|
|
|
+**Example Output:**
|
|
|
+
|
|
|
+```text
|
|
|
+FIXUP: hash2 INTO hash1
|
|
|
+FIXUP: hash5 INTO hash4
|
|
|
+```
|
|
|
+
|
|
|
+5. **File Content Request:** If you absolutely need the content of specific files *at specific commits* to confidently determine if they should be fixed up, ask for them clearly ONCE. List the files using this exact format at the end of your response:
|
|
|
+ `REQUEST_FILES: [commit_hash1:path/to/file1.py, commit_hash2:another/path/file2.js]`
|
|
|
+ Use the short commit hashes provided in the commit list. Do *not* ask for files unless essential for *this specific task* of identifying fixup candidates.
|
|
|
+
|
|
|
+Now, analyze the provided context and generate *only* the `FIXUP:` lines or `REQUEST_FILES:` line.
|
|
|
+"""
|
|
|
+ return prompt
|
|
|
+
|
|
|
+
|
|
|
+def parse_fixup_suggestions(ai_response_text, commits_in_range):
|
|
|
+ """Parses AI response for FIXUP: lines and validates hashes."""
|
|
|
+ fixup_pairs = []
|
|
|
+ commit_hashes = {
|
|
|
+ c.split()[0] for c in commits_in_range
|
|
|
+ } # Set of valid short hashes
|
|
|
+
|
|
|
+ for line in ai_response_text.splitlines():
|
|
|
+ line = line.strip()
|
|
|
+ if line.startswith("FIXUP:"):
|
|
|
+ match = re.match(r"FIXUP:\s*(\w+)\s+INTO\s+(\w+)", line, re.IGNORECASE)
|
|
|
+ if match:
|
|
|
+ fixup_hash = match.group(1)
|
|
|
+ target_hash = match.group(2)
|
|
|
+ # Validate that both hashes were in the original commit list
|
|
|
+ if fixup_hash in commit_hashes and target_hash in commit_hashes:
|
|
|
+ fixup_pairs.append({"fixup": fixup_hash, "target": target_hash})
|
|
|
+ logging.debug(
|
|
|
+ f"Parsed fixup suggestion: {fixup_hash} into {target_hash}"
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ logging.warning(
|
|
|
+ f"Ignoring invalid fixup suggestion (hash not in range): {line}"
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ logging.warning(f"Could not parse FIXUP line: {line}")
|
|
|
+ return fixup_pairs
|
|
|
+
|
|
|
+
|
|
|
+# --- request_files_from_user function remains the same ---
|
|
|
+def request_files_from_user(requested_files_str, commits_in_range):
|
|
|
+ """
|
|
|
+ Parses AI request string "REQUEST_FILES: [hash:path, ...]", verifies hashes,
|
|
|
+ asks user permission, fetches file contents, and returns formatted context.
|
|
|
+ """
|
|
|
+ file_requests = []
|
|
|
+ try:
|
|
|
+ content_match = re.search(
|
|
|
+ r"REQUEST_FILES:\s*\[(.*)\]", requested_files_str, re.IGNORECASE | re.DOTALL
|
|
|
+ )
|
|
|
+ if not content_match:
|
|
|
+ logging.warning("Could not parse file request format from AI response.")
|
|
|
+ return None, None
|
|
|
+
|
|
|
+ items_str = content_match.group(1).strip()
|
|
|
+ if not items_str:
|
|
|
+ logging.info("AI requested files but the list was empty.")
|
|
|
+ return None, None
|
|
|
+
|
|
|
+ items = [item.strip() for item in items_str.split(",") if item.strip()]
|
|
|
+ commit_hash_map = {c.split()[0]: c.split()[0] for c in commits_in_range}
|
|
|
+
|
|
|
+ for item in items:
|
|
|
+ if ":" not in item:
|
|
|
+ logging.warning(
|
|
|
+ f"Invalid format in requested file item (missing ':'): {item}"
|
|
|
+ )
|
|
|
+ continue
|
|
|
+ commit_hash, file_path = item.split(":", 1)
|
|
|
+ commit_hash = commit_hash.strip()
|
|
|
+ file_path = file_path.strip()
|
|
|
+
|
|
|
+ if commit_hash not in commit_hash_map:
|
|
|
+ logging.warning(
|
|
|
+ f"AI requested file for unknown/out-of-range commit hash '{commit_hash}'. Skipping."
|
|
|
+ )
|
|
|
+ continue
|
|
|
+ file_requests.append({"hash": commit_hash, "path": file_path})
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"Error parsing requested files string: {e}")
|
|
|
+ return None, None
|
|
|
+
|
|
|
+ if not file_requests:
|
|
|
+ logging.info("No valid file requests found after parsing AI response.")
|
|
|
+ return None, None
|
|
|
+
|
|
|
+ print("\n----------------------------------------")
|
|
|
+ print("❓ AI Request for File Content ❓")
|
|
|
+ print("----------------------------------------")
|
|
|
+ print("The AI needs the content of the following files at specific commits")
|
|
|
+ print("to provide more accurate fixup suggestions:")
|
|
|
+ files_to_fetch = []
|
|
|
+ for i, req in enumerate(file_requests):
|
|
|
+ print(f" {i + 1}. File: '{req['path']}' at commit {req['hash']}")
|
|
|
+ files_to_fetch.append(req)
|
|
|
+
|
|
|
+ if not files_to_fetch:
|
|
|
+ print("\nNo valid files to fetch based on the request.")
|
|
|
+ return None, None
|
|
|
+
|
|
|
+ print("----------------------------------------")
|
|
|
+
|
|
|
+ while True:
|
|
|
+ try:
|
|
|
+ answer = (
|
|
|
+ input("Allow fetching these file contents? (yes/no): ").lower().strip()
|
|
|
+ )
|
|
|
+ except EOFError:
|
|
|
+ logging.warning("Input stream closed. Assuming 'no'.")
|
|
|
+ answer = "no"
|
|
|
+
|
|
|
+ if answer == "yes":
|
|
|
+ logging.info("User approved fetching file content.")
|
|
|
+ fetched_content_list = []
|
|
|
+ for req in files_to_fetch:
|
|
|
+ content = get_file_content_at_commit(req["hash"], req["path"])
|
|
|
+ if content is not None:
|
|
|
+ fetched_content_list.append(
|
|
|
+ f"--- Content of '{req['path']}' at commit {req['hash']} ---\n"
|
|
|
+ f"```\n{content}\n```\n"
|
|
|
+ f"--- End Content for {req['path']} at {req['hash']} ---"
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ fetched_content_list.append(
|
|
|
+ f"--- Could not fetch content of '{req['path']}' at commit {req['hash']} ---"
|
|
|
+ )
|
|
|
+ return "\n\n".join(fetched_content_list), requested_files_str
|
|
|
+
|
|
|
+ elif answer == "no":
|
|
|
+ logging.info("User denied fetching file content.")
|
|
|
+ return None, requested_files_str
|
|
|
+ else:
|
|
|
+ print("Please answer 'yes' or 'no'.")
|
|
|
+
|
|
|
+
|
|
|
+# --- Automatic Rebase Logic ---
|
|
|
+
|
|
|
+
|
|
|
+def create_rebase_editor_script(script_path, fixup_plan):
|
|
|
+ """Creates the python script to be used by GIT_SEQUENCE_EDITOR."""
|
|
|
+ # Create a set of hashes that need to be fixed up
|
|
|
+ fixups_to_apply = {pair["fixup"] for pair in fixup_plan}
|
|
|
+
|
|
|
+ script_content = f"""#!/usr/bin/env python3
|
|
|
+import sys
|
|
|
+import logging
|
|
|
+import re
|
|
|
+import os
|
|
|
+
|
|
|
+# Define log file path relative to the script itself
|
|
|
+log_file = __file__ + ".log"
|
|
|
+# Setup logging within the editor script to write to the log file
|
|
|
+logging.basicConfig(filename=log_file, filemode='w', level=logging.WARN, format="%(asctime)s - %(levelname)s: %(message)s")
|
|
|
+
|
|
|
+todo_file_path = sys.argv[1]
|
|
|
+logging.info(f"GIT_SEQUENCE_EDITOR script started for: {{todo_file_path}}")
|
|
|
+
|
|
|
+# Hashes that should be changed to 'fixup'
|
|
|
+fixups_to_apply = {fixups_to_apply!r}
|
|
|
+logging.info(f"Applying fixups for hashes: {{fixups_to_apply}}")
|
|
|
+
|
|
|
+new_lines = []
|
|
|
+try:
|
|
|
+ with open(todo_file_path, 'r', encoding='utf-8') as f:
|
|
|
+ lines = f.readlines()
|
|
|
+
|
|
|
+ for line in lines:
|
|
|
+ stripped_line = line.strip()
|
|
|
+ # Skip comments and blank lines
|
|
|
+ if not stripped_line or stripped_line.startswith('#'):
|
|
|
+ new_lines.append(line)
|
|
|
+ continue
|
|
|
+
|
|
|
+ # Use regex for more robust parsing of todo lines (action hash ...)
|
|
|
+ match = re.match(r"^(\w+)\s+([0-9a-fA-F]+)(.*)", stripped_line)
|
|
|
+ if match:
|
|
|
+ action = match.group(1).lower()
|
|
|
+ commit_hash = match.group(2)
|
|
|
+ rest_of_line = match.group(3)
|
|
|
+
|
|
|
+ # Check if this commit should be fixed up
|
|
|
+ if commit_hash in fixups_to_apply and action == 'pick':
|
|
|
+ logging.info(f"Changing 'pick {{commit_hash}}' to 'fixup {{commit_hash}}'")
|
|
|
+ # Replace 'pick' with 'fixup', preserving the rest of the line
|
|
|
+ new_line = f'f {{commit_hash}}{{rest_of_line}}\\n'
|
|
|
+ new_lines.append(new_line)
|
|
|
+ else:
|
|
|
+ # Keep the original line
|
|
|
+ new_lines.append(line)
|
|
|
+ else:
|
|
|
+ # Keep lines that don't look like standard todo lines
|
|
|
+ logging.warning(f"Could not parse todo line: {{stripped_line}}")
|
|
|
+ new_lines.append(line)
|
|
|
+
|
|
|
+
|
|
|
+ logging.info(f"Writing {{len(new_lines)}} lines back to {{todo_file_path}}")
|
|
|
+ with open(todo_file_path, 'w', encoding='utf-8') as f:
|
|
|
+ f.writelines(new_lines)
|
|
|
+
|
|
|
+ logging.info("GIT_SEQUENCE_EDITOR script finished successfully.")
|
|
|
+ sys.exit(0) # Explicitly exit successfully
|
|
|
+
|
|
|
+except Exception as e:
|
|
|
+ logging.error(f"Error in GIT_SEQUENCE_EDITOR script: {{e}}", exc_info=True)
|
|
|
+ sys.exit(1) # Exit with error code
|
|
|
+"""
|
|
|
+ try:
|
|
|
+ with open(script_path, "w", encoding="utf-8") as f:
|
|
|
+ f.write(script_content)
|
|
|
+ # Make the script executable (important on Linux/macOS)
|
|
|
+ os.chmod(script_path, 0o755)
|
|
|
+ logging.info(f"Created GIT_SEQUENCE_EDITOR script: {script_path}")
|
|
|
+ return True
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"Failed to create GIT_SEQUENCE_EDITOR script: {e}")
|
|
|
+ return False
|
|
|
+
|
|
|
+
|
|
|
+def attempt_auto_fixup(merge_base, fixup_plan):
|
|
|
+ """Attempts to perform the rebase automatically applying fixups."""
|
|
|
+ if not fixup_plan:
|
|
|
+ logging.info("No fixup suggestions provided by AI. Skipping auto-rebase.")
|
|
|
+ return True # Nothing to do, considered success
|
|
|
+
|
|
|
+ # Use a temporary directory to hold the script and its log
|
|
|
+ temp_dir = tempfile.mkdtemp(prefix="git_rebase_")
|
|
|
+ editor_script_path = os.path.join(temp_dir, "rebase_editor.py")
|
|
|
+ logging.debug(f"Temporary directory: {temp_dir}")
|
|
|
+ logging.debug(f"Temporary editor script path: {editor_script_path}")
|
|
|
+
|
|
|
+ try:
|
|
|
+ if not create_rebase_editor_script(editor_script_path, fixup_plan):
|
|
|
+ return False # Failed to create script
|
|
|
+
|
|
|
+ # Prepare environment for the git command
|
|
|
+ rebase_env = os.environ.copy()
|
|
|
+ rebase_env["GIT_SEQUENCE_EDITOR"] = editor_script_path
|
|
|
+ # Prevent Git from opening a standard editor for messages etc.
|
|
|
+ # 'true' simply exits successfully, accepting default messages
|
|
|
+ rebase_env["GIT_EDITOR"] = "true"
|
|
|
+
|
|
|
+ print("\nAttempting automatic rebase with suggested fixups...")
|
|
|
+ logging.info(f"Running: git rebase -i {merge_base}")
|
|
|
+ # Run rebase non-interactively, check=False to handle failures manually
|
|
|
+ rebase_result = run_git_command(
|
|
|
+ ["rebase", "-i", merge_base],
|
|
|
+ check=False, # Don't raise exception on failure, check exit code
|
|
|
+ capture_output=True, # Capture output to see potential errors
|
|
|
+ env=rebase_env,
|
|
|
+ )
|
|
|
+
|
|
|
+ # Check the result (run_git_command returns None on CalledProcessError)
|
|
|
+ if rebase_result is not None:
|
|
|
+ # Command finished, exit code was likely 0 (success)
|
|
|
+ print("✅ Automatic fixup rebase completed successfully.")
|
|
|
+ logging.info("Automatic fixup rebase seems successful.")
|
|
|
+ return True
|
|
|
+ else:
|
|
|
+ # Command failed (non-zero exit code, run_git_command returned None)
|
|
|
+ print("\n❌ Automatic fixup rebase failed.")
|
|
|
+ print(
|
|
|
+ " This likely means merge conflicts occurred or another rebase error happened."
|
|
|
+ )
|
|
|
+ logging.warning("Automatic fixup rebase failed. Aborting...")
|
|
|
+
|
|
|
+ # Attempt to abort the failed rebase
|
|
|
+ print(" Attempting to abort the failed rebase (`git rebase --abort`)...")
|
|
|
+ # Run abort without capturing output, just check success/failure
|
|
|
+ abort_result = run_git_command(
|
|
|
+ ["rebase", "--abort"], check=False, capture_output=False
|
|
|
+ )
|
|
|
+ # run_git_command returns None on failure (CalledProcessError)
|
|
|
+ if abort_result is not None:
|
|
|
+ print(
|
|
|
+ " Rebase aborted successfully. Your branch is back to its original state."
|
|
|
+ )
|
|
|
+ logging.info("Failed rebase aborted successfully.")
|
|
|
+ else:
|
|
|
+ print(" ⚠️ Failed to automatically abort the rebase.")
|
|
|
+ print(" Please run `git rebase --abort` manually to clean up.")
|
|
|
+ logging.error("Failed to automatically abort the rebase.")
|
|
|
+ return False
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(
|
|
|
+ f"An unexpected error occurred during auto-fixup attempt: {e}",
|
|
|
+ exc_info=True,
|
|
|
+ )
|
|
|
+ # Might need manual cleanup here too
|
|
|
+ print("\n❌ An unexpected error occurred during the automatic fixup attempt.")
|
|
|
+ print(
|
|
|
+ " You may need to manually check your Git status and potentially run `git rebase --abort`."
|
|
|
+ )
|
|
|
+ return False
|
|
|
+ finally:
|
|
|
+ # Determine if rebase failed *before* potential cleanup errors
|
|
|
+ # Note: rebase_result is defined in the outer scope of the try block
|
|
|
+ rebase_failed = "rebase_result" in locals() and rebase_result is None
|
|
|
+
|
|
|
+ # Check if we need to display the editor script log
|
|
|
+ editor_log_path = editor_script_path + ".log"
|
|
|
+ verbose_logging = logging.getLogger().isEnabledFor(logging.DEBUG)
|
|
|
+
|
|
|
+ if (rebase_failed or verbose_logging) and os.path.exists(editor_log_path):
|
|
|
+ try:
|
|
|
+ with open(editor_log_path, "r", encoding="utf-8") as log_f:
|
|
|
+ log_content = log_f.read()
|
|
|
+ if log_content:
|
|
|
+ print("\n--- Rebase Editor Script Log ---")
|
|
|
+ print(log_content.strip())
|
|
|
+ print("--- End Log ---")
|
|
|
+ else:
|
|
|
+ # Only log if verbose, otherwise it's just noise
|
|
|
+ if verbose_logging:
|
|
|
+ logging.debug(
|
|
|
+ f"Rebase editor script log file was empty: {editor_log_path}"
|
|
|
+ )
|
|
|
+ except Exception as log_e:
|
|
|
+ logging.warning(
|
|
|
+ f"Could not read rebase editor script log file {editor_log_path}: {log_e}"
|
|
|
+ )
|
|
|
+
|
|
|
+ # Clean up the temporary directory and its contents
|
|
|
+ if temp_dir and os.path.exists(temp_dir):
|
|
|
+ try:
|
|
|
+ if os.path.exists(editor_log_path):
|
|
|
+ os.remove(editor_log_path)
|
|
|
+ if os.path.exists(editor_script_path):
|
|
|
+ os.remove(editor_script_path)
|
|
|
+ os.rmdir(temp_dir)
|
|
|
+ logging.debug(f"Cleaned up temporary directory: {temp_dir}")
|
|
|
+ except OSError as e:
|
|
|
+ logging.warning(
|
|
|
+ f"Could not completely remove temporary directory {temp_dir}: {e}"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+# --- Main Execution ---
|
|
|
+
|
|
|
+
|
|
|
+def main():
|
|
|
+ """Main function to orchestrate Git analysis and AI interaction."""
|
|
|
+ parser = argparse.ArgumentParser(
|
|
|
+ description="Uses Gemini AI to suggest and automatically attempt Git 'fixup' operations.",
|
|
|
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter,
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ "upstream_ref",
|
|
|
+ nargs="?",
|
|
|
+ default="upstream/main",
|
|
|
+ help="The upstream reference point or commit hash to compare against "
|
|
|
+ "(e.g., 'origin/main', 'upstream/develop', specific_commit_hash). "
|
|
|
+ "Ensure this reference exists and is fetched.",
|
|
|
+ )
|
|
|
+ # --- Argument Change ---
|
|
|
+ parser.add_argument(
|
|
|
+ "--instruct",
|
|
|
+ action="store_true",
|
|
|
+ help="Only show AI suggestions and instructions; disable automatic fixup attempt.",
|
|
|
+ )
|
|
|
+ parser.add_argument(
|
|
|
+ "-v", "--verbose", action="store_true", help="Enable verbose debug logging."
|
|
|
+ )
|
|
|
+ args = parser.parse_args()
|
|
|
+
|
|
|
+ if args.verbose:
|
|
|
+ logging.getLogger().setLevel(logging.DEBUG)
|
|
|
+ logging.debug("Verbose logging enabled.")
|
|
|
+
|
|
|
+ if not check_git_repository():
|
|
|
+ logging.error("This script must be run from within a Git repository.")
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ current_branch = get_current_branch()
|
|
|
+ if not current_branch:
|
|
|
+ logging.error("Could not determine the current Git branch.")
|
|
|
+ sys.exit(1)
|
|
|
+ logging.info(f"Current branch: {current_branch}")
|
|
|
+
|
|
|
+ upstream_ref = args.upstream_ref
|
|
|
+ logging.info(f"Comparing against reference: {upstream_ref}")
|
|
|
+
|
|
|
+ # --- Safety: Create Backup Branch ---
|
|
|
+ # Always create backup, especially if attempting auto-rebase
|
|
|
+ backup_branch = create_backup_branch(current_branch)
|
|
|
+ if not backup_branch:
|
|
|
+ try:
|
|
|
+ confirm = input(
|
|
|
+ "⚠️ Failed to create backup branch. Continue without backup? (yes/no): "
|
|
|
+ ).lower()
|
|
|
+ except EOFError:
|
|
|
+ logging.warning("Input stream closed. Aborting.")
|
|
|
+ confirm = "no"
|
|
|
+ if confirm != "yes":
|
|
|
+ logging.info("Aborting.")
|
|
|
+ sys.exit(1)
|
|
|
+ else:
|
|
|
+ logging.warning("Proceeding without a backup branch. Be careful!")
|
|
|
+ else:
|
|
|
+ print("-" * 40)
|
|
|
+ print(f"✅ Backup branch created: {backup_branch}")
|
|
|
+ print(" If anything goes wrong, you can restore using:")
|
|
|
+ print(f" git checkout {current_branch}")
|
|
|
+ print(f" git reset --hard {backup_branch}")
|
|
|
+ print("-" * 40)
|
|
|
+
|
|
|
+ # --- Gather Git Context ---
|
|
|
+ print("\nGathering Git context...")
|
|
|
+ commit_range, merge_base = get_commit_range(upstream_ref, current_branch)
|
|
|
+ if not commit_range:
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ logging.info(f"Analyzing commit range: {commit_range} (Merge Base: {merge_base})")
|
|
|
+
|
|
|
+ commits = get_commits_in_range(commit_range)
|
|
|
+ if not commits:
|
|
|
+ logging.info(
|
|
|
+ f"No commits found between '{merge_base}' and '{current_branch}'. Nothing to do."
|
|
|
+ )
|
|
|
+ sys.exit(0)
|
|
|
+
|
|
|
+ file_structure, changed_files_list = get_changed_files_in_range(commit_range)
|
|
|
+ diff = get_diff_in_range(commit_range)
|
|
|
+
|
|
|
+ if not diff and not changed_files_list:
|
|
|
+ logging.warning(
|
|
|
+ f"No file changes or diff found between '{merge_base}' and '{current_branch}',"
|
|
|
+ )
|
|
|
+ logging.warning("even though commits exist. AI suggestions might be limited.")
|
|
|
+ # Don't exit automatically, let AI try
|
|
|
+
|
|
|
+ # --- Interact with AI ---
|
|
|
+ print("\nGenerating prompt for AI fixup suggestions...")
|
|
|
+ initial_prompt = generate_fixup_suggestion_prompt(
|
|
|
+ commit_range, merge_base, commits, file_structure, diff
|
|
|
+ )
|
|
|
+
|
|
|
+ logging.debug("\n--- Initial AI Prompt Snippet ---")
|
|
|
+ logging.debug(initial_prompt[:1000] + "...")
|
|
|
+ logging.debug("--- End Prompt Snippet ---\n")
|
|
|
+
|
|
|
+ print(f"Sending request to Gemini AI ({MODEL_NAME})...")
|
|
|
+
|
|
|
+ ai_response_text = ""
|
|
|
+ fixup_suggestions_text = "" # Store the raw suggestions for later display if needed
|
|
|
+ try:
|
|
|
+ convo = model.start_chat(history=[])
|
|
|
+ response = convo.send_message(initial_prompt)
|
|
|
+ ai_response_text = response.text
|
|
|
+
|
|
|
+ # Loop for file requests
|
|
|
+ while "REQUEST_FILES:" in ai_response_text.upper():
|
|
|
+ logging.info("AI requested additional file content.")
|
|
|
+ additional_context, original_request = request_files_from_user(
|
|
|
+ ai_response_text, commits
|
|
|
+ )
|
|
|
+
|
|
|
+ if additional_context:
|
|
|
+ logging.info("Sending fetched file content back to AI...")
|
|
|
+ follow_up_prompt = f"""
|
|
|
+Okay, here is the content of the files you requested:
|
|
|
+
|
|
|
+{additional_context}
|
|
|
+
|
|
|
+Please use this new information to refine your **fixup suggestions** based on the original request and context. Provide the final list of `FIXUP: ...` lines now. Remember to *only* suggest fixup actions and output *only* `FIXUP:` lines. Do not ask for more files.
|
|
|
+"""
|
|
|
+ logging.debug("\n--- Follow-up AI Prompt Snippet ---")
|
|
|
+ logging.debug(follow_up_prompt[:500] + "...")
|
|
|
+ logging.debug("--- End Follow-up Snippet ---\n")
|
|
|
+ response = convo.send_message(follow_up_prompt)
|
|
|
+ ai_response_text = response.text
|
|
|
+ else:
|
|
|
+ logging.info(
|
|
|
+ "Proceeding without providing files as requested by AI or user."
|
|
|
+ )
|
|
|
+ no_files_prompt = f"""
|
|
|
+I cannot provide the content for the files you requested ({original_request}).
|
|
|
+Please proceed with generating the **fixup suggestions** based *only* on the initial context (commit list, file structure, diff) I provided earlier. Make your best suggestions without the file content. Provide the final list of `FIXUP: ...` lines now. Remember to *only* suggest fixup actions.
|
|
|
+"""
|
|
|
+ logging.debug("\n--- No-Files AI Prompt ---")
|
|
|
+ logging.debug(no_files_prompt)
|
|
|
+ logging.debug("--- End No-Files Prompt ---\n")
|
|
|
+ response = convo.send_message(no_files_prompt)
|
|
|
+ ai_response_text = response.text
|
|
|
+ break
|
|
|
+
|
|
|
+ # Store the final AI response containing suggestions
|
|
|
+ fixup_suggestions_text = ai_response_text.strip()
|
|
|
+
|
|
|
+ # Parse the suggestions
|
|
|
+ fixup_plan = parse_fixup_suggestions(fixup_suggestions_text, commits)
|
|
|
+
|
|
|
+ if not fixup_plan:
|
|
|
+ print("\n💡 AI did not suggest any specific fixup operations.")
|
|
|
+ else:
|
|
|
+ print("\n💡 --- AI Fixup Suggestions --- 💡")
|
|
|
+ # Print the parsed plan for clarity
|
|
|
+ for i, pair in enumerate(fixup_plan):
|
|
|
+ print(
|
|
|
+ f" {i + 1}. Fixup commit `{pair['fixup']}` into `{pair['target']}`"
|
|
|
+ )
|
|
|
+ print("💡 --- End AI Suggestions --- 💡")
|
|
|
+
|
|
|
+ # --- Attempt Automatic Rebase or Show Instructions ---
|
|
|
+ # --- Logic Change ---
|
|
|
+ if not args.instruct: # Default behavior: attempt auto-fixup
|
|
|
+ if fixup_plan:
|
|
|
+ success = attempt_auto_fixup(merge_base, fixup_plan)
|
|
|
+ if not success:
|
|
|
+ # Failure message already printed by attempt_auto_fixup
|
|
|
+ print("\n" + "=" * 60)
|
|
|
+ print("🛠️ MANUAL REBASE REQUIRED 🛠️")
|
|
|
+ print("=" * 60)
|
|
|
+ print(
|
|
|
+ "The automatic fixup rebase failed (likely due to conflicts)."
|
|
|
+ )
|
|
|
+ print("Please perform the rebase manually:")
|
|
|
+ print(f" 1. Run: `git rebase -i {merge_base}`")
|
|
|
+ print(
|
|
|
+ " 2. In the editor, change 'pick' to 'f' (or 'fixup') for the commits"
|
|
|
+ )
|
|
|
+ print(
|
|
|
+ " suggested by the AI above (and any other changes you want)."
|
|
|
+ )
|
|
|
+ print(" Original AI suggestions:")
|
|
|
+ print(" ```text")
|
|
|
+ # Print raw suggestions which might be easier to copy/paste
|
|
|
+ print(
|
|
|
+ fixup_suggestions_text
|
|
|
+ if fixup_suggestions_text
|
|
|
+ else " (No specific fixup lines found in AI response)"
|
|
|
+ )
|
|
|
+ print(" ```")
|
|
|
+ print(" 3. Save the editor and resolve any conflicts Git reports.")
|
|
|
+ print(
|
|
|
+ " Use `git status`, edit files, `git add <files>`, `git rebase --continue`."
|
|
|
+ )
|
|
|
+ if backup_branch:
|
|
|
+ print(f" 4. Remember backup branch: {backup_branch}")
|
|
|
+ print("=" * 60)
|
|
|
+ sys.exit(1) # Exit with error status after failure
|
|
|
+ else:
|
|
|
+ # Auto fixup succeeded
|
|
|
+ print("\nBranch history has been modified by automatic fixups.")
|
|
|
+ if backup_branch:
|
|
|
+ print(
|
|
|
+ f"Backup branch '{backup_branch}' still exists if needed."
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ print("\nNo automatic rebase attempted as AI suggested no fixups.")
|
|
|
+
|
|
|
+ elif fixup_plan: # --instruct flag was used AND suggestions exist
|
|
|
+ print("\n" + "=" * 60)
|
|
|
+ print("📝 MANUAL REBASE INSTRUCTIONS (--instruct used) 📝")
|
|
|
+ print("=" * 60)
|
|
|
+ print("AI suggested the fixups listed above.")
|
|
|
+ print("To apply them (or other changes):")
|
|
|
+ print(f" 1. Run: `git rebase -i {merge_base}`")
|
|
|
+ print(" 2. Edit the 'pick' lines in the editor based on the suggestions")
|
|
|
+ print(" (changing 'pick' to 'f' or 'fixup').")
|
|
|
+ print(" 3. Save the editor and follow Git's instructions.")
|
|
|
+ if backup_branch:
|
|
|
+ print(f" 4. Remember backup branch: {backup_branch}")
|
|
|
+ print("=" * 60)
|
|
|
+ # If --instruct and no fixup_plan, nothing specific needs to be printed here
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logging.error(f"\nAn unexpected error occurred: {e}", exc_info=True)
|
|
|
+ # Attempt to print feedback if available
|
|
|
+ try:
|
|
|
+ if response and hasattr(response, "prompt_feedback"):
|
|
|
+ logging.error(f"AI Prompt Feedback: {response.prompt_feedback}")
|
|
|
+ if response and hasattr(response, "candidates"):
|
|
|
+ for candidate in response.candidates:
|
|
|
+ logging.error(
|
|
|
+ f"AI Candidate Finish Reason: {candidate.finish_reason}"
|
|
|
+ )
|
|
|
+ if hasattr(candidate, "safety_ratings"):
|
|
|
+ logging.error(f"AI Safety Ratings: {candidate.safety_ratings}")
|
|
|
+ except Exception as feedback_e:
|
|
|
+ logging.error(
|
|
|
+ f"Could not retrieve detailed feedback from AI response: {feedback_e}"
|
|
|
+ )
|
|
|
+ print("\n❌ An unexpected error occurred during the process.")
|
|
|
+ print(" Please check the logs and your Git status.")
|
|
|
+ print(" You may need to run `git rebase --abort` manually.")
|
|
|
+
|
|
|
+
|
|
|
+if __name__ == "__main__":
|
|
|
+ main()
|
