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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ace-git-copilot
-Version: 0.3.1
+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.1 → 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.1 → ace_git_copilot-0.3.3}/ace/ai/changelog_generator.py

@@ -18,6 +18,24 @@ class ChangelogGenerator:
         If from_ref is None, attempts to find the latest tag.
         If no latest tag exists, falls back to the last 30 commits.
         """
+        if from_ref:
+            try:
+                self.git_ops.execute(f"rev-parse --verify {from_ref}")
+            except Exception:
+                raise ChangelogGeneratorError(f"Invalid starting revision: {from_ref}")
+
+        if to_ref:
+            try:
+                self.git_ops.execute(f"rev-parse --verify {to_ref}")
+            except Exception:
+                raise ChangelogGeneratorError(f"Invalid ending revision: {to_ref}")
+
+        # Check if HEAD exists first
+        try:
+            self.git_ops.execute("rev-parse --verify HEAD")
+        except Exception:
+            return ""
+
         to_revision = to_ref or "HEAD"
         from_revision = from_ref
         

{ace_git_copilot-0.3.1 → ace_git_copilot-0.3.3}/ace/ai/commit_generator.py

@@ -29,8 +29,13 @@ class CommitGenerator:
             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)
+        has_content_changes = False
+        for line in staged_diff.splitlines():
+            if (line.startswith("+") and not line.startswith("+++")) or (line.startswith("-") and not line.startswith("---")):
+                has_content_changes = True
+                break
+
+        if not has_content_changes:
             raise NoStagedChangesError("Staged diff is empty. Cannot generate commit message.")
 
         # Format context

{ace_git_copilot-0.3.1 → 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.1 → ace_git_copilot-0.3.3}/ace/ai/llm_factory.py

@@ -43,27 +43,46 @@ def ensure_ollama_model(base_url: str, model_name: str) -> None:
         return
 
     # 2. Prompt user and pull model
-    from ace.ui.display import console, spinner
+    from ace.ui.display import console, spinner, print_warning, print_success, print_error, print_info
     from ace.ui.prompts import confirm
     
-    console.print(f"\n[warning]⚠️  Ollama model [bold]{model_name}[/bold] is not downloaded locally.[/warning]")
+    console.print()
+    print_warning(f"Ollama model '{model_name}' is not downloaded locally.")
     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):
-                        console.print(f"[success]✅ Successfully downloaded '{model_name}'![/success]\n")
-                    else:
-                        console.print(f"[info]Ollama response: {res_data}[/info]\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:
-            console.print(f"[error]❌ Failed to pull model: {e}[/error]")
-            console.print(f"[info]Please run 'ollama pull {model_name}' manually in your shell.[/info]\n")
+            print_error(f"Failed to pull model: {e}")
+            print_info(f"Please run 'ollama pull {model_name}' manually in your shell.\n")
 
 def get_llm(offline_override: bool = False) -> BaseChatModel:
     """

{ace_git_copilot-0.3.1 → ace_git_copilot-0.3.3}/ace/cli.py

@@ -138,9 +138,9 @@ def main(
         r_level, r_desc, alt = SafetyChecker.analyze_command(cmd)
         if r_level == "destructive":
             highest_risk = "destructive"
-            risk_details.append(f"[bold red]Command:[/bold] {cmd}\n[bold red]Risk:[/bold] {r_desc}")
+            risk_details.append(f"[bold red]Command:[/] {cmd}\n[bold red]Risk:[/] {r_desc}")
             if alt:
-                safer_alts.append(f"[bold green]Safer Alternative:[/bold] {alt}")
+                safer_alts.append(f"[bold green]Safer Alternative:[/] {alt}")
         elif r_level == "moderate" and highest_risk != "destructive":
             highest_risk = "moderate"
 
@@ -191,8 +191,20 @@ def main(
                     raise typer.Exit(code=1)
             else:
                 try:
-                    res = git_ops.execute(cmd)
-                    outputs.append(res)
+                    import subprocess
+                    import sys
+                    import shlex
+                    args = shlex.split(cmd)[1:]
+                    res_proc = subprocess.run(
+                        [sys.executable, "-m", "ace"] + args,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        encoding="utf-8"
+                    )
+                    if res_proc.returncode != 0:
+                        raise Exception(res_proc.stderr or res_proc.stdout)
+                    outputs.append(res_proc.stdout)
                 except Exception as e:
                     show_error_panel(f"Failed to execute command '{cmd}': {e}", "Execution Error")
                     raise typer.Exit(code=1)
@@ -207,7 +219,7 @@ def main(
 
     # Summarization flow for read-only history queries
     combined_output = "\n".join(outputs)
-    if highest_risk == "safe" and combined_output.strip():
+    if highest_risk == "safe" and combined_output.strip() and not any(c.startswith("ace ") for c in commands):
         from ace.ai.history_analyzer import HistoryAnalyzer
         from rich.markdown import Markdown
         analyzer = HistoryAnalyzer(git_ops)
@@ -270,6 +282,8 @@ def commit_cmd(
             with open(prepare, "w", encoding="utf-8") as f:
                 f.write(msg)
             raise typer.Exit(code=0)
+        except (typer.Exit, typer.Abort):
+            raise
         except NoStagedChangesError:
             raise typer.Exit(code=0)
         except Exception as e:
@@ -785,7 +799,8 @@ def changelog_cmd(
         show_error_panel(f"{str(e)}\n\nRun [bold]ace setup[/bold] to configure your AI credentials.", "Configuration Error")
         raise typer.Exit(code=1)
     except Exception as e:
-        show_error_panel(f"Failed to generate changelog: {e}", "AI Error")
+        title = "Git Error" if "ChangelogGeneratorError" in str(type(e)) or "Cmd('git')" in str(e) or "Invalid starting revision" in str(e) or "Invalid ending revision" in str(e) else "AI Error"
+        show_error_panel(f"Failed to generate changelog: {e}", title)
         raise typer.Exit(code=1)
 
     # Show or write to file
@@ -1154,9 +1169,9 @@ def undo_cmd(
         r_level, r_desc, alt = SafetyChecker.analyze_command(cmd)
         if r_level == "destructive":
             highest_risk = "destructive"
-            risk_details.append(f"[bold red]Command:[/bold] {cmd}\n[bold red]Risk:[/bold] {r_desc}")
+            risk_details.append(f"[bold red]Command:[/] {cmd}\n[bold red]Risk:[/] {r_desc}")
             if alt:
-                safer_alts.append(f"[bold green]Safer Alternative:[/bold] {alt}")
+                safer_alts.append(f"[bold green]Safer Alternative:[/] {alt}")
         elif r_level == "moderate" and highest_risk != "destructive":
             highest_risk = "moderate"
 
@@ -1251,7 +1266,8 @@ def pr_cmd(
         with spinner(f"Generating PR description against base branch '{base}'..."):
             pr_data = drafter.draft_pr(base, offline=offline)
     except Exception as e:
-        show_error_panel(f"Failed to generate PR description: {e}", "AI Error")
+        title = "Git Error" if "Cmd('git')" in str(e) or "git log" in str(e) or "exit code" in str(e) else "AI Error"
+        show_error_panel(f"Failed to generate PR description: {e}", title)
         raise typer.Exit(code=1)
 
     title = pr_data.get("title", "Pull Request")

{ace_git_copilot-0.3.1 → 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.1 → 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.1 → 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.1 → ace_git_copilot-0.3.3}/ace/ui/display.py

@@ -30,9 +30,65 @@ def print_warning(message: str) -> None:
     """Print a warning message."""
     console.print(f" [warning]{_SYM_WARNING}[/warning]  [warning]{message}[/warning]")
 
+def clean_error_message(message: str) -> str:
+    """Clean up common LLM API response dumps and traceback details into human-readable text."""
+    from rich.markup import escape
+
+    # Normalize/clean raw message string
+    msg_str = str(message).strip()
+
+    # Check for NVIDIA/OpenAI 504 gateway timeout
+    if "504" in msg_str or "Gateway Timeout" in msg_str:
+        return (
+            "API Server Error: [bold #FF1744]Gateway Timeout (504)[/bold #FF1744]\n\n"
+            "The cloud AI provider servers took too long to respond. This is a temporary server "
+            "overload. Please try again in a few moments, or run [bold]ace setup[/bold] to switch "
+            "to a local model (Ollama) or another provider."
+        )
+
+    # Check for authentication errors
+    if "AuthenticationError" in msg_str or "invalid api key" in msg_str.lower() or "401" in msg_str:
+        return (
+            "API Authentication Error: [bold #FF1744]Invalid API Key[/bold #FF1744]\n\n"
+            "Please check that your API key is correct and active. Run [bold]ace setup[/bold] to reconfigure."
+        )
+
+    # Check for rate limits
+    if "RateLimitError" in msg_str or "429" in msg_str or "rate limit exceeded" in msg_str.lower():
+        return (
+            "API Rate Limit Error: [bold #FF1744]Too Many Requests[/bold #FF1744]\n\n"
+            "You have hit the rate limit for this API provider. Please wait a moment before trying again."
+        )
+
+    # General Connection errors
+    if "ConnectionError" in msg_str or "Failed to establish a new connection" in msg_str or "timeout" in msg_str.lower():
+        return (
+            "API Connection Error: [bold #FF1744]Network Timeout[/bold #FF1744]\n\n"
+            "Could not connect to the AI API endpoint. Please check your internet connection and try again."
+        )
+
+    # If it's a raw dictionary dump of a response (like in NVIDIA / OpenAI SDK exception strings)
+    if "{'_content':" in msg_str or "'status_code':" in msg_str or "'_content_consumed':" in msg_str:
+        lines = msg_str.splitlines()
+        first_line = lines[0] if lines else ""
+        if "APIStatusError" in first_line:
+            first_line = first_line.split("APIStatusError:")[-1].strip()
+            
+        import re
+        status_match = re.search(r"'status_code':\s*(\d+)", msg_str)
+        reason_match = re.search(r"'reason':\s*'([^']+)'", msg_str)
+        if status_match and reason_match:
+            return f"API Error: [bold #FF1744]{escape(reason_match.group(1))} ({status_match.group(1)})[/bold #FF1744]"
+        elif status_match:
+            return f"API Error: [bold #FF1744]Status Code {status_match.group(1)}[/bold #FF1744]"
+        return escape(first_line) if first_line else "An unexpected API error occurred."
+
+    # If it's a generic exception or string, escape it to prevent Rich markup parsing errors
+    return escape(msg_str)
+
 def print_error(message: str) -> None:
     """Print an error message."""
-    err_console.print(f" [error]{_SYM_ERROR}[/error]  [error]{message}[/error]")
+    err_console.print(f" [error]{_SYM_ERROR}[/error]  [error]{clean_error_message(message)}[/error]")
 
 
 # ─── Panels ──────────────────────────────────────────────────────────────────
@@ -57,8 +113,11 @@ def show_error_panel(message: str, title: str = "Error") -> None:
     """Show a styled red error panel."""
     from rich.panel import Panel
     from rich import box
+    
+    cleaned_message = clean_error_message(message)
+    
     panel = Panel(
-        Text.from_markup(message),
+        Text.from_markup(cleaned_message),
         title=f"[bold #FF1744] {_SYM_ERROR} {title}[/bold #FF1744]",
         border_style="#FF1744",
         box=box.ROUNDED,

{ace_git_copilot-0.3.1 → ace_git_copilot-0.3.3}/ace/ui/prompts.py

@@ -30,7 +30,8 @@ def confirm(question: str, default: bool = True) -> bool:
         return False
     if val in ("\r", "\n", ""):
         return default
-    return default
+    # Default to False for safety on unrecognized inputs
+    return False
 
 
 def prompt_action(options: Dict[str, Tuple[str, str]], default_key: str = "\r") -> str:

{ace_git_copilot-0.3.1 → ace_git_copilot-0.3.3}/pyproject.toml

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