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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ace-git-copilot
-Version: 0.3.2
+Version: 0.3.3
 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
@@ -198,6 +198,18 @@ Distributed under the MIT License. See [LICENSE](LICENSE) for more details.
 
 ## Changelog
 
+### 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.3}/README.md

@@ -165,6 +165,18 @@ Distributed under the MIT License. See [LICENSE](LICENSE) for more details.
 
 ## Changelog
 
+### 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.3/ace/__init__.py

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

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.3}/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.3}/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.3}/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,

{ace_git_copilot-0.3.2 → ace_git_copilot-0.3.3}/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.3}/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.3}/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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ace-git-copilot"
-version = "0.3.2"
+version = "0.3.3"
 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.3}/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.3/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.3/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.3/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"

ace_git_copilot-0.3.3/tests/test_git_ops_execute.py

@@ -0,0 +1,41 @@
+import pytest
+from unittest.mock import MagicMock
+from ace.core.git_ops import GitOps
+
+def test_git_ops_execute_quoted_args():
+    # Setup mock repo
+    mock_repo = MagicMock()
+    mock_git_func = MagicMock(return_value="commit success")
+    mock_repo.git.commit = mock_git_func
+    
+    git_ops = GitOps.__new__(GitOps)
+    git_ops.repo = mock_repo
+    
+    # Run execute with quotes
+    res = git_ops.execute("commit -m 'hello world'")
+    
+    assert res == "commit success"
+    mock_git_func.assert_called_once_with("-m", "hello world")
+
+def test_git_ops_execute_unknown_command():
+    mock_repo = MagicMock()
+    # Simulate AttributeError when getting direct attribute
+    del mock_repo.git.nonexistent
+    
+    # Mock fallback git.execute
+    mock_execute = MagicMock(return_value="executed custom")
+    mock_repo.git.execute = mock_execute
+    
+    git_ops = GitOps.__new__(GitOps)
+    git_ops.repo = mock_repo
+    
+    res = git_ops.execute("nonexistent -a --foo")
+    assert res == "executed custom"
+    mock_execute.assert_called_once_with(["git", "nonexistent", "-a", "--foo"])
+
+def test_git_ops_execute_empty():
+    git_ops = GitOps.__new__(GitOps)
+    with pytest.raises(ValueError, match="Empty Git command"):
+        git_ops.execute("")
+    with pytest.raises(ValueError, match="Empty Git command"):
+        git_ops.execute("   ")

ace_git_copilot-0.3.3/tests/test_llm_factory_ollama.py

@@ -0,0 +1,48 @@
+import pytest
+import json
+from unittest.mock import patch, MagicMock
+from ace.ai.llm_factory import ensure_ollama_model, _checked_ollama_models
+
+@pytest.fixture(autouse=True)
+def clear_ollama_cache():
+    _checked_ollama_models.clear()
+
+@patch("urllib.request.urlopen")
+@patch("urllib.request.Request")
+def test_ensure_ollama_model_streaming_success(mock_request, mock_urlopen):
+    # First response: GET /api/tags (model list doesn't contain test-model)
+    mock_response_tags = MagicMock()
+    mock_response_tags.__enter__.return_value = mock_response_tags
+    mock_response_tags.read.return_value = b'{"models": []}'
+    
+    # Second response: POST /api/pull (streaming download chunks)
+    mock_response_pull = MagicMock()
+    mock_response_pull.__enter__.return_value = mock_response_pull
+    mock_response_pull.__iter__.return_value = [
+        b'{"status": "pulling manifest"}\n',
+        b'{"status": "downloading digest", "completed": 50, "total": 100}\n',
+        b'{"status": "success"}\n'
+    ]
+    
+    mock_urlopen.side_effect = [mock_response_tags, mock_response_pull]
+    
+    # Mock user input to confirm pulling
+    with patch("ace.ui.prompts.confirm", return_value=True):
+        ensure_ollama_model("http://localhost:11434", "test-model")
+        
+    assert mock_urlopen.call_count == 2
+
+@patch("urllib.request.urlopen")
+@patch("urllib.request.Request")
+def test_ensure_ollama_model_already_exists(mock_request, mock_urlopen):
+    # Model is listed in local models, so no pull should be requested
+    mock_response_tags = MagicMock()
+    mock_response_tags.__enter__.return_value = mock_response_tags
+    mock_response_tags.read.return_value = b'{"models": [{"name": "test-model:latest"}]}'
+    mock_urlopen.return_value = mock_response_tags
+    
+    with patch("ace.ui.prompts.confirm", return_value=True) as mock_confirm:
+        ensure_ollama_model("http://localhost:11434", "test-model")
+        mock_confirm.assert_not_called()
+        
+    assert mock_urlopen.call_count == 1

ace_git_copilot-0.3.2/ace/__init__.py

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