ace-git-copilot 0.2.2__tar.gz → 0.2.4__tar.gz

ace_git_copilot-0.2.4/.agents/AGENTS.md

@@ -0,0 +1,17 @@
+# Custom Rules for Ace Workspace
+
+Whenever a new version of Ace is created (e.g., version incremented in `pyproject.toml` or when releasing a new tag), we must build the package and publish the updated release to PyPI (pip) so that users can install the latest package.
+
+## Publishing Steps
+1. Increment the version number in [pyproject.toml](file:///d:/Ace/pyproject.toml).
+2. Clean previous build artifacts from `dist/`.
+3. Build the wheel and source distribution:
+   ```bash
+   python -m build
+   ```
+   *(or using `hatch build` / `poetry build` as appropriate)*
+4. Upload the built packages to PyPI using twine:
+   ```bash
+   twine upload dist/*
+   ```
+5. Ensure a corresponding git tag is pushed to GitHub.

{ace_git_copilot-0.2.2 → ace_git_copilot-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ace-git-copilot
-Version: 0.2.2
+Version: 0.2.4
 Summary: AI-powered Git copilot — talk to Git in plain English
 License: MIT
 Classifier: License :: OSI Approved :: MIT License
@@ -56,8 +56,11 @@ Ace is an intelligent command-line tool that brings AI assistance directly to yo
 *   **Automated Code Review**: Rates code quality and points out bugs, security flaws, or styling issues inside staged or unstaged diffs.
 *   **Merge Conflict Resolution**: Interactively walks you through conflict blocks and suggests correct merges.
 *   **Rich Repo Stats and Changelogs**: Instantly computes repository statistics (commits, additions, deletions, file counts) and generates markdown release notes since the last tag.
-*   **Semantic Commit Search**: Search commits by natural language queries (e.g. "fixed the authorization bug") instead of matching literal strings.
-*   **Interactive TUI Dashboard**: Run `ace dash` to launch a terminal interface showing current status, branch info, commit charts, and interactive menus.
+*   **Semantic Commit Search & Checkout**: Search commits by natural language queries and interactively inspect diffs, checkout commits, or create branches.
+*   **Interactive TUI Dashboard**: Run `ace dash` to launch a terminal interface showing current status, branch info, workspace repository listings, and interactive menus.
+*   **Repository Health Diagnostics**: Run `ace doctor` to run repository health checks (detached heads, locks, large files) and generate step-by-step AI recovery advice.
+*   **Smart Git Hooks**: Run `ace hook install` to register pre-commit code review checks and prepare-commit-msg message drafting.
+*   **AI Auto-Squashing & Rebasing**: Run `ace squash` to automatically analyze branch commits and run automated interactive rebases.
 *   **Safety Features**: Classifies actions into safe, moderate, or destructive levels, and requests confirmation before running destructive operations.
 
 ---
@@ -153,10 +156,13 @@ Ace has dedicated subcommands for specific tasks. Here is the complete command l
 | `ace review` | — | Run code review on staged, unstaged, or branch changes. |
 | `ace resolve` | — | Step-by-step interactive merge conflict resolver. |
 | `ace explain <query>`| — | Explain complex Git commands or repository errors. |
+| `ace doctor` | — | Run repository diagnostics and generate step-by-step AI recovery recipes. |
+| `ace hook <action>` | — | Install or uninstall pre-commit and prepare-commit-msg Git hooks. |
 | `ace stats` | — | Rich visualization of repo statistics, extension breakdowns, and history. |
 | `ace changelog` | — | Compile release changelogs since the last tag. |
 | `ace pr` | — | Draft a Markdown pull request title and description. |
-| `ace search <query>` | — | Semantically search commit history using natural language. |
+| `ace search <query>` | — | Semantically search commit history with interactive checkout options. |
+| `ace squash` | — | Automatically analyze commit history and run AI-guided interactive rebases. |
 | `ace ignore <rule>` | — | Generate and append standard templates to `.gitignore`. |
 | `ace undo` | — | Safely revert the last action after checking repository status. |
 | `ace dash` | — | Launch the interactive repository management console (TUI). |

{ace_git_copilot-0.2.2 → ace_git_copilot-0.2.4}/README.md

@@ -28,8 +28,11 @@ Ace is an intelligent command-line tool that brings AI assistance directly to yo
 *   **Automated Code Review**: Rates code quality and points out bugs, security flaws, or styling issues inside staged or unstaged diffs.
 *   **Merge Conflict Resolution**: Interactively walks you through conflict blocks and suggests correct merges.
 *   **Rich Repo Stats and Changelogs**: Instantly computes repository statistics (commits, additions, deletions, file counts) and generates markdown release notes since the last tag.
-*   **Semantic Commit Search**: Search commits by natural language queries (e.g. "fixed the authorization bug") instead of matching literal strings.
-*   **Interactive TUI Dashboard**: Run `ace dash` to launch a terminal interface showing current status, branch info, commit charts, and interactive menus.
+*   **Semantic Commit Search & Checkout**: Search commits by natural language queries and interactively inspect diffs, checkout commits, or create branches.
+*   **Interactive TUI Dashboard**: Run `ace dash` to launch a terminal interface showing current status, branch info, workspace repository listings, and interactive menus.
+*   **Repository Health Diagnostics**: Run `ace doctor` to run repository health checks (detached heads, locks, large files) and generate step-by-step AI recovery advice.
+*   **Smart Git Hooks**: Run `ace hook install` to register pre-commit code review checks and prepare-commit-msg message drafting.
+*   **AI Auto-Squashing & Rebasing**: Run `ace squash` to automatically analyze branch commits and run automated interactive rebases.
 *   **Safety Features**: Classifies actions into safe, moderate, or destructive levels, and requests confirmation before running destructive operations.
 
 ---
@@ -125,10 +128,13 @@ Ace has dedicated subcommands for specific tasks. Here is the complete command l
 | `ace review` | — | Run code review on staged, unstaged, or branch changes. |
 | `ace resolve` | — | Step-by-step interactive merge conflict resolver. |
 | `ace explain <query>`| — | Explain complex Git commands or repository errors. |
+| `ace doctor` | — | Run repository diagnostics and generate step-by-step AI recovery recipes. |
+| `ace hook <action>` | — | Install or uninstall pre-commit and prepare-commit-msg Git hooks. |
 | `ace stats` | — | Rich visualization of repo statistics, extension breakdowns, and history. |
 | `ace changelog` | — | Compile release changelogs since the last tag. |
 | `ace pr` | — | Draft a Markdown pull request title and description. |
-| `ace search <query>` | — | Semantically search commit history using natural language. |
+| `ace search <query>` | — | Semantically search commit history with interactive checkout options. |
+| `ace squash` | — | Automatically analyze commit history and run AI-guided interactive rebases. |
 | `ace ignore <rule>` | — | Generate and append standard templates to `.gitignore`. |
 | `ace undo` | — | Safely revert the last action after checking repository status. |
 | `ace dash` | — | Launch the interactive repository management console (TUI). |

ace_git_copilot-0.2.4/ace/ai/prompts/doctor.py

@@ -0,0 +1,24 @@
+# Prompt templates for Git Diagnostics (ace doctor)
+
+DOCTOR_SYSTEM_PROMPT = """
+You are "Ace", an expert Git engineer and repository doctor.
+Your job is to analyze the Git repository diagnostic findings and compile a clear explanation of what is wrong, along with a step-by-step recovery plan (with exact Git commands) to restore the repository to a clean, stable state.
+
+Output format:
+Your output must be formatted as markdown.
+Include:
+1. 🩺 **Diagnostics Assessment**: A brief explanation of the problems found.
+2. 📋 **Recovery Plan**: A step-by-step guide with instructions and standard code blocks (e.g. `git restore` or `git stash`) to resolve the issues.
+3. 💡 **Prevention Tip**: A short advice block on how to prevent this state in the future.
+
+Ensure all commands proposed are safe and exact. Avoid destructive operations without providing a clear stash/backup alternative first.
+"""
+
+USER_PROMPT_TEMPLATE = """
+Diagnostic Findings:
+\"\"\"
+{diagnostics_json}
+\"\"\"
+
+Analyze these findings and provide your diagnostics report and recovery guide.
+"""

ace_git_copilot-0.2.4/ace/ai/prompts/rebase.py

@@ -0,0 +1,36 @@
+# Prompt templates for Git Auto-Squash & Rebase Helper (ace squash)
+
+REBASE_SYSTEM_PROMPT = """
+You are "Ace", an expert Git engineer.
+Your job is to analyze the local commits on a developer's branch and recommend how to group, squash, or reword them to build a clean, professional commit history.
+
+You will be given:
+1. The list of recent local commits on the branch.
+
+You MUST respond with a JSON object containing the following keys (no markdown blocks, no other text):
+{
+  "recommendations": [
+    {
+      "hexsha": "commit_hash",
+      "summary": "commit_summary",
+      "action": "pick" | "squash" | "reword" | "drop",
+      "new_message": "New commit message if action is reword, or null"
+    }
+  ],
+  "explanation": "A brief explanation of the proposed squashing logic."
+}
+
+Guidelines:
+1. The oldest commit (chronologically first) MUST be 'pick'. You cannot squash the base/first commit of the branch.
+2. Group temporary commits (e.g., "typo fix", "formatting", "wip", "cleanup") into the main functional commits that preceded them by recommending "squash".
+3. Recommend "reword" to clean up poor messages to conform to clean Git conventions.
+"""
+
+USER_PROMPT_TEMPLATE = """
+Local Commits on branch:
+\"\"\"
+{commit_list_text}
+\"\"\"
+
+Analyze these commits and recommend rebase/squash actions.
+"""

ace_git_copilot-0.2.4/ace/ai/rebase_helper.py

@@ -0,0 +1,157 @@
+import os
+import tempfile
+import json
+import sys
+from typing import Dict, Any, List
+from langchain_core.messages import SystemMessage, HumanMessage
+from ace.core.git_ops import GitOps
+from ace.ai.llm_factory import get_llm
+from ace.ai.prompts.rebase import REBASE_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+from ace.utils.json_utils import extract_json
+
+class RebaseHelper:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+
+    def get_local_commits(self, base_branch: str) -> List[Dict[str, Any]]:
+        """Get list of local commits not merged into the base branch, in chronological order."""
+        try:
+            log_data = self.git_ops.execute(f"log {base_branch}..HEAD --reverse --format=%H|%an|%s")
+        except Exception:
+            return []
+            
+        commits = []
+        for line in log_data.splitlines():
+            if "|" in line:
+                parts = line.split("|")
+                if len(parts) >= 3:
+                    commits.append({
+                        "hexsha": parts[0],
+                        "author": parts[1],
+                        "summary": parts[2].strip()
+                    })
+        return commits
+
+    def analyze_commits(self, commits: List[Dict[str, Any]], offline: bool = False) -> Dict[str, Any]:
+        """Ask LLM to recommend squash/reword actions for the local commits."""
+        commit_lines = []
+        for c in commits:
+            commit_lines.append(f"- {c['hexsha'][:7]} - {c['summary']} (by {c['author']})")
+        commit_list_text = "\n".join(commit_lines)
+
+        usr_prompt = USER_PROMPT_TEMPLATE.format(commit_list_text=commit_list_text)
+        
+        messages = [
+            SystemMessage(content=REBASE_SYSTEM_PROMPT),
+            HumanMessage(content=usr_prompt)
+        ]
+
+        llm = get_llm(offline_override=offline)
+        response = llm.invoke(messages)
+        
+        return extract_json(response.content)
+
+    def run_auto_rebase(self, base_branch: str, recommendations: List[Dict[str, Any]]) -> str:
+        """Execute programmatic interactive rebase using Python sequence and message editors."""
+        action_map = {}
+        reword_messages = {}
+        for rec in recommendations:
+            sha = rec["hexsha"][:7].lower()
+            action_map[sha] = rec["action"].lower()
+            if rec["action"].lower() == "reword" and rec.get("new_message"):
+                reword_messages[rec["summary"].strip()] = rec["new_message"]
+
+        # Create mapping JSON
+        map_data = {
+            "actions": action_map,
+            "rewords": reword_messages
+        }
+        
+        fd, map_path = tempfile.mkstemp(suffix=".json")
+        editor_path = None
+        reword_editor_path = None
+        
+        try:
+            with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                json.dump(map_data, f)
+
+            # Sequence editor: edits git-rebase-todo
+            seq_code = f"""import sys, json
+with open({repr(map_path)}, 'r') as f:
+    data = json.load(f)
+actions = data['actions']
+
+todo_path = sys.argv[1]
+with open(todo_path, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+lines = []
+for line in content.splitlines():
+    if not line.strip() or line.startswith('#'):
+        lines.append(line)
+        continue
+    parts = line.split()
+    if len(parts) >= 2 and parts[0] == 'pick':
+        sha = parts[1][:7].lower()
+        if sha in actions:
+            action = actions[sha]
+            lines.append(action + ' ' + ' '.join(parts[1:]))
+            continue
+    lines.append(line)
+
+with open(todo_path, 'w', encoding='utf-8') as f:
+    f.write('\\n'.join(lines) + '\\n')
+"""
+            editor_fd, editor_path = tempfile.mkstemp(suffix=".py")
+            with os.fdopen(editor_fd, 'w', encoding='utf-8') as f:
+                f.write(seq_code)
+
+            # Commit msg editor: edits COMMIT_EDITMSG for reword actions
+            reword_code = f"""import sys, json
+with open({repr(map_path)}, 'r') as f:
+    data = json.load(f)
+rewords = data['rewords']
+
+msg_path = sys.argv[1]
+with open(msg_path, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+lines = content.splitlines()
+if lines:
+    subject = lines[0].strip()
+    if subject in rewords:
+        new_msg = rewords[subject]
+        comments = [l for l in lines[1:] if l.strip().startswith('#')]
+        with open(msg_path, 'w', encoding='utf-8') as f_out:
+            f_out.write(new_msg + '\\n\\n' + '\\n'.join(comments))
+"""
+            reword_fd, reword_editor_path = tempfile.mkstemp(suffix=".py")
+            with os.fdopen(reword_fd, 'w', encoding='utf-8') as f:
+                f.write(reword_code)
+
+            # Execute rebase with environment variables
+            env = os.environ.copy()
+            python_exe = sys.executable
+            env["GIT_SEQUENCE_EDITOR"] = f'"{python_exe}" "{editor_path}"'
+            env["GIT_EDITOR"] = f'"{python_exe}" "{reword_editor_path}"'
+            
+            # Execute command directly using GitPython
+            # Run rebase -i base_branch
+            # GitPython execute method wraps repo.git
+            return self.git_ops.repo.git.rebase("-i", base_branch, env=env)
+        finally:
+            # Clean up temp files
+            try:
+                os.unlink(map_path)
+            except Exception:
+                pass
+            if editor_path:
+                try:
+                    os.unlink(editor_path)
+                except Exception:
+                    pass
+            if reword_editor_path:
+                try:
+                    os.unlink(reword_editor_path)
+                except Exception:
+                    pass