refactor(auto_commit): switch to OpenRouter API for branch name and commit message

- Replace local prompt flow with send_to_openrouter for branch name suggestion
- Remove tempfile usage and find_prompt_command; rely on API inputs
- Introduce API config: timeout_seconds, api_key_env, api_base; pass through to API calls
- Validate and sanitize API responses; handle empty or invalid results gracefully
- Update generate_commit_message to use OpenRouter API; remove prompt_cmd dependency
- Adjust protected-branch handling to rely on API-based suggestions
- Enhance prompt.py parsing to support content field and reasoning fallback from API responses
- Improve error handling paths when API calls fail or return unexpected data
- Update integration tests to simulate API failures and mock send_to_openrouter
- Remove tests related to finding ab-prompt; adapt tests to API-based flow
- Minor import cleanup by removing tempfile usage and related code paths

Author: allanbatista

src/ab_cli/commands/auto_commit.py

@@ -8,9 +8,9 @@
 import os
 import subprocess
 import sys
-import tempfile
 
 from ab_cli.core.config import get_config, estimate_tokens, get_language
+from ab_cli.commands.prompt import send_to_openrouter
 
 # ANSI colors
 RED = '\033[0;31m'
@@ -84,8 +84,9 @@ def create_branch(branch_name: str) -> bool:
         return False
 
 
-def suggest_branch_name(diff: str, name_status: str, prompt_cmd: str, lang: str) -> str:
+def suggest_branch_name(diff: str, name_status: str, lang: str) -> str:
     """Generate a suggested branch name based on changes."""
+    import re
     config = get_config()
 
     prompt_text = f"""Analyze these git changes and suggest a branch name.
@@ -113,32 +114,49 @@ def suggest_branch_name(diff: str, name_status: str, prompt_cmd: str, lang: str)
 
     estimated_tokens = estimate_tokens(prompt_text)
     selected_model = config.select_model(estimated_tokens)
-
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-        f.write(prompt_text)
-        prompt_file = f.name
+    timeout_s = config.get_with_default('global.timeout_seconds')
+    api_key_env = config.get_with_default('global.api_key_env')
+    api_base = config.get_with_default('global.api_base')
 
     try:
-        result = subprocess.run(
-            [prompt_cmd, '--model', selected_model, '--lang', lang,
-             '--max-completion-tokens', '100', '--only-output', '--prompt', '-'],
-            stdin=open(prompt_file, 'r'),
-            capture_output=True,
-            text=True,
-            check=False
+        result = send_to_openrouter(
+            prompt=prompt_text,
+            context="",
+            lang=lang,
+            specialist=None,
+            model_name=selected_model,
+            timeout_s=timeout_s,
+            max_completion_tokens=-1,  # No limit
+            api_key_env=api_key_env,
+            api_base=api_base
         )
-        branch_name = result.stdout.strip()
+
+        if not result:
+            log_error("API call failed for branch suggestion")
+            return ""
+
+        branch_name = result.get('text', '').strip()
+
+        if not branch_name:
+            log_error("LLM returned empty response for branch name")
+            return ""
+
         # Clean up
-        import re
         branch_name = branch_name.strip('"\'`')
         branch_name = branch_name.split('\n')[0].strip()
         branch_name = re.sub(r'\s+', '-', branch_name)
         branch_name = re.sub(r'[^a-zA-Z0-9/_-]', '', branch_name)
         if len(branch_name) > 50:
             branch_name = branch_name[:50].rstrip('-')
+
+        if not branch_name:
+            log_error("Branch name became empty after cleanup")
+            return ""
+
         return branch_name
-    finally:
-        os.unlink(prompt_file)
+    except Exception as e:
+        log_error(f"Exception suggesting branch name: {e}")
+        return ""
 
 
 def get_staged_files() -> str:
@@ -196,26 +214,9 @@ def get_latest_commit() -> str:
     return result.stdout.strip()
 
 
-def find_prompt_command() -> str:
-    """Find the ab-prompt command."""
-    # Try to find it in the bin directory relative to this module
-    import pathlib
-    module_dir = pathlib.Path(__file__).parent.parent.parent.parent
-    prompt_cmd = module_dir / 'bin' / 'ab-prompt'
-    if prompt_cmd.exists():
-        return str(prompt_cmd)
-
-    # Fallback to PATH
-    import shutil
-    if shutil.which('ab-prompt'):
-        return 'ab-prompt'
-
-    raise FileNotFoundError("Could not find ab-prompt command")
-
-
 def generate_commit_message(diff: str, name_status: str, recent_commits: str,
-                           lang: str, prompt_cmd: str) -> str:
-    """Generate commit message using the prompt utility."""
+                           lang: str) -> str:
+    """Generate commit message using the LLM."""
     config = get_config()
 
     # Build the prompt
@@ -245,38 +246,40 @@ def generate_commit_message(diff: str, name_status: str, recent_commits: str,
     # Estimate tokens and select model
     estimated_tokens = estimate_tokens(prompt_text)
     selected_model = config.select_model(estimated_tokens)
+    timeout_s = config.get_with_default('global.timeout_seconds')
+    api_key_env = config.get_with_default('global.api_key_env')
+    api_base = config.get_with_default('global.api_base')
 
     log_info(f"Estimated tokens: ~{estimated_tokens} | Model: {selected_model} | Lang: {lang}")
     print()
 
-    # Write prompt to temp file and use stdin
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
-        f.write(prompt_text)
-        prompt_file = f.name
+    result = send_to_openrouter(
+        prompt=prompt_text,
+        context="",
+        lang=lang,
+        specialist=None,
+        model_name=selected_model,
+        timeout_s=timeout_s,
+        max_completion_tokens=-1,
+        api_key_env=api_key_env,
+        api_base=api_base
+    )
 
-    try:
-        result = subprocess.run(
-            [prompt_cmd, '--model', selected_model, '--lang', lang,
-             '--max-completion-tokens', '-1', '--only-output', '--prompt', '-'],
-            stdin=open(prompt_file, 'r'),
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        return result.stdout.strip()
-    finally:
-        os.unlink(prompt_file)
+    if not result:
+        raise RuntimeError("API call failed for commit message generation")
+
+    return result.get('text', '').strip()
 
 
 def handle_protected_branch(current_branch: str, diff: str, name_status: str,
-                            prompt_cmd: str, lang: str) -> bool:
+                            lang: str) -> bool:
     """Handle protected branch workflow. Returns True if should continue, False to abort."""
     log_warning(f"You are on '{current_branch}' branch.")
     print()
 
     # Try to suggest a branch name
     log_info("Suggesting branch name...")
-    suggested_branch = suggest_branch_name(diff, name_status, prompt_cmd, lang)
+    suggested_branch = suggest_branch_name(diff, name_status, lang)
 
     if suggested_branch:
         print(f"\n{GREEN}Suggested branch:{NC} {YELLOW}{suggested_branch}{NC}\n")
@@ -359,13 +362,6 @@ def main():
         log_error("Not inside a git repository")
         sys.exit(1)
 
-    # Find prompt command
-    try:
-        prompt_cmd = find_prompt_command()
-    except FileNotFoundError as e:
-        log_error(str(e))
-        sys.exit(1)
-
     # Change to repo root
     os.chdir(get_repo_root())
 
@@ -437,19 +433,17 @@ def main():
 
     # Handle protected branch (after staging so we have the diff for suggestions)
     if on_protected_branch:
-        handle_protected_branch(current_branch, diff, name_status, prompt_cmd, args.lang)
+        handle_protected_branch(current_branch, diff, name_status, args.lang)
 
     # Generate commit message
     log_info("Generating commit message...")
 
     try:
         commit_msg = generate_commit_message(
-            diff, name_status, recent_commits, args.lang, prompt_cmd
+            diff, name_status, recent_commits, args.lang
         )
-    except subprocess.CalledProcessError as e:
+    except Exception as e:
         log_error(f"Failed to generate commit message: {e}")
-        if e.stderr:
-            print(e.stderr, file=sys.stderr)
         sys.exit(1)
 
     if not commit_msg:

src/ab_cli/commands/prompt.py

@@ -142,7 +142,18 @@ def send_to_openrouter(prompt: str, context: str, lang: str, specialist: Optiona
         response.raise_for_status()
         data = response.json()
 
-        text_response = data['choices'][0]['message']['content']
+        message = data['choices'][0]['message']
+        text_response = message.get('content') or ''
+
+        # Handle reasoning models (gpt-5, o1, o3, etc.) that put response in reasoning field
+        if not text_response and 'reasoning' in message:
+            # For simple tasks, try to extract the final answer from reasoning
+            reasoning = message.get('reasoning', '')
+            # If the model ran out of tokens, reasoning might contain a partial answer
+            if reasoning:
+                pp(f"Note: Using reasoning field (model: {model_name}, content was empty)")
+                text_response = reasoning
+
         usage = data.get("usage", {})
         prompt_tokens = usage.get("prompt_tokens", "N/A")
         response_tokens = usage.get("completion_tokens", "N/A")
@@ -885,6 +896,9 @@ def main():
             }
 
             save_to_history(result['full_prompt'], response_text, result, files_info, args)
+        else:
+            # API call failed - exit with error code
+            sys.exit(1)
         return
 
     # If no prompt but file content exists, copy to clipboard

tests/integration/test_auto_commit.py

@@ -225,23 +225,25 @@ def test_main_no_changes_exits_0(self, mock_git_repo, monkeypatch, capsys):
         assert "No changes to commit" in captured.out
 
     def test_main_prompt_not_found_exits_1(self, mock_git_repo, monkeypatch, capsys):
-        """Exits with error if ab-prompt not found."""
+        """Exits with error if API call fails."""
         monkeypatch.chdir(mock_git_repo)
 
         # Create changes
         (mock_git_repo / "test.txt").write_text("content")
         subprocess.run(["git", "add", "."], cwd=mock_git_repo, check=True)
 
-        monkeypatch.setattr(sys, "argv", ["auto-commit"])
+        monkeypatch.setattr(sys, "argv", ["auto-commit", "-y"])
 
-        # Mock find_prompt_command to raise FileNotFoundError
-        with patch("ab_cli.commands.auto_commit.find_prompt_command") as mock_find:
-            mock_find.side_effect = FileNotFoundError("Could not find ab-prompt")
+        # Mock send_to_openrouter to return None (API failure)
+        # Also mock is_protected_branch to avoid input() prompt
+        with patch("ab_cli.commands.auto_commit.send_to_openrouter") as mock_send:
+            with patch("ab_cli.commands.auto_commit.is_protected_branch", return_value=False):
+                mock_send.return_value = None
 
-            with pytest.raises(SystemExit) as exc_info:
-                main()
+                with pytest.raises(SystemExit) as exc_info:
+                    main()
 
-            assert exc_info.value.code == 1
+                assert exc_info.value.code == 1
 
     def test_main_auto_add_flag(self, mock_git_repo, monkeypatch, mock_input):
         """'-a' flag stages all files."""
@@ -253,26 +255,27 @@ def test_main_auto_add_flag(self, mock_git_repo, monkeypatch, mock_input):
         # Verify file is not staged initially
         assert "unstaged.txt" not in get_staged_files()
 
-        monkeypatch.setattr(sys, "argv", ["auto-commit", "-a"])
+        monkeypatch.setattr(sys, "argv", ["auto-commit", "-a", "-y"])
 
-        # Mock find_prompt_command to raise after staging happens
+        # Mock send_to_openrouter to fail after staging happens
         call_count = [0]
         original_stage = stage_all_files
 
         def mock_stage():
             original_stage()
             call_count[0] += 1
 
+        # Also mock is_protected_branch to avoid input() prompt
         with patch("ab_cli.commands.auto_commit.stage_all_files", side_effect=mock_stage):
-            with patch("ab_cli.commands.auto_commit.find_prompt_command") as mock_find:
-                mock_find.side_effect = FileNotFoundError("abort test")
+            with patch("ab_cli.commands.auto_commit.send_to_openrouter") as mock_send:
+                with patch("ab_cli.commands.auto_commit.is_protected_branch", return_value=False):
+                    mock_send.return_value = None  # Fail after staging
 
-                with pytest.raises(SystemExit):
-                    main()
+                    with pytest.raises(SystemExit):
+                        main()
 
         # Verify staging was called (the flag was honored)
-        # Even though it fails later, we verified the -a flag triggers staging
-        assert call_count[0] >= 0  # Test passes if we got here without other errors
+        assert call_count[0] >= 1
 
     def test_main_user_cancels(self, mock_git_repo, monkeypatch, capsys):
         """Handles user cancellation during staging prompt."""
@@ -297,13 +300,15 @@ def test_main_lang_flag(self, mock_git_repo, monkeypatch, capsys):
         (mock_git_repo / "test.txt").write_text("content")
         subprocess.run(["git", "add", "."], cwd=mock_git_repo, check=True)
 
-        monkeypatch.setattr(sys, "argv", ["auto-commit", "-l", "pt-br"])
+        monkeypatch.setattr(sys, "argv", ["auto-commit", "-l", "pt-br", "-y"])
 
-        with patch("ab_cli.commands.auto_commit.find_prompt_command") as mock_find:
-            mock_find.side_effect = FileNotFoundError("abort")
+        # Also mock is_protected_branch to avoid input() prompt
+        with patch("ab_cli.commands.auto_commit.send_to_openrouter") as mock_send:
+            with patch("ab_cli.commands.auto_commit.is_protected_branch", return_value=False):
+                mock_send.return_value = None  # Fail to abort
 
-            with pytest.raises(SystemExit):
-                main()
+                with pytest.raises(SystemExit):
+                    main()
 
         captured = capsys.readouterr()
         # Language should be in info output

tests/unit/test_utils.py

@@ -1,52 +1,9 @@
 """Unit tests for utility functions across ab_cli modules."""
-from pathlib import Path
 from unittest.mock import patch
 
 import pytest
 
 
-class TestAutoCommitUtils:
-    """Tests for utility functions in auto_commit module."""
-
-    def test_find_prompt_command_in_bin(self, tmp_path, monkeypatch):
-        """find_prompt_command finds ab-prompt in bin directory."""
-        from ab_cli.commands import auto_commit
-
-        # Create mock bin structure
-        bin_dir = tmp_path / "bin"
-        bin_dir.mkdir()
-        prompt_cmd = bin_dir / "ab-prompt"
-        prompt_cmd.touch()
-
-        # Patch __file__ to point to our tmp structure
-        fake_module_path = tmp_path / "src" / "ab_cli" / "commands" / "auto_commit.py"
-        fake_module_path.parent.mkdir(parents=True, exist_ok=True)
-        fake_module_path.touch()
-
-        with patch.object(auto_commit, "__file__", str(fake_module_path)):
-            result = auto_commit.find_prompt_command()
-            assert result == str(prompt_cmd)
-
-    def test_find_prompt_command_in_path(self, monkeypatch):
-        """find_prompt_command falls back to PATH."""
-        from ab_cli.commands import auto_commit
-
-        # Mock pathlib to return non-existent path
-        with patch.object(Path, "exists", return_value=False):
-            with patch("shutil.which", return_value="/usr/local/bin/ab-prompt"):
-                result = auto_commit.find_prompt_command()
-                assert result == "ab-prompt"
-
-    def test_find_prompt_command_not_found(self, monkeypatch):
-        """find_prompt_command raises when not found."""
-        from ab_cli.commands import auto_commit
-
-        with patch.object(Path, "exists", return_value=False):
-            with patch("shutil.which", return_value=None):
-                with pytest.raises(FileNotFoundError):
-                    auto_commit.find_prompt_command()
-
-
 class TestAutoCommitGitHelpers:
     """Tests for git helper functions in auto_commit."""