ace-git-copilot 0.1.0__tar.gz

ace_git_copilot-0.1.0/.env.example

@@ -0,0 +1,13 @@
+# Ace AI Git Copilot Environment Variables
+
+# AI Provider: 'nvidia' (default) or 'ollama' (offline)
+ACE_PROVIDER=nvidia
+
+# NVIDIA NIM Configuration
+# Get your free key at https://build.nvidia.com/
+NVIDIA_API_KEY=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
+NVIDIA_MODEL=meta/llama-3.3-70b-instruct
+
+# Ollama Configuration (Fallback/Offline)
+OLLAMA_MODEL=qwen2.5-coder:7b
+OLLAMA_URL=http://localhost:11434

ace_git_copilot-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install .[dev]
+
+    - name: Lint with Ruff
+      run: ruff check
+
+    - name: Run tests with Pytest
+      run: pytest

ace_git_copilot-0.1.0/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+env/
+
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment secrets
+*.env
+.env.local
+
+# Testing / Coverage
+.pytest_cache/
+.coverage
+htmlcov/
+.cov/

ace_git_copilot-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: ace-git-copilot
+Version: 0.1.0
+Summary: AI-powered Git copilot — talk to Git in plain English
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: gitpython>=3.1
+Requires-Dist: langchain-nvidia-ai-endpoints>=0.3
+Requires-Dist: langchain-ollama>=0.3
+Requires-Dist: langchain>=0.3
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: typer[all]>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Ace — AI-Powered Git Copilot
+
+> Ace is an intelligent terminal tool that understands what you want to do with Git and does it for you. Talk to Git in plain English — Ace figures out the right git commands, explains what it's doing, and executes safely.
+
+---
+
+## 🚀 Installation
+
+Install in editable mode globally/user-wide:
+```bash
+python -m pip install --user -e D:\Ace
+```
+
+*Note: Make sure your Python scripts path (e.g., `AppData\Roaming\Python\Python3xx\Scripts`) is added to your Windows PATH environment variable.*
+
+---
+
+## ⚙️ Configuration
+
+Configure your AI provider (NVIDIA NIM or local Ollama) by running:
+```bash
+ace setup
+```
+This will save your preferences to `~/.ace/config.toml`.
+
+---
+
+## 🛠️ Usage & Commands
+
+### 🧠 Natural Language Input
+Run anything you want to do directly:
+```bash
+ace "stage all changes"
+ace "undo my last commit but keep changes"
+ace "create feature branch named login"
+```
+
+### 📋 Command Reference
+
+| Command | Shorthand | Description |
+|---------|-----------|-------------|
+| `ace add <files>` | `ace stage` | Stage files (`git add`) for commit. |
+| `ace commit` | — | Generate a smart Conventional Commit message and commit. |
+| `ace review` | — | AI code review of staged/unstaged changes. |
+| `ace resolve` | — | AI-assisted interactive merge conflict resolution. |
+| `ace changelog` | — | Generate markdown release notes since the last tag. |
+| `ace stats` | — | Enhanced visual repo overview, extension counts, and lines altered. |
+| `ace explain <cmd>` | — | Explain Git commands or concepts in plain English. |
+| `ace undo` | — | Context-aware smart undo (analyzes Git state to safely revert last action). |
+| `ace pr` | — | Generate a markdown Pull Request description comparing branches. |
+| `ace search <query>` | — | Semantic search across repository commits. |
+| `ace ignore <query>` | — | Generate and append rules to `.gitignore`. |
+| `ace dash` | — | Launch the interactive terminal dashboard TUI. |
+| `ace config` | — | View the active configuration settings. |
+
+---
+
+## 📁 Codebase Directory & File Functions
+
+Here is the list of files in the project and what each one does:
+
+### 📍 Core CLI & Setup
+* **`pyproject.toml`**: Configures the project, entry points (`ace = ace.cli:app`), dependencies (`typer`, `rich`, `gitpython`, `langchain`), and build systems.
+* **`ace/cli.py`**: The entrypoint of the Typer application. Defines all CLI commands, parses command line flags, and routes calls.
+
+### ⚙️ Core Modules (`ace/core/`)
+* **`ace/core/config.py`**: Manages reading, writing, and parsing the user's TOML settings file (`config.toml`).
+* **`ace/core/git_ops.py`**: Wraps the GitPython library to perform programmatic Git commands (e.g. status, diff, log, commit, push).
+* **`ace/core/safety.py`**: Classifies Git commands into safety levels (Safe, Moderate, Destructive) and guards against destructive operations.
+* **`ace/core/context.py`**: Collects repository-wide details (branch, diffs, untracked files) to provide context for AI requests.
+
+### 🧠 AI Engine (`ace/ai/`)
+* **`ace/ai/llm_factory.py`**: Instantiates ChatNVIDIA (cloud) or ChatOllama (local) depending on configuration settings.
+* **`ace/ai/intent_parser.py`**: Translates the user's natural language input into Git commands.
+* **`ace/ai/commit_generator.py`**: Analyzes staged diffs and generates Conventional Commit messages.
+* **`ace/ai/code_reviewer.py`**: Analyzes unstaged or staged diffs to locate bugs, style flaws, security issues, and rate code.
+* **`ace/ai/conflict_resolver.py`**: Parses file-level merge conflicts and suggests correct merges.
+* **`ace/ai/changelog_generator.py`**: Collates commit messages and formats release logs.
+* **`ace/ai/history_analyzer.py`**: Runs semantic searches across log files and computes repository overview metrics.
+* **`ace/ai/pr_drafter.py`**: Drafts Pull Request titles and bodies comparing branch changes.
+* **`ace/ai/gitignore_generator.py`**: Generates `.gitignore` syntax templates.
+* **`ace/ai/prompts/`**: Houses all prompt templates for the LLMs (intent, commit, review, conflict, explain, undo, pr, search, ignore).
+
+### 🎨 User Interface (`ace/ui/`)
+* **`ace/ui/display.py`**: Directs Rich panel printouts, warning/error panels, and load spinners.
+* **`ace/ui/themes.py`**: Houses colors, styling, and markdown rules.
+* **`ace/ui/prompts.py`**: Handles keyboard selection options (e.g., commit/review prompts).
+* **`ace/ui/dashboard.py`**: Implements the interactive terminal dashboard (TUI) showing branch states and command routing menus.
+
+### 🔧 Utilities (`ace/utils/`)
+* **`ace/utils/json_utils.py`**: Extracts and parses clean JSON structures from Markdown code blocks.
+* **`ace/utils/diff_parser.py`**: Splits unified diff files into per-file chunks.
+* **`ace/utils/conflict_parser.py`**: Parses git conflict blocks inside file lines.

ace_git_copilot-0.1.0/README.md

@@ -0,0 +1,93 @@
+# Ace — AI-Powered Git Copilot
+
+> Ace is an intelligent terminal tool that understands what you want to do with Git and does it for you. Talk to Git in plain English — Ace figures out the right git commands, explains what it's doing, and executes safely.
+
+---
+
+## 🚀 Installation
+
+Install in editable mode globally/user-wide:
+```bash
+python -m pip install --user -e D:\Ace
+```
+
+*Note: Make sure your Python scripts path (e.g., `AppData\Roaming\Python\Python3xx\Scripts`) is added to your Windows PATH environment variable.*
+
+---
+
+## ⚙️ Configuration
+
+Configure your AI provider (NVIDIA NIM or local Ollama) by running:
+```bash
+ace setup
+```
+This will save your preferences to `~/.ace/config.toml`.
+
+---
+
+## 🛠️ Usage & Commands
+
+### 🧠 Natural Language Input
+Run anything you want to do directly:
+```bash
+ace "stage all changes"
+ace "undo my last commit but keep changes"
+ace "create feature branch named login"
+```
+
+### 📋 Command Reference
+
+| Command | Shorthand | Description |
+|---------|-----------|-------------|
+| `ace add <files>` | `ace stage` | Stage files (`git add`) for commit. |
+| `ace commit` | — | Generate a smart Conventional Commit message and commit. |
+| `ace review` | — | AI code review of staged/unstaged changes. |
+| `ace resolve` | — | AI-assisted interactive merge conflict resolution. |
+| `ace changelog` | — | Generate markdown release notes since the last tag. |
+| `ace stats` | — | Enhanced visual repo overview, extension counts, and lines altered. |
+| `ace explain <cmd>` | — | Explain Git commands or concepts in plain English. |
+| `ace undo` | — | Context-aware smart undo (analyzes Git state to safely revert last action). |
+| `ace pr` | — | Generate a markdown Pull Request description comparing branches. |
+| `ace search <query>` | — | Semantic search across repository commits. |
+| `ace ignore <query>` | — | Generate and append rules to `.gitignore`. |
+| `ace dash` | — | Launch the interactive terminal dashboard TUI. |
+| `ace config` | — | View the active configuration settings. |
+
+---
+
+## 📁 Codebase Directory & File Functions
+
+Here is the list of files in the project and what each one does:
+
+### 📍 Core CLI & Setup
+* **`pyproject.toml`**: Configures the project, entry points (`ace = ace.cli:app`), dependencies (`typer`, `rich`, `gitpython`, `langchain`), and build systems.
+* **`ace/cli.py`**: The entrypoint of the Typer application. Defines all CLI commands, parses command line flags, and routes calls.
+
+### ⚙️ Core Modules (`ace/core/`)
+* **`ace/core/config.py`**: Manages reading, writing, and parsing the user's TOML settings file (`config.toml`).
+* **`ace/core/git_ops.py`**: Wraps the GitPython library to perform programmatic Git commands (e.g. status, diff, log, commit, push).
+* **`ace/core/safety.py`**: Classifies Git commands into safety levels (Safe, Moderate, Destructive) and guards against destructive operations.
+* **`ace/core/context.py`**: Collects repository-wide details (branch, diffs, untracked files) to provide context for AI requests.
+
+### 🧠 AI Engine (`ace/ai/`)
+* **`ace/ai/llm_factory.py`**: Instantiates ChatNVIDIA (cloud) or ChatOllama (local) depending on configuration settings.
+* **`ace/ai/intent_parser.py`**: Translates the user's natural language input into Git commands.
+* **`ace/ai/commit_generator.py`**: Analyzes staged diffs and generates Conventional Commit messages.
+* **`ace/ai/code_reviewer.py`**: Analyzes unstaged or staged diffs to locate bugs, style flaws, security issues, and rate code.
+* **`ace/ai/conflict_resolver.py`**: Parses file-level merge conflicts and suggests correct merges.
+* **`ace/ai/changelog_generator.py`**: Collates commit messages and formats release logs.
+* **`ace/ai/history_analyzer.py`**: Runs semantic searches across log files and computes repository overview metrics.
+* **`ace/ai/pr_drafter.py`**: Drafts Pull Request titles and bodies comparing branch changes.
+* **`ace/ai/gitignore_generator.py`**: Generates `.gitignore` syntax templates.
+* **`ace/ai/prompts/`**: Houses all prompt templates for the LLMs (intent, commit, review, conflict, explain, undo, pr, search, ignore).
+
+### 🎨 User Interface (`ace/ui/`)
+* **`ace/ui/display.py`**: Directs Rich panel printouts, warning/error panels, and load spinners.
+* **`ace/ui/themes.py`**: Houses colors, styling, and markdown rules.
+* **`ace/ui/prompts.py`**: Handles keyboard selection options (e.g., commit/review prompts).
+* **`ace/ui/dashboard.py`**: Implements the interactive terminal dashboard (TUI) showing branch states and command routing menus.
+
+### 🔧 Utilities (`ace/utils/`)
+* **`ace/utils/json_utils.py`**: Extracts and parses clean JSON structures from Markdown code blocks.
+* **`ace/utils/diff_parser.py`**: Splits unified diff files into per-file chunks.
+* **`ace/utils/conflict_parser.py`**: Parses git conflict blocks inside file lines.

ace_git_copilot-0.1.0/ace/__init__.py

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

ace_git_copilot-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_git_copilot-0.1.0/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_git_copilot-0.1.0/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_git_copilot-0.1.0/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")