ace-git-copilot 0.1.0__py3-none-any.whl

ace/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ace/ai/changelog_generator.py

@@ -0,0 +1,70 @@
+from typing import Optional
+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.changelog import CHANGELOG_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+
+class ChangelogGeneratorError(Exception):
+    """Raised when changelog generation fails."""
+    pass
+
+class ChangelogGenerator:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+
+    def get_commits_in_range(self, from_ref: Optional[str] = None, to_ref: Optional[str] = None) -> str:
+        """
+        Retrieve formatted commit log between from_ref and to_ref.
+        If from_ref is None, attempts to find the latest tag.
+        If no latest tag exists, falls back to the last 30 commits.
+        """
+        to_revision = to_ref or "HEAD"
+        from_revision = from_ref
+        
+        # If from_ref is not provided, try to find the latest tag
+        if not from_revision:
+            try:
+                # git describe --tags --abbrev=0 to get latest tag
+                latest_tag = self.git_ops.execute("describe --tags --abbrev=0").strip()
+                from_revision = latest_tag
+            except Exception:
+                # No tags found
+                from_revision = None
+
+        log_args = ["log"]
+        if from_revision:
+            log_args.append(f"{from_revision}..{to_revision}")
+        else:
+            # Fallback to last 30 commits
+            log_args.extend(["-n", "30"])
+
+        # Format: hash|date|author|subject\nbody
+        log_args.append('--format=%H|%ad|%an|%s%n%b')
+        
+        try:
+            cmd = " ".join(log_args)
+            return self.git_ops.execute(cmd).strip()
+        except Exception as e:
+            raise ChangelogGeneratorError(f"Failed to fetch commit log: {e}")
+
+    def generate_changelog(self, from_ref: Optional[str] = None, to_ref: Optional[str] = None, offline: bool = False) -> str:
+        """
+        Retrieve commits and generate a release changelog in Markdown.
+        """
+        commit_log = self.get_commits_in_range(from_ref, to_ref)
+        if not commit_log.strip():
+            return "No commits found in the specified range."
+
+        llm = get_llm(offline_override=offline)
+        
+        user_prompt = USER_PROMPT_TEMPLATE.format(
+            commit_log=commit_log[:20000] # Cap log length to respect context window
+        )
+
+        messages = [
+            SystemMessage(content=CHANGELOG_SYSTEM_PROMPT),
+            HumanMessage(content=user_prompt)
+        ]
+
+        response = llm.invoke(messages)
+        return response.content.strip()

ace/ai/code_reviewer.py

@@ -0,0 +1,81 @@
+from typing import Dict, Any, List, Tuple
+from langchain_core.messages import SystemMessage, HumanMessage
+from ace.core.git_ops import GitOps
+from ace.utils.diff_parser import split_diff_by_file, trim_diff
+from ace.ai.llm_factory import get_llm
+from ace.ai.prompts.review import REVIEW_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+from ace.utils.json_utils import extract_json
+
+class CodeReviewerError(Exception):
+    """Raised when code review processing fails."""
+    pass
+
+class CodeReviewer:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+
+    def review_diff(self, diff_text: str, offline: bool = False) -> Tuple[List[Dict[str, Any]], float]:
+        """
+        Perform a code review on a raw diff string.
+        
+        Returns a tuple of (findings, overall_score).
+        """
+        if not diff_text.strip():
+            return [], 10.0
+
+        # Split diff by file
+        file_diffs = split_diff_by_file(diff_text)
+        if not file_diffs:
+            return [], 10.0
+
+        all_findings = []
+        scores = []
+        llm = get_llm(offline_override=offline)
+
+        for filename, diff_content in file_diffs.items():
+            # Skip binary diffs or very small metadata updates
+            if "Binary files" in diff_content or len(diff_content.strip()) < 20:
+                continue
+
+            user_prompt = USER_PROMPT_TEMPLATE.format(
+                filename=filename,
+                diff_content=trim_diff(diff_content, max_chars=15000)  # Cap file diff size
+            )
+
+            messages = [
+                SystemMessage(content=REVIEW_SYSTEM_PROMPT),
+                HumanMessage(content=user_prompt)
+            ]
+
+            try:
+                response = llm.invoke(messages)
+                parsed = extract_json(response.content)
+                
+                # Extract score and findings
+                score = float(parsed.get("score", 10.0))
+                scores.append(score)
+                
+                findings = parsed.get("findings", [])
+                if isinstance(findings, list):
+                    for finding in findings:
+                        # Annotate with the filename
+                        finding["file"] = filename
+                        all_findings.append(finding)
+            except Exception as e:
+                # Log or handle exception per file, but don't crash the whole review
+                # We can add a fallback warning finding
+                all_findings.append({
+                    "file": filename,
+                    "category": "suggestion",
+                    "severity": "info",
+                    "line": None,
+                    "description": f"AI review failed for this file: {e}",
+                    "fix": None
+                })
+                scores.append(10.0)
+
+        overall_score = sum(scores) / len(scores) if scores else 10.0
+        # Round overall score
+        overall_score = round(overall_score, 1)
+
+        return all_findings, overall_score

ace/ai/commit_generator.py

@@ -0,0 +1,73 @@
+from langchain_core.messages import SystemMessage, HumanMessage
+from ace.core.git_ops import GitOps
+from ace.core.context import RepoContext
+from ace.ai.llm_factory import get_llm
+from ace.utils.diff_parser import trim_diff
+from ace.ai.prompts.commit import (
+    CONVENTIONAL_COMMIT_SYSTEM_PROMPT,
+    SIMPLE_COMMIT_SYSTEM_PROMPT,
+    DETAILED_COMMIT_SYSTEM_PROMPT,
+    USER_PROMPT_TEMPLATE,
+)
+
+class NoStagedChangesError(Exception):
+    """Raised when trying to generate a commit message but no changes are staged."""
+    pass
+
+class CommitGenerator:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+        self.context_builder = RepoContext(git_ops)
+
+    def generate_message(self, format_type: str = "conventional", offline: bool = False) -> str:
+        """
+        Analyze staged changes and generate a commit message using the configured AI.
+        """
+        # Ensure we have staged changes
+        status = self.git_ops.get_status()
+        if not status["staged"]:
+            raise NoStagedChangesError("No changes are staged for commit. Stage files first using 'git add'.")
+
+        staged_diff = self.git_ops.get_staged_diff()
+        if not staged_diff.strip():
+            # Sometimes status has staged but diff is empty (e.g. only file permissions or empty files)
+            raise NoStagedChangesError("Staged diff is empty. Cannot generate commit message.")
+
+        # Format context
+        repo_context = self.context_builder.format_context_for_prompt()
+
+        # Select system prompt based on format
+        if format_type == "conventional":
+            system_prompt = CONVENTIONAL_COMMIT_SYSTEM_PROMPT
+        elif format_type == "simple":
+            system_prompt = SIMPLE_COMMIT_SYSTEM_PROMPT
+        elif format_type == "detailed":
+            system_prompt = DETAILED_COMMIT_SYSTEM_PROMPT
+        else:
+            system_prompt = CONVENTIONAL_COMMIT_SYSTEM_PROMPT
+
+        user_prompt = USER_PROMPT_TEMPLATE.format(
+            repo_context=repo_context,
+            staged_diff=trim_diff(staged_diff, max_chars=25000)  # Cap diff to avoid context window limit
+        )
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=user_prompt)
+        ]
+
+        # Get LLM and run inference
+        llm = get_llm(offline_override=offline)
+        response = llm.invoke(messages)
+        
+        # Clean response (remove extra leading/trailing whitespace or markdown fences)
+        message = response.content.strip()
+        if message.startswith("```"):
+            lines = message.splitlines()
+            if lines[0].startswith("```"):
+                lines = lines[1:]
+            if lines and lines[-1].startswith("```"):
+                lines = lines[:-1]
+            message = "\n".join(lines).strip()
+            
+        return message

ace/ai/conflict_resolver.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+from langchain_core.messages import SystemMessage, HumanMessage
+from ace.core.git_ops import GitOps
+from ace.utils.conflict_parser import parse_conflict_file
+from ace.ai.llm_factory import get_llm
+from ace.ai.prompts.conflict import CONFLICT_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+from ace.utils.json_utils import extract_json
+
+class ConflictResolverError(Exception):
+    """Raised when conflict resolution fails."""
+    pass
+
+class ConflictResolver:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+
+    def get_suggestions(self, file_path: str, offline: bool = False) -> List[Dict[str, Any]]:
+        """
+        Scan a file for conflicts and return AI resolution suggestions for each.
+        
+        Returns a list of dicts:
+        [
+            {
+                "full_block": str,
+                "head": str,
+                "incoming": str,
+                "suggested_merged": str,
+                "explanation": str
+            }
+        ]
+        """
+        full_path = Path(self.git_ops.working_dir) / file_path
+        if not full_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        try:
+            content = full_path.read_text(encoding="utf-8")
+        except Exception as e:
+            raise ConflictResolverError(f"Failed to read file {file_path}: {e}")
+
+        blocks = parse_conflict_file(content)
+        if not blocks:
+            return []
+
+        llm = get_llm(offline_override=offline)
+        suggestions = []
+
+        for block in blocks:
+            sys_prompt = CONFLICT_SYSTEM_PROMPT.format(filename=file_path)
+            usr_prompt = USER_PROMPT_TEMPLATE.format(
+                head_content=block["head"],
+                incoming_content=block["incoming"]
+            )
+
+            messages = [
+                SystemMessage(content=sys_prompt),
+                HumanMessage(content=usr_prompt)
+            ]
+
+            try:
+                response = llm.invoke(messages)
+                parsed = extract_json(response.content)
+                
+                suggestions.append({
+                    "full_block": block["full_block"],
+                    "head": block["head"],
+                    "incoming": block["incoming"],
+                    "suggested_merged": parsed.get("merged_content", block["head"]), # Fallback to head
+                    "explanation": parsed.get("explanation", "AI suggested resolution.")
+                })
+            except Exception as e:
+                # Fallback in case of AI failures
+                suggestions.append({
+                    "full_block": block["full_block"],
+                    "head": block["head"],
+                    "incoming": block["incoming"],
+                    "suggested_merged": block["head"], # Keep head as fallback
+                    "explanation": f"AI suggestion failed: {e}. Keeping local branch version as default suggestion."
+                })
+
+        return suggestions
+
+    def apply_resolution(self, file_path: str, block_replacements: List[Tuple[str, str]]) -> None:
+        """
+        Apply resolutions to a conflicted file.
+        
+        block_replacements: List of tuples (full_conflict_block, replacement_content)
+        """
+        full_path = Path(self.git_ops.working_dir) / file_path
+        if not full_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        content = full_path.read_text(encoding="utf-8")
+        
+        for full_block, replacement in block_replacements:
+            if full_block in content:
+                content = content.replace(full_block, replacement)
+            else:
+                # Try with normalized line endings
+                norm_block = full_block.replace("\r\n", "\n")
+                norm_content = content.replace("\r\n", "\n")
+                if norm_block in norm_content:
+                    norm_content = norm_content.replace(norm_block, replacement)
+                    # Restore Windows line endings if they were originally present
+                    if "\r\n" in content:
+                        content = norm_content.replace("\n", "\r\n")
+                    else:
+                        content = norm_content
+                else:
+                    raise ConflictResolverError(
+                        "Conflict block not found in file. Has it been edited already?"
+                    )
+
+        full_path.write_text(content, encoding="utf-8")

ace/ai/gitignore_generator.py

@@ -0,0 +1,45 @@
+import os
+from typing import Dict, Any
+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.ignore import IGNORE_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+from ace.utils.json_utils import extract_json
+
+class GitignoreGenerator:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+
+    def generate_rules(self, query: str, offline: bool = False) -> Dict[str, Any]:
+        """
+        Reads the current .gitignore file (if any), queries the LLM with the user's
+        ignore request, and returns generated rules to append along with an explanation.
+        """
+        gitignore_path = os.path.join(self.git_ops.working_dir, ".gitignore")
+        current_content = ""
+        if os.path.exists(gitignore_path):
+            try:
+                with open(gitignore_path, "r", encoding="utf-8") as f:
+                    current_content = f.read()
+            except Exception:
+                current_content = ""
+
+        llm = get_llm(offline_override=offline)
+        
+        usr_prompt = USER_PROMPT_TEMPLATE.format(
+            query=query,
+            current_gitignore=current_content.strip() or "(empty)"
+        )
+
+        messages = [
+            SystemMessage(content=IGNORE_SYSTEM_PROMPT),
+            HumanMessage(content=usr_prompt)
+        ]
+
+        response = llm.invoke(messages)
+        parsed = extract_json(response.content)
+        
+        if "rules" not in parsed or "explanation" not in parsed:
+            raise Exception("AI response JSON missing 'rules' or 'explanation' keys.")
+            
+        return parsed

ace/ai/history_analyzer.py

@@ -0,0 +1,188 @@
+import collections
+import os
+import datetime
+from typing import Dict, Any
+from langchain_core.messages import SystemMessage, HumanMessage
+from ace.core.git_ops import GitOps
+from ace.ai.llm_factory import get_llm
+
+HISTORY_SUMMARY_SYSTEM_PROMPT = """
+You are "Ace", the AI Git Copilot.
+The user asked a question about the repository's Git history, and we ran a Git command to fetch the raw data.
+Your job is to analyze the raw Git output and summarize it for the user in a beautiful, helpful, and concise format.
+
+User Query: "{query}"
+Git Command Run: "{command}"
+
+Analyze the Git output below and write the response. Use markdown, emojis, lists, or tables where helpful. Keep it concise.
+""".strip()
+
+class HistoryAnalyzer:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+
+    def summarize_query(self, query: str, command: str, command_output: str, offline: bool = False) -> str:
+        """
+        Summarize raw Git command output in response to a user's question.
+        """
+        if not command_output.strip():
+            return "The Git command returned no output, meaning there is no matching history found."
+
+        llm = get_llm(offline_override=offline)
+        
+        sys_prompt = HISTORY_SUMMARY_SYSTEM_PROMPT.format(query=query, command=command)
+        user_prompt = f"Raw Git Output:\n\"\"\"\n{command_output[:20000]}\n\"\"\""
+
+        messages = [
+            SystemMessage(content=sys_prompt),
+            HumanMessage(content=user_prompt)
+        ]
+
+        response = llm.invoke(messages)
+        return response.content.strip()
+
+    def get_repo_stats(self) -> Dict[str, Any]:
+        """
+        Calculate repository statistics:
+        - Total commits
+        - Unique contributors
+        - Most active authors
+        - Recent commit frequency
+        """
+        try:
+            # Get list of all commits (hash|author|date)
+            log_data = self.git_ops.execute("log --format=%H|%an|%ad")
+        except Exception:
+            return {}
+
+        commits = [line.split("|") for line in log_data.splitlines() if "|" in line]
+        if not commits:
+            return {}
+
+        total_commits = len(commits)
+        
+        # Contributors count
+        authors = [c[1] for c in commits]
+        author_counts = collections.Counter(authors)
+        contributors = list(author_counts.items())
+        # Sort contributors by commit count descending
+        contributors.sort(key=lambda x: x[1], reverse=True)
+
+        # Active branches
+        branches = self.git_ops.get_branches()
+
+        # Files changed counts (approximate from diff-tree of recent commits)
+        status = self.git_ops.get_status()
+
+        # Lines of code changes per author
+        try:
+            numstat_data = self.git_ops.execute('log --numstat --format=AUTHOR:%an')
+        except Exception:
+            numstat_data = ""
+        
+        author_lines = {}
+        current_author = None
+        for line in numstat_data.splitlines():
+            line = line.strip().replace('"', '')
+            if not line:
+                continue
+            if line.startswith("AUTHOR:"):
+                current_author = line[7:]
+                if current_author not in author_lines:
+                    author_lines[current_author] = {"added": 0, "deleted": 0}
+            elif current_author:
+                parts = line.split()
+                if len(parts) >= 3:
+                    try:
+                        added = int(parts[0])
+                        deleted = int(parts[1])
+                        author_lines[current_author]["added"] += added
+                        author_lines[current_author]["deleted"] += deleted
+                    except ValueError:
+                        pass
+
+        # File type distribution (extensions)
+        try:
+            files_list = self.git_ops.execute("ls-files")
+        except Exception:
+            files_list = ""
+            
+        extensions = []
+        for f in files_list.splitlines():
+            f = f.strip()
+            if not f:
+                continue
+            _, ext = os.path.splitext(f)
+            if ext:
+                extensions.append(ext.lower())
+            else:
+                extensions.append("(no extension)")
+                
+        extension_counts = collections.Counter(extensions)
+
+        # Commit timeline (last 14 days)
+        try:
+            dates_data = self.git_ops.execute("log --format=%ad --date=short")
+        except Exception:
+            dates_data = ""
+            
+        date_counts = collections.Counter(dates_data.splitlines())
+        today = datetime.date.today()
+        last_14_days = [today - datetime.timedelta(days=i) for i in range(13, -1, -1)]
+        
+        timeline = []
+        for d in last_14_days:
+            date_str = d.isoformat()
+            count = date_counts.get(date_str, 0)
+            timeline.append((date_str, count))
+
+        return {
+            "total_commits": total_commits,
+            "total_branches": len(branches),
+            "contributors": contributors,
+            "staged_count": len(status["staged"]),
+            "unstaged_count": len(status["unstaged"]),
+            "untracked_count": len(status["untracked"]),
+            "lines_per_author": author_lines,
+            "extension_counts": dict(extension_counts.most_common(5)),
+            "timeline": timeline,
+        }
+
+
+    def semantic_search(self, query: str, limit: int = 50, offline: bool = False) -> Dict[str, Any]:
+        """
+        Retrieves the last `limit` commits, sends them to the LLM along with the search query,
+        and returns the semantically matching commits.
+        """
+        commits = self.git_ops.get_log(n=limit)
+        if not commits:
+            return {"matches": []}
+
+        history_lines = []
+        for c in commits:
+            history_lines.append(
+                f"Commit: {c['hexsha']}\nAuthor: {c['author']}\nDate: {c['date']}\nSummary: {c['summary']}\nMessage: {c['message']}\n---"
+            )
+        commit_history_text = "\n".join(history_lines)
+
+        from ace.ai.prompts.search import SEARCH_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+        from ace.utils.json_utils import extract_json
+
+        llm = get_llm(offline_override=offline)
+        
+        if len(commit_history_text) > 25000:
+            commit_history_text = commit_history_text[:25000] + "\n\n... (history truncated due to size) ..."
+
+        usr_prompt = USER_PROMPT_TEMPLATE.format(
+            query=query,
+            commit_history=commit_history_text
+        )
+
+        messages = [
+            SystemMessage(content=SEARCH_SYSTEM_PROMPT),
+            HumanMessage(content=usr_prompt)
+        ]
+
+        response = llm.invoke(messages)
+        return extract_json(response.content)
+

ace/ai/intent_parser.py

@@ -0,0 +1,65 @@
+from typing import Dict, Any
+from langchain_core.messages import SystemMessage, HumanMessage
+from ace.core.git_ops import GitOps
+from ace.core.context import RepoContext
+from ace.ai.llm_factory import get_llm
+from ace.ai.prompts.intent import INTENT_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
+from ace.utils.json_utils import extract_json, JSONExtractError
+
+class IntentParserError(Exception):
+    """Raised when intent parsing fails."""
+    pass
+
+class IntentParser:
+    def __init__(self, git_ops: GitOps):
+        self.git_ops = git_ops
+        self.context_builder = RepoContext(git_ops)
+
+    def parse_intent(self, query: str, offline: bool = False) -> Dict[str, Any]:
+        """
+        Convert a natural language query into structured Git commands.
+        
+        Returns a dict:
+        {
+            "commands": List[str],
+            "explanation": str,
+            "risk_level": "safe" | "moderate" | "destructive",
+            "alternatives": Optional[str]
+        }
+        """
+        # Fetch current context
+        repo_context = self.context_builder.format_context_for_prompt()
+        
+        user_prompt = USER_PROMPT_TEMPLATE.format(
+            repo_context=repo_context,
+            query=query
+        )
+        
+        messages = [
+            SystemMessage(content=INTENT_SYSTEM_PROMPT),
+            HumanMessage(content=user_prompt)
+        ]
+        
+        # Initialize and call LLM
+        llm = get_llm(offline_override=offline)
+        response = llm.invoke(messages)
+        
+        raw_content = response.content.strip()
+        
+        # Parse the output using shared utility
+        try:
+            parsed = extract_json(raw_content)
+        except JSONExtractError as e:
+            raise IntentParserError(str(e))
+        
+        # Validate keys and default types
+        commands = parsed.get("commands", [])
+        if not isinstance(commands, list):
+            commands = [str(commands)] if commands else []
+            
+        return {
+            "commands": [cmd.strip() for cmd in commands],
+            "explanation": str(parsed.get("explanation", "No explanation provided.")),
+            "risk_level": str(parsed.get("risk_level", "safe")).lower(),
+            "alternatives": parsed.get("alternatives", None)
+        }