ace-git-copilot 0.3.2__tar.gz → 0.3.4__tar.gz

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ace-git-copilot
-Version: 0.3.2
+Version: 0.3.4
 Summary: AI-powered Git copilot — talk to Git in plain English
 Project-URL: Homepage, https://github.com/jachinsamuel/Ace
 Project-URL: Documentation, https://github.com/jachinsamuel/Ace#readme
@@ -170,6 +170,7 @@ Ace has dedicated subcommands for specific tasks. Here is the complete command l
 | `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 workspace` | `ace ws` | Monitor status of multiple repositories and navigate between them. |
 | `ace dash` | — | Launch the interactive repository management console (TUI). |
 | `ace config` | — | Print out active configuration settings. |
 | `ace help` | — | Show user guide and help information on how to use Ace. |
@@ -198,6 +199,23 @@ Distributed under the MIT License. See [LICENSE](LICENSE) for more details.
 
 ## Changelog
 
+### v0.3.4 — Workspace Management (2026-07-11)
+*   Added new `workspace` command (alias `ws`) to scan, monitor, and navigate multiple repositories.
+*   Shows active branch, staged/unstaged/untracked file counts, and local upstream sync offsets in a Rich Table.
+*   Supports interactive actions to open the TUI dashboard, spawn a nested shell, or run copy-paste commands inside any chosen repository.
+
+### v0.3.3 — Stability & Resilience (2026-07-04)
+*   Implemented streaming progress and download percentages for Ollama model pulls to prevent thread hangs.
+*   Added atomic file saves and rollback backups for merge conflict resolutions and config modifications to prevent data corruption.
+*   Fixed merge/rebase detection in git worktrees and submodules by resolving the authoritative `git_dir` dynamically.
+*   Added `shlex` command splitting to safely parse and execute quoted arguments in Git commands.
+*   Created python module entry point (`python -m ace`) for nested execution support.
+
+### v0.3.2 — Windows Compatibility & E2E Fixes (2026-07-01)
+*   Resolved Windows-specific UTF-8 encoding issues in E2E tests and log parsers.
+*   Fixed subprocess natural language command execution paths to execute nested ace commands through Python interpreter contexts.
+*   Refactored CLI error panel formatting to match expected exception names.
+
 ### v0.3.1 — Patch (2026-06-30)
 *   Fixed invisible key labels (`[c]`, `[r]`, etc.) in the dashboard and search menus caused by Rich markup tag conflicts.
 *   Fixed `[Y/n]` confirmation prompt rendering invisibly.

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/README.md

@@ -137,6 +137,7 @@ Ace has dedicated subcommands for specific tasks. Here is the complete command l
 | `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 workspace` | `ace ws` | Monitor status of multiple repositories and navigate between them. |
 | `ace dash` | — | Launch the interactive repository management console (TUI). |
 | `ace config` | — | Print out active configuration settings. |
 | `ace help` | — | Show user guide and help information on how to use Ace. |
@@ -165,6 +166,23 @@ Distributed under the MIT License. See [LICENSE](LICENSE) for more details.
 
 ## Changelog
 
+### v0.3.4 — Workspace Management (2026-07-11)
+*   Added new `workspace` command (alias `ws`) to scan, monitor, and navigate multiple repositories.
+*   Shows active branch, staged/unstaged/untracked file counts, and local upstream sync offsets in a Rich Table.
+*   Supports interactive actions to open the TUI dashboard, spawn a nested shell, or run copy-paste commands inside any chosen repository.
+
+### v0.3.3 — Stability & Resilience (2026-07-04)
+*   Implemented streaming progress and download percentages for Ollama model pulls to prevent thread hangs.
+*   Added atomic file saves and rollback backups for merge conflict resolutions and config modifications to prevent data corruption.
+*   Fixed merge/rebase detection in git worktrees and submodules by resolving the authoritative `git_dir` dynamically.
+*   Added `shlex` command splitting to safely parse and execute quoted arguments in Git commands.
+*   Created python module entry point (`python -m ace`) for nested execution support.
+
+### v0.3.2 — Windows Compatibility & E2E Fixes (2026-07-01)
+*   Resolved Windows-specific UTF-8 encoding issues in E2E tests and log parsers.
+*   Fixed subprocess natural language command execution paths to execute nested ace commands through Python interpreter contexts.
+*   Refactored CLI error panel formatting to match expected exception names.
+
 ### v0.3.1 — Patch (2026-06-30)
 *   Fixed invisible key labels (`[c]`, `[r]`, etc.) in the dashboard and search menus caused by Rich markup tag conflicts.
 *   Fixed `[Y/n]` confirmation prompt rendering invisibly.

ace_git_copilot-0.3.4/ace/__init__.py

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

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/ace/ai/conflict_resolver.py

@@ -83,10 +83,15 @@ class ConflictResolver:
 
     def apply_resolution(self, file_path: str, block_replacements: List[Tuple[str, str]]) -> None:
         """
-        Apply resolutions to a conflicted file.
+        Apply resolutions to a conflicted file safely.
         
         block_replacements: List of tuples (full_conflict_block, replacement_content)
         """
+        import shutil
+        import tempfile
+        import os
+        import time
+
         full_path = Path(self.git_ops.working_dir) / file_path
         if not full_path.exists():
             raise FileNotFoundError(f"File not found: {file_path}")
@@ -95,13 +100,13 @@ class ConflictResolver:
         
         for full_block, replacement in block_replacements:
             if full_block in content:
-                content = content.replace(full_block, replacement)
+                content = content.replace(full_block, replacement, 1)
             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)
+                    norm_content = norm_content.replace(norm_block, replacement, 1)
                     # Restore Windows line endings if they were originally present
                     if "\r\n" in content:
                         content = norm_content.replace("\n", "\r\n")
@@ -112,4 +117,30 @@ class ConflictResolver:
                         "Conflict block not found in file. Has it been edited already?"
                     )
 
-        full_path.write_text(content, encoding="utf-8")
+        # Create backup copy
+        backup_path = full_path.with_suffix(full_path.suffix + f".bak-{int(time.time())}")
+        try:
+            shutil.copy2(full_path, backup_path)
+        except Exception as e:
+            raise ConflictResolverError(f"Failed to create backup copy of {file_path}: {e}")
+
+        # Atomic replacement
+        try:
+            fd, temp_path_str = tempfile.mkstemp(dir=full_path.parent, prefix="resolved-", suffix=".tmp")
+            temp_path = Path(temp_path_str)
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                f.write(content)
+            os.replace(temp_path, full_path)
+        except Exception as e:
+            # Restore from backup
+            try:
+                shutil.copy2(backup_path, full_path)
+            except Exception:
+                pass
+            raise ConflictResolverError(f"Failed to apply conflict resolution to {file_path}: {e}")
+        finally:
+            if backup_path.exists():
+                try:
+                    backup_path.unlink()
+                except Exception:
+                    pass

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/ace/ai/llm_factory.py

@@ -51,17 +51,35 @@ def ensure_ollama_model(base_url: str, model_name: str) -> None:
     if confirm(f"Would you like Ace to automatically pull '{model_name}' from the Ollama registry?", default=True):
         try:
             url = f"{base_url.rstrip('/')}/api/pull"
-            payload = json.dumps({"name": model_name, "stream": False}).encode("utf-8")
+            payload = json.dumps({"name": model_name, "stream": True}).encode("utf-8")
             req = urllib.request.Request(url, data=payload, method="POST")
             req.add_header("Content-Type", "application/json")
             
-            with spinner(f"Downloading model '{model_name}' (this may take a few minutes)..."):
-                with urllib.request.urlopen(req) as response:
-                    res_data = json.loads(response.read().decode("utf-8"))
-                    if res_data.get("status") == "success" or "success" in str(res_data):
-                        print_success(f"Successfully downloaded '{model_name}'!\n")
-                    else:
-                        print_info(f"Ollama response: {res_data}\n")
+            with spinner(f"Initiating download of model '{model_name}'..."):
+                pass
+            
+            with urllib.request.urlopen(req, timeout=60) as response:
+                import sys
+                for line in response:
+                    if not line.strip():
+                        continue
+                    try:
+                        data = json.loads(line.decode("utf-8"))
+                        status = data.get("status", "")
+                        completed = data.get("completed", 0)
+                        total = data.get("total", 0)
+                        if total > 0:
+                            pct = (completed / total) * 100
+                            sys.stdout.write(f"\r\033[K[Ollama] {status} ({pct:.1f}%)")
+                            sys.stdout.flush()
+                        else:
+                            sys.stdout.write(f"\r\033[K[Ollama] {status}")
+                            sys.stdout.flush()
+                    except Exception:
+                        pass
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            print_success(f"Successfully downloaded '{model_name}'!\n")
         except Exception as e:
             print_error(f"Failed to pull model: {e}")
             print_info(f"Please run 'ollama pull {model_name}' manually in your shell.\n")

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/ace/cli.py

@@ -193,9 +193,10 @@ def main(
                 try:
                     import subprocess
                     import sys
-                    args = cmd.split()[1:]
+                    import shlex
+                    args = shlex.split(cmd)[1:]
                     res_proc = subprocess.run(
-                        [sys.executable, "-c", "from ace.cli import app; app()"] + args,
+                        [sys.executable, "-m", "ace"] + args,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         text=True,
@@ -1685,6 +1686,195 @@ def hook_cmd(
         show_error_panel("Invalid action. Use 'install' or 'uninstall'.", "Usage Error")
         raise typer.Exit(code=1)
 
+@app.command(name="workspace", help="Monitor status of multiple repositories and navigate between them.")
+def workspace_cmd(
+    path: Optional[str] = typer.Argument(
+        None, help="Custom directory to scan (defaults to sibling projects scan)"
+    ),
+):
+    from pathlib import Path
+    import os
+    import sys
+    import subprocess
+    from rich.table import Table
+    from ace.core.git_ops import GitOps, NotAGitRepositoryError
+    from ace.ui.display import console, print_info, print_success, print_warning, print_error
+    from ace.ui.prompts import prompt_select, prompt_action
+
+    # 1. Determine target directory to scan
+    if path:
+        scan_dir = Path(path).resolve()
+    else:
+        # Smart default
+        cwd = Path(os.getcwd()).resolve()
+        if (cwd / ".git").exists():
+            scan_dir = cwd.parent
+        else:
+            scan_dir = cwd
+
+    if not scan_dir.exists() or not scan_dir.is_dir():
+        print_error(f"Directory not found: {scan_dir}")
+        raise typer.Exit(code=1)
+
+    print_info(f"Scanning workspace directory: [bold]{scan_dir}[/bold]")
+
+    # 2. Find git repositories
+    repos_found = []
+    try:
+        for child in sorted(scan_dir.iterdir()):
+            if not child.is_dir():
+                continue
+            # Basic validation that it's a git repo
+            if (child / ".git").exists() or (child / "gitdir").exists() or child.name.endswith(".git"):
+                try:
+                    git_ops = GitOps(str(child))
+                    repos_found.append((child, git_ops))
+                except Exception:
+                    pass
+    except Exception as e:
+        print_error(f"Failed to scan directory: {e}")
+        raise typer.Exit(code=1)
+
+    if not repos_found:
+        print_warning(f"No active Git repositories found in: {scan_dir}")
+        return
+
+    # 3. Build Status Table
+    table = Table(
+        title=f"[bold white]Workspace Summary: {scan_dir.name}[/bold white]",
+        title_style="bold",
+        border_style="#FF6D00",
+        expand=True,
+    )
+    table.add_column("[bold #00D5FF]#[/bold #00D5FF]", justify="right", width=4)
+    table.add_column("Repository", style="bold white")
+    table.add_column("Branch", style="bold cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Sync", justify="center")
+
+    display_options = []
+    for idx, (repo_path, git_ops) in enumerate(repos_found, 1):
+        repo_name = repo_path.name
+        
+        # Branch
+        branch_name = git_ops.get_current_branch() or "Detached HEAD"
+        
+        # Status counts
+        status = git_ops.get_status()
+        staged = len(status.get("staged", []))
+        unstaged = len(status.get("unstaged", []))
+        untracked = len(status.get("untracked", []))
+        
+        if staged == 0 and unstaged == 0 and untracked == 0:
+            status_desc = "[success]Clean[/success]"
+        else:
+            parts = []
+            if staged > 0:
+                parts.append(f"[bold #00E676]+{staged}[/bold #00E676]")
+            if unstaged > 0:
+                parts.append(f"[bold #FFD600]~{unstaged}[/bold #FFD600]")
+            if untracked > 0:
+                parts.append(f"[bold #FF1744]?{untracked}[/bold #FF1744]")
+            status_desc = " ".join(parts)
+
+        # Sync offsets
+        ab = git_ops.get_ahead_behind()
+        ahead = ab.get("ahead", 0)
+        behind = ab.get("behind", 0)
+        tracking = git_ops.get_upstream_tracking()
+        
+        if not tracking:
+            sync_desc = "[#666666]No Upstream[/#666666]"
+        elif ahead == 0 and behind == 0:
+            sync_desc = "[success]Up-to-date[/success]"
+        elif ahead > 0 and behind == 0:
+            sync_desc = f"[bold #00D5FF]Ahead {ahead}[/bold #00D5FF]"
+        elif behind > 0 and ahead == 0:
+            sync_desc = f"[bold #FFD600]Behind {behind}[/bold #FFD600]"
+        else:
+            sync_desc = f"[bold #FF1744]Diverged (A{ahead}, B{behind})[/bold #FF1744]"
+
+        table.add_row(
+            str(idx),
+            repo_name,
+            branch_name,
+            status_desc,
+            sync_desc
+        )
+        display_options.append(repo_name)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+    # 4. Prompt selection
+    selected_idx = prompt_select(
+        display_options,
+        prompt_text="  Select repository number to manage (or 'q' to quit)",
+        default="q"
+    )
+    
+    if selected_idx < 0:
+        print_info("Exit workspace monitor.")
+        return
+
+    selected_path, _ = repos_found[selected_idx]
+
+    # 5. Prompt action choice
+    console.print(f"\n[bold white]  Choose action for [bold cyan]{selected_path.name}[/bold cyan]:[/bold white]")
+    action_options = {
+        "d": ("Dashboard", "Open interactive TUI dashboard"),
+        "s": ("Shell", "Spawn an interactive shell in project directory"),
+        "c": ("Command", "Execute an ace natural-language command"),
+        "q": ("Quit", "Cancel action and exit")
+    }
+    
+    action = prompt_action(action_options, default_key="d")
+    
+    if action == "d":
+        print_success(f"Launching dashboard in {selected_path.name}...")
+        console.print()
+        try:
+            subprocess.run([sys.executable, "-m", "ace", "dash"], cwd=str(selected_path))
+        except Exception as e:
+            print_error(f"Failed to launch dashboard: {e}")
+            
+    elif action == "s":
+        shell = os.environ.get("SHELL")
+        if not shell:
+            if sys.platform == "win32":
+                shell = "powershell.exe"
+            else:
+                shell = "/bin/bash"
+                
+        print_success(f"Opening interactive shell in {selected_path.name}...")
+        print_info("Type 'exit' to return to Ace workspace monitor.")
+        console.print()
+        
+        try:
+            subprocess.run([shell], cwd=str(selected_path))
+            print_success("Returned to Ace workspace.")
+        except Exception as e:
+            print_error(f"Failed to open shell: {e}")
+            
+    elif action == "c":
+        query = typer.prompt("  Enter command for this repo")
+        if query.strip():
+            print_success(f"Running command: {query}")
+            console.print()
+            try:
+                subprocess.run([sys.executable, "-m", "ace", query], cwd=str(selected_path))
+            except Exception as e:
+                print_error(f"Failed to run command: {e}")
+
+@app.command(name="ws", help="Alias for 'workspace' command.")
+def ws_cmd(
+    path: Optional[str] = typer.Argument(
+        None, help="Custom directory to scan"
+    ),
+):
+    workspace_cmd(path)
+
 if __name__ == "__main__":
     app()
 

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/ace/core/config.py

@@ -154,10 +154,19 @@ def get_config() -> Config:
     return Config(data)
 
 def save_config(config: Config) -> None:
-    """Save the current configuration back to ~/.ace/config.toml."""
+    """Save the current configuration back to ~/.ace/config.toml atomically."""
+    import tempfile
+    import os
     try:
         DEFAULT_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-        with open(DEFAULT_CONFIG_PATH, "w", encoding="utf-8") as f:
-            toml.dump(config.to_dict(), f)
+        fd, temp_path = tempfile.mkstemp(dir=DEFAULT_CONFIG_DIR, prefix="config-", suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                toml.dump(config.to_dict(), f)
+            os.replace(temp_path, DEFAULT_CONFIG_PATH)
+        except Exception as e:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+            raise e
     except Exception as e:
         raise IOError(f"Could not save configuration: {e}")

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/ace/core/context.py

@@ -61,7 +61,11 @@ class RepoContext:
 
     def check_merge_rebase_state(self) -> Dict[str, Any]:
         """Check if the repository is currently in a merge, rebase, or cherry-pick state."""
-        git_dir = Path(self.git_ops.working_dir) / ".git"
+        try:
+            git_dir = Path(self.git_ops.repo.git_dir)
+        except Exception:
+            git_dir = Path(self.git_ops.working_dir) / ".git"
+            
         state = {
             "in_progress": False,
             "type": None,  # 'merge', 'rebase', 'cherry-pick', 'revert'

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/ace/core/git_ops.py

@@ -118,7 +118,13 @@ class GitOps:
     def get_branches(self, remote: bool = False) -> List[str]:
         """List local or remote branches."""
         if remote:
-            return [b.name for b in self.repo.remotes.origin.refs] if "origin" in self.repo.remotes else []
+            branches = []
+            for r in self.repo.remotes:
+                try:
+                    branches.extend([b.name for b in r.refs])
+                except Exception:
+                    pass
+            return branches
         return [b.name for b in self.repo.branches]
 
     def get_conflicts(self) -> List[str]:
@@ -153,14 +159,34 @@ class GitOps:
 
     def execute(self, command: str) -> str:
         """Run an arbitrary git command safely (the command string shouldn't include 'git ')."""
-        # Split command into parts
-        parts = command.strip().split()
+        import shlex
+        if not command.strip():
+            raise ValueError("Empty Git command provided.")
+            
+        try:
+            parts = shlex.split(command.strip())
+        except ValueError:
+            parts = command.strip().split()
+
         if parts and parts[0] == "git":
             parts = parts[1:]
-        
-        # Use git command runner directly
-        git_func = getattr(self.repo.git, parts[0].replace("-", "_"))
-        return git_func(*parts[1:])
+            
+        if not parts:
+            raise ValueError("Empty Git command provided.")
+
+        subcommand = parts[0]
+        args = parts[1:]
+
+        try:
+            git_func = getattr(self.repo.git, subcommand.replace("-", "_"))
+            return git_func(*args)
+        except AttributeError:
+            try:
+                return self.repo.git.execute(["git", subcommand] + args)
+            except Exception as e:
+                raise ValueError(f"Failed to execute Git command '{command}': {e}")
+        except Exception as e:
+            raise ValueError(f"Failed to execute Git command '{command}': {e}")
 
     def get_upstream_tracking(self) -> Optional[str]:
         """Get the remote tracking branch of the current branch, e.g. 'origin/main'."""

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ace-git-copilot"
-version = "0.3.2"
+version = "0.3.4"
 description = "AI-powered Git copilot — talk to Git in plain English"
 readme = "README.md"
 requires-python = ">=3.11"

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.4}/tests/e2e/test_tier2_boundaries.py

@@ -379,6 +379,13 @@ def test_undo_nothing_to_undo(git_workspace):
     assert "Nothing to undo" in res.stdout
 
 def test_undo_destructive_confirm_no(git_workspace):
+    # Setup commit and ORIG_HEAD to trigger high risk undo
+    test_file = git_workspace.workspace / "test.txt"
+    test_file.write_text("initial")
+    git_workspace.repo.index.add([str(test_file)])
+    git_workspace.repo.index.commit("initial commit")
+    git_workspace.repo.git.update_ref("ORIG_HEAD", "HEAD")
+
     # Mock server triggers destructive plan
     res = git_workspace.run(["undo"], stdin_data="n\n")
     assert res.returncode == 0

ace_git_copilot-0.3.4/tests/test_config_atomic_write.py

@@ -0,0 +1,41 @@
+import pytest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+from ace.core.config import save_config, Config
+
+@patch("ace.core.config.DEFAULT_CONFIG_DIR")
+@patch("ace.core.config.DEFAULT_CONFIG_PATH")
+def test_save_config_atomic(mock_config_path, mock_config_dir, tmp_path):
+    # Setup tmp directory for config file
+    config_dir = tmp_path / ".ace"
+    config_dir.mkdir()
+    config_file = config_dir / "config.toml"
+    
+    mock_config_dir.mkdir = MagicMock()
+    mock_config_dir.__truediv__ = MagicMock(return_value=config_file)
+    # Configure path patch
+    mock_config_path.open = config_file.open
+    mock_config_path.parent = config_dir
+    mock_config_path.exists = config_file.exists
+    
+    # We patch DEFAULT_CONFIG_DIR and DEFAULT_CONFIG_PATH directly inside the function
+    with patch("ace.core.config.DEFAULT_CONFIG_DIR", config_dir), \
+         patch("ace.core.config.DEFAULT_CONFIG_PATH", config_file):
+        
+        cfg = Config({
+            "ai": {
+                "provider": "openai",
+                "openai_model": "gpt-4o-mini"
+            }
+        })
+        
+        save_config(cfg)
+        
+        # Verify content was written
+        assert config_file.exists()
+        content = config_file.read_text(encoding="utf-8")
+        assert "provider = \"openai\"" in content
+        
+        # Verify no temp files are left in the directory
+        temp_files = list(config_dir.glob("config-*.tmp"))
+        assert len(temp_files) == 0

ace_git_copilot-0.3.4/tests/test_conflict_resolver_backup.py

@@ -0,0 +1,49 @@
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock
+from ace.ai.conflict_resolver import ConflictResolver, ConflictResolverError
+
+def test_apply_resolution_creates_backup_and_atomic_swap(tmp_path):
+    # Setup mock git_ops working dir
+    mock_git_ops = MagicMock()
+    mock_git_ops.working_dir = str(tmp_path)
+    
+    # Create a test conflicted file
+    test_file = tmp_path / "conflict.txt"
+    test_content = "<<<<<<< HEAD\nlocal changes\n=======\nincoming changes\n>>>>>>> branch\n"
+    test_file.write_text(test_content, encoding="utf-8")
+    
+    resolver = ConflictResolver(mock_git_ops)
+    
+    # Replacement block
+    block = "<<<<<<< HEAD\nlocal changes\n=======\nincoming changes\n>>>>>>> branch"
+    replacement = "resolved changes"
+    
+    # Run resolution
+    resolver.apply_resolution("conflict.txt", [(block, replacement)])
+    
+    # Assert resolution succeeded
+    assert test_file.read_text(encoding="utf-8") == "resolved changes\n"
+    
+    # Assert backup file was cleaned up (no extra .bak files remain)
+    bak_files = list(tmp_path.glob("conflict.txt.bak-*"))
+    assert len(bak_files) == 0
+
+def test_apply_resolution_fails_and_restores(tmp_path):
+    mock_git_ops = MagicMock()
+    mock_git_ops.working_dir = str(tmp_path)
+    
+    test_file = tmp_path / "conflict.txt"
+    test_content = "<<<<<<< HEAD\noriginal content\n>>>>>>> branch"
+    test_file.write_text(test_content, encoding="utf-8")
+    
+    resolver = ConflictResolver(mock_git_ops)
+    
+    # Block that doesn't exist to force failure
+    non_existent_block = "no match"
+    
+    with pytest.raises(ConflictResolverError, match="Conflict block not found"):
+        resolver.apply_resolution("conflict.txt", [(non_existent_block, "bad replacement")])
+        
+    # Assert original content was preserved/restored
+    assert test_file.read_text(encoding="utf-8") == test_content

ace_git_copilot-0.3.4/tests/test_context_gitdir_detection.py

@@ -0,0 +1,45 @@
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock
+from ace.core.context import RepoContext
+
+def test_check_merge_rebase_state_with_git_dir_resolution(tmp_path):
+    # Create mock git_dir (which in real git might be inside worktrees/submodules)
+    mock_git_dir = tmp_path / "worktree_gitdir"
+    mock_git_dir.mkdir()
+    
+    # Simulate a merge in progress
+    merge_head = mock_git_dir / "MERGE_HEAD"
+    merge_head.write_text("commit123", encoding="utf-8")
+    
+    # Setup mock git_ops and repo
+    mock_git_ops = MagicMock()
+    mock_git_ops.repo.git_dir = str(mock_git_dir)
+    mock_git_ops.working_dir = str(tmp_path)
+    
+    context_builder = RepoContext(mock_git_ops)
+    state = context_builder.check_merge_rebase_state()
+    
+    assert state["in_progress"] is True
+    assert state["type"] == "merge"
+    assert "Merge conflict" in state["detail"]
+
+def test_check_merge_rebase_state_fallback(tmp_path):
+    # Setup mock git_ops that raises error when accessing git_dir
+    mock_git_ops = MagicMock()
+    # Delete git_dir attribute to force AttributeError on access
+    del mock_git_ops.repo.git_dir
+    mock_git_ops.working_dir = str(tmp_path)
+    
+    # Setup local fallback .git directory
+    fallback_git = tmp_path / ".git"
+    fallback_git.mkdir()
+    
+    rebase_apply = fallback_git / "rebase-apply"
+    rebase_apply.mkdir()
+    
+    context_builder = RepoContext(mock_git_ops)
+    state = context_builder.check_merge_rebase_state()
+    
+    assert state["in_progress"] is True
+    assert state["type"] == "rebase"