reverse-api-engineer 0.4.2__tar.gz → 0.4.3__tar.gz

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.3}/.claude/settings.local.json

@@ -111,7 +111,9 @@
       "Bash(pip show:*)",
       "Bash(npm uninstall:*)",
       "Bash(npx rollup-plugin-visualizer:*)",
-      "Bash(git pull:*)"
+      "Bash(git pull:*)",
+      "WebFetch(domain:docs.anthropic.com)",
+      "WebFetch(domain:docs.claude.com)"
     ]
   }
 }

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.3}/CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.3] - 2026-03-12
+
+### Fixed
+- **AskUserQuestion interactive prompt**: Fixed interactive questionary UI not rendering in engineer and agent modes. Switched from `ClaudeSDKClient` to `query()` function, as `ClaudeSDKClient` silently auto-approves `AskUserQuestion` without triggering the `can_use_tool` callback
+
 ## [0.4.2] - 2026-03-12
 
 ### Fixed

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse-api-engineer
-Version: 0.4.2
+Version: 0.4.3
 Summary: A tool to capture browser traffic for API reverse engineering
 Project-URL: Homepage, https://github.com/kalil0321/reverse-api-engineer
 Project-URL: Repository, https://github.com/kalil0321/reverse-api-engineer

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reverse-api-engineer"
-version = "0.4.2"
+version = "0.4.3"
 description = "A tool to capture browser traffic for API reverse engineering"
 readme = "README.md"
 requires-python = ">=3.11"

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.3}/src/reverse_api/auto_engineer.py

@@ -11,11 +11,14 @@ import httpx
 from claude_agent_sdk import (
     AssistantMessage,
     ClaudeAgentOptions,
-    ClaudeSDKClient,
+    HookMatcher,
+    PermissionResultAllow,
     ResultMessage,
     TextBlock,
+    ToolPermissionContext,
     ToolResultBlock,
     ToolUseBlock,
+    query,
 )
 
 from .engineer import ClaudeEngineer
@@ -226,6 +229,19 @@ Your final response should confirm the files were created and provide a brief su
 - Any limitations or caveats
 """
 
+    async def _handle_tool_permission(
+        self, tool_name: str, input_data: dict[str, Any], context: ToolPermissionContext
+    ) -> PermissionResultAllow:
+        """Handle tool permission requests, with interactive UI for AskUserQuestion."""
+        if tool_name == "AskUserQuestion":
+            questions = input_data.get("questions", [])
+            answers = await self._ask_user_interactive(questions)
+            return PermissionResultAllow(
+                updated_input={"questions": questions, "answers": answers},
+            )
+        # Auto-approve all other tools
+        return PermissionResultAllow(updated_input=input_data)
+
     async def analyze_and_generate(self) -> dict[str, Any] | None:
         """Run auto mode with MCP browser integration."""
         self.ui.header(self.run_id, self.prompt, self.model)
@@ -243,119 +259,116 @@ Your final response should confirm the files were created and provide a brief su
             ],
         }
 
+        # Required workaround: dummy hook keeps the stream open for can_use_tool
+        # See: https://platform.claude.com/docs/en/agent-sdk/user-input
+        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
+            return {"continue_": True}
+
+        prompt_text = self._build_auto_prompt()
+
+        async def _prompt_stream() -> Any:
+            yield {
+                "type": "user",
+                "message": {"role": "user", "content": prompt_text},
+            }
+
         options = ClaudeAgentOptions(
             mcp_servers={"playwright": mcp_config},
-            permission_mode="bypassPermissions",  # Auto-accept browser tool usage
-            allowed_tools=[
-                "Read",
-                "Write",
-                "Bash",
-                "Glob",
-                "Grep",
-                "WebSearch",
-                "WebFetch",
-            ],
+            can_use_tool=self._handle_tool_permission,
+            hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[_dummy_hook])]},
             cwd=str(self.scripts_dir.parent.parent),  # Project root
             model=self.model,
         )
 
         try:
-            async with ClaudeSDKClient(options=options) as client:
-                await client.query(self._build_auto_prompt())
-
-                # Process response and show progress with TUI
-                async for message in client.receive_response():
-                    # Check for usage metadata
-                    if hasattr(message, "usage") and isinstance(message.usage, dict):
-                        self.usage_metadata.update(message.usage)
-
-                    if isinstance(message, AssistantMessage):
-                        last_tool_name = None
-                        for block in message.content:
-                            if isinstance(block, ToolUseBlock):
-                                last_tool_name = block.name
-                                self.ui.tool_start(block.name, block.input)
-                                self.message_store.save_tool_start(block.name, block.input)
-                            elif isinstance(block, ToolResultBlock):
-                                is_error = block.is_error if block.is_error else False
-
-                                # Extract output from ToolResultBlock
-                                output = None
-                                if hasattr(block, "content"):
-                                    output = block.content
-                                elif hasattr(block, "result"):
-                                    output = block.result
-                                elif hasattr(block, "output"):
-                                    output = block.output
-
-                                tool_name = last_tool_name or "Tool"
-                                self.ui.tool_result(tool_name, is_error, output)
-                                self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
-                            elif isinstance(block, TextBlock):
-                                self.ui.thinking(block.text)
-                                self.message_store.save_thinking(block.text)
-
-                    elif isinstance(message, ResultMessage):
-                        if message.is_error:
-                            self.ui.error(message.result or "Unknown error")
-                            self.message_store.save_error(message.result or "Unknown error")
-                            return None
-                        else:
-                            script_path = str(self.scripts_dir / self._get_client_filename())
-                            local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
-                            self.ui.success(script_path, local_path)
-
-                            # Calculate estimated cost if we have usage data
-                            if self.usage_metadata:
-                                input_tokens = self.usage_metadata.get("input_tokens", 0)
-                                output_tokens = self.usage_metadata.get("output_tokens", 0)
-                                cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
-                                cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
-
-                                # Calculate cost using shared pricing module
-                                from .pricing import calculate_cost
-
-                                cost = calculate_cost(
-                                    model_id=self.model,
-                                    input_tokens=input_tokens,
-                                    output_tokens=output_tokens,
-                                    cache_creation_tokens=cache_creation_tokens,
-                                    cache_read_tokens=cache_read_tokens,
-                                )
-                                self.usage_metadata["estimated_cost_usd"] = cost
-
-                                # Display usage breakdown
-                                self.ui.console.print(f"  [dim]Usage:[/dim]")  # noqa: F541
-                                if input_tokens > 0:
-                                    self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
-                                if cache_creation_tokens > 0:
-                                    self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
-                                if cache_read_tokens > 0:
-                                    self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
-                                if output_tokens > 0:
-                                    self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
-                                self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
-
-                            result: dict[str, Any] = {
-                                "script_path": script_path,
-                                "usage": self.usage_metadata,
-                            }
-                            self.message_store.save_result(result)
-                            return result
+            async for message in query(prompt=_prompt_stream(), options=options):
+                # Check for usage metadata
+                if hasattr(message, "usage") and isinstance(message.usage, dict):
+                    self.usage_metadata.update(message.usage)
+
+                if isinstance(message, AssistantMessage):
+                    last_tool_name = None
+                    for block in message.content:
+                        if isinstance(block, ToolUseBlock):
+                            last_tool_name = block.name
+                            self.ui.tool_start(block.name, block.input)
+                            self.message_store.save_tool_start(block.name, block.input)
+                        elif isinstance(block, ToolResultBlock):
+                            is_error = block.is_error if block.is_error else False
+
+                            # Extract output from ToolResultBlock
+                            output = None
+                            if hasattr(block, "content"):
+                                output = block.content
+                            elif hasattr(block, "result"):
+                                output = block.result
+                            elif hasattr(block, "output"):
+                                output = block.output
+
+                            tool_name = last_tool_name or "Tool"
+                            self.ui.tool_result(tool_name, is_error, output)
+                            self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
+                        elif isinstance(block, TextBlock):
+                            self.ui.thinking(block.text)
+                            self.message_store.save_thinking(block.text)
+
+                elif isinstance(message, ResultMessage):
+                    if message.is_error:
+                        self.ui.error(message.result or "Unknown error")
+                        self.message_store.save_error(message.result or "Unknown error")
+                        return None
+                    else:
+                        script_path = str(self.scripts_dir / self._get_client_filename())
+                        local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
+                        self.ui.success(script_path, local_path)
+
+                        # Calculate estimated cost if we have usage data
+                        if self.usage_metadata:
+                            input_tokens = self.usage_metadata.get("input_tokens", 0)
+                            output_tokens = self.usage_metadata.get("output_tokens", 0)
+                            cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
+                            cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
+
+                            from .pricing import calculate_cost
+
+                            cost = calculate_cost(
+                                model_id=self.model,
+                                input_tokens=input_tokens,
+                                output_tokens=output_tokens,
+                                cache_creation_tokens=cache_creation_tokens,
+                                cache_read_tokens=cache_read_tokens,
+                            )
+                            self.usage_metadata["estimated_cost_usd"] = cost
+
+                            self.ui.console.print("  [dim]Usage:[/dim]")
+                            if input_tokens > 0:
+                                self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
+                            if cache_creation_tokens > 0:
+                                self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
+                            if cache_read_tokens > 0:
+                                self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
+                            if output_tokens > 0:
+                                self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
+                            self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
+
+                        result: dict[str, Any] = {
+                            "script_path": script_path,
+                            "usage": self.usage_metadata,
+                        }
+                        self.message_store.save_result(result)
+                        return result
 
         except Exception as e:
             error_msg = str(e)
             self.ui.error(error_msg)
             self.message_store.save_error(error_msg)
 
-            # Handle screenshot buffer size errors specifically
             if "buffer size" in error_msg.lower() or "1048576" in error_msg or "exceeded maximum buffer" in error_msg.lower():
-                self.ui.console.print("\n[yellow]⚠ Screenshot too large (exceeds 1MB limit)[/yellow]")
+                self.ui.console.print("\n[yellow]Screenshot too large (exceeds 1MB limit)[/yellow]")
                 self.ui.console.print("[dim]Tip: The AI should take element-specific screenshots instead of full-page screenshots.[/dim]")
                 self.ui.console.print(
                     "[dim]Consider using browser_snapshot() for accessibility tree information when screenshots aren't needed.[/dim]"
                 )
-            # Provide helpful error messages
             elif "MCP server" in error_msg or "npx" in error_msg:
                 self.ui.console.print("\n[dim]Make sure rae-playwright-mcp is installed: npm install -g rae-playwright-mcp[/dim]")
             else:

reverse_api_engineer-0.4.3/src/reverse_api/engineer.py

@@ -0,0 +1,255 @@
+"""Reverse engineering module with SDK dispatch."""
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any
+
+from claude_agent_sdk import (
+    AssistantMessage,
+    ClaudeAgentOptions,
+    HookMatcher,
+    PermissionResultAllow,
+    ResultMessage,
+    TextBlock,
+    ToolPermissionContext,
+    ToolResultBlock,
+    ToolUseBlock,
+    query,
+)
+
+from .base_engineer import BaseEngineer
+
+# Suppress claude_agent_sdk logs
+logging.getLogger("claude_agent_sdk").setLevel(logging.WARNING)
+logging.getLogger("claude_agent_sdk._internal.transport.subprocess_cli").setLevel(logging.WARNING)
+
+
+class ClaudeEngineer(BaseEngineer):
+    """Uses Claude Agent SDK to analyze HAR files and generate Python API scripts."""
+
+    async def _handle_tool_permission(
+        self, tool_name: str, input_data: dict[str, Any], context: ToolPermissionContext
+    ) -> PermissionResultAllow:
+        """Handle tool permission requests, with interactive UI for AskUserQuestion."""
+        if tool_name == "AskUserQuestion":
+            questions = input_data.get("questions", [])
+            answers = await self._ask_user_interactive(questions)
+            return PermissionResultAllow(
+                updated_input={"questions": questions, "answers": answers},
+            )
+
+        # Auto-approve all other tools
+        return PermissionResultAllow(updated_input=input_data)
+
+    async def analyze_and_generate(self) -> dict[str, Any] | None:
+        """Run the reverse engineering analysis with Claude."""
+        self.ui.header(self.run_id, self.prompt, self.model, self.sdk)
+        self.ui.start_analysis()
+        self.message_store.save_prompt(self._build_analysis_prompt())
+
+        # Required workaround: dummy hook keeps the stream open for can_use_tool
+        # See: https://platform.claude.com/docs/en/agent-sdk/user-input
+        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
+            return {"continue_": True}
+
+        prompt_text = self._build_analysis_prompt()
+
+        async def _prompt_stream() -> Any:
+            yield {
+                "type": "user",
+                "message": {"role": "user", "content": prompt_text},
+            }
+
+        options = ClaudeAgentOptions(
+            can_use_tool=self._handle_tool_permission,
+            hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[_dummy_hook])]},
+            cwd=str(self.scripts_dir.parent.parent),  # Project root
+            model=self.model,
+        )
+
+        try:
+            async for message in query(prompt=_prompt_stream(), options=options):
+                # Check for usage metadata in message if applicable
+                if hasattr(message, "usage") and isinstance(message.usage, dict):
+                    self.usage_metadata.update(message.usage)
+
+                if isinstance(message, AssistantMessage):
+                    last_tool_name = None
+                    for block in message.content:
+                        if isinstance(block, ToolUseBlock):
+                            last_tool_name = block.name
+                            self.ui.tool_start(block.name, block.input)
+                            self.message_store.save_tool_start(block.name, block.input)
+                        elif isinstance(block, ToolResultBlock):
+                            is_error = block.is_error if block.is_error else False
+
+                            # Extract output from ToolResultBlock
+                            output = None
+                            if hasattr(block, "content"):
+                                output = block.content
+                            elif hasattr(block, "result"):
+                                output = block.result
+                            elif hasattr(block, "output"):
+                                output = block.output
+
+                            tool_name = last_tool_name or "Tool"
+                            self.ui.tool_result(tool_name, is_error, output)
+                            self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
+                        elif isinstance(block, TextBlock):
+                            self.ui.thinking(block.text)
+                            self.message_store.save_thinking(block.text)
+
+                elif isinstance(message, ResultMessage):
+                    if message.is_error:
+                        self.ui.error(message.result or "Unknown error")
+                        self.message_store.save_error(message.result or "Unknown error")
+                        return None
+                    else:
+                        script_path = str(self.scripts_dir / self._get_client_filename())
+                        local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
+                        self.ui.success(script_path, local_path)
+
+                        # Calculate estimated cost if we have usage data
+                        if self.usage_metadata:
+                            input_tokens = self.usage_metadata.get("input_tokens", 0)
+                            output_tokens = self.usage_metadata.get("output_tokens", 0)
+                            cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
+                            cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
+
+                            # Calculate cost using shared pricing module
+                            from .pricing import calculate_cost
+
+                            cost = calculate_cost(
+                                model_id=self.model,
+                                input_tokens=input_tokens,
+                                output_tokens=output_tokens,
+                                cache_creation_tokens=cache_creation_tokens,
+                                cache_read_tokens=cache_read_tokens,
+                            )
+                            self.usage_metadata["estimated_cost_usd"] = cost
+
+                            # Display usage breakdown
+                            self.ui.console.print("  [dim]Usage:[/dim]")
+                            if input_tokens > 0:
+                                self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
+                            if cache_creation_tokens > 0:
+                                self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
+                            if cache_read_tokens > 0:
+                                self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
+                            if output_tokens > 0:
+                                self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
+                            self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
+
+                        result: dict[str, Any] = {
+                            "script_path": script_path,
+                            "usage": self.usage_metadata,
+                        }
+                        self.message_store.save_result(result)
+                        return result
+
+        except Exception as e:
+            self.ui.error(str(e))
+            self.message_store.save_error(str(e))
+            self.ui.console.print("\n[dim]Make sure Claude Code CLI is installed: npm install -g @anthropic-ai/claude-code[/dim]")
+            return None
+
+        return None
+
+
+# Keep old class name for backwards compatibility
+APIReverseEngineer = ClaudeEngineer
+
+
+def run_reverse_engineering(
+    run_id: str,
+    har_path: Path,
+    prompt: str,
+    model: str | None = None,
+    additional_instructions: str | None = None,
+    output_dir: str | None = None,
+    verbose: bool = True,
+    sdk: str = "claude",
+    opencode_provider: str | None = None,
+    opencode_model: str | None = None,
+    copilot_model: str | None = None,
+    enable_sync: bool = False,
+    is_fresh: bool = False,
+    output_language: str = "python",
+    output_mode: str = "client",
+) -> dict[str, Any] | None:
+    """Run reverse engineering with the specified SDK.
+
+    Args:
+        sdk: "claude", "opencode", or "copilot" - determines which SDK to use
+        opencode_provider: Provider ID for OpenCode (e.g., "anthropic")
+        opencode_model: Model ID for OpenCode (e.g., "claude-sonnet-4-6")
+        copilot_model: Model ID for Copilot (e.g., "gpt-5")
+        enable_sync: Enable real-time file syncing during engineering
+        is_fresh: Whether to start fresh (ignore previous scripts)
+        output_language: Target language - "python", "javascript", or "typescript"
+        output_mode: Output mode - "client" for API client code, "docs" for OpenAPI specification
+    """
+    if sdk == "opencode":
+        from .opencode_engineer import OpenCodeEngineer
+
+        engineer = OpenCodeEngineer(
+            run_id=run_id,
+            har_path=har_path,
+            prompt=prompt,
+            model=model,
+            additional_instructions=additional_instructions,
+            output_dir=output_dir,
+            verbose=verbose,
+            opencode_provider=opencode_provider,
+            opencode_model=opencode_model,
+            enable_sync=enable_sync,
+            sdk=sdk,
+            is_fresh=is_fresh,
+            output_language=output_language,
+            output_mode=output_mode,
+        )
+    elif sdk == "copilot":
+        from .copilot_engineer import CopilotEngineer
+
+        engineer = CopilotEngineer(
+            run_id=run_id,
+            har_path=har_path,
+            prompt=prompt,
+            model=model,
+            additional_instructions=additional_instructions,
+            output_dir=output_dir,
+            verbose=verbose,
+            enable_sync=enable_sync,
+            sdk=sdk,
+            is_fresh=is_fresh,
+            output_language=output_language,
+            output_mode=output_mode,
+            copilot_model=copilot_model,
+        )
+    else:
+        engineer = ClaudeEngineer(
+            run_id=run_id,
+            har_path=har_path,
+            prompt=prompt,
+            model=model,
+            additional_instructions=additional_instructions,
+            output_dir=output_dir,
+            verbose=verbose,
+            enable_sync=enable_sync,
+            sdk=sdk,
+            is_fresh=is_fresh,
+            output_language=output_language,
+            output_mode=output_mode,
+        )
+
+    # Start sync before analysis
+    engineer.start_sync()
+
+    try:
+        result = asyncio.run(engineer.analyze_and_generate())
+    finally:
+        # Always stop sync when done
+        engineer.stop_sync()
+
+    return result

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.3}/uv.lock

@@ -2189,7 +2189,7 @@ wheels = [
 
 [[package]]
 name = "reverse-api-engineer"
-version = "0.4.0"
+version = "0.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },