reverse-api-engineer 0.4.4__tar.gz → 0.5.0__tar.gz

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.5.0}/CHANGELOG.md

@@ -5,11 +5,23 @@ 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.4] - 2026-03-15
+## [0.5.0] - 2026-03-17
+
+### Added
+- **Follow-up chat**: After a run completes, type follow-up messages to iterate in the same session without creating new run IDs or folders. Press Enter to finish
+- **Abort run (Ctrl+C)**: Gracefully cancel a running agent/engineer session and return to the REPL instead of exiting the app
+- **AskUserQuestion free mode**: All select/checkbox prompts now include "Other (type your answer)" so users can always provide free-text input. Updated agent prompt to document free-form, multi-select, and multi-question capabilities
+- **Random task suggestions (Ctrl+R)**: Press Ctrl+R in agent mode to fill the prompt with a random curated task idea. Press again to cycle
+
+### Fixed
+- **Usage tracking across follow-ups**: Token counts now accumulate across all turns in a session instead of being overwritten by the last turn
+- **Agent mode follow-up**: Auto engineer (agent mode) was using a copy-pasted streaming loop without follow-up support; now reuses the shared conversation loop
+
+## [0.4.5] - 2026-03-15
 
 ### Fixed
-- **Stream closed errors (#51)**: Fixed "Error in hook callback hook_0: Stream closed" by clearing inherited `CLAUDECODE` env var from CLI subprocess and extending stream close timeout
-- **Async generator cleanup**: Avoid early return inside `query()` loop to prevent cancel-scope errors
+- **Stream closed errors (#51)**: Reverted from `query()` to `ClaudeSDKClient` which maintains a persistent bidirectional connection, eliminating "Error in hook callback hook_0: Stream closed" errors. The original AUQ fix (v0.4.3) unnecessarily switched APIs — only the `can_use_tool` callback signature needed updating
+- **CLAUDECODE env var leak**: Clear inherited `CLAUDECODE` env var from CLI subprocess to prevent nested session interference when running inside Claude Code
 - **CLI stderr noise**: Filter minified JS stack traces into a single clean error line (use `DEBUG=1` for full output)
 
 ### Changed
@@ -17,6 +29,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Agent mode**: No longer prompts for URL (agent navigates autonomously)
 - **Header UI**: Version and task labels now use mode-specific colors (agent=coral, engineer=blue, collector=gold)
 
+## [0.4.4] - 2026-03-15
+
+### Fixed
+- **Stream closed errors (#51)**: Partial fix using `query()` with env var workarounds (superseded by v0.4.5)
+
 ## [0.4.3] - 2026-03-12
 
 ### Fixed

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse-api-engineer
-Version: 0.4.4
+Version: 0.5.0
 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
@@ -19,18 +19,13 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
-Requires-Dist: aiohttp>=3.12.15
-Requires-Dist: anthropic>=0.40.0
-Requires-Dist: brotli>=1.2.0
 Requires-Dist: claude-agent-sdk>=0.1.48
 Requires-Dist: click>=8.1.0
 Requires-Dist: playwright-stealth>=1.0.0
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: questionary>=2.0.0
-Requires-Dist: requests>=2.32.5
 Requires-Dist: rich>=13.0.0
 Requires-Dist: setproctitle>=1.3.0
-Requires-Dist: sprites-py>=0.0.1a1
 Requires-Dist: watchdog>=3.0.0
 Provides-Extra: agent
 Requires-Dist: stagehand; extra == 'agent'

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reverse-api-engineer"
-version = "0.4.4"
+version = "0.5.0"
 description = "A tool to capture browser traffic for API reverse engineering"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -27,13 +27,8 @@ dependencies = [
     "claude-agent-sdk>=0.1.48",
     "rich>=13.0.0",
     "questionary>=2.0.0",
-    "requests>=2.32.5",
-    "anthropic>=0.40.0",
-    "brotli>=1.2.0",
-    "aiohttp>=3.12.15",
     "watchdog>=3.0.0",
     "setproctitle>=1.3.0",
-    "sprites-py>=0.0.1a1",
 ]
 
 [project.optional-dependencies]

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.5.0}/src/reverse_api/auto_engineer.py

@@ -9,16 +9,10 @@ from typing import Any
 
 import httpx
 from claude_agent_sdk import (
-    AssistantMessage,
     ClaudeAgentOptions,
-    HookMatcher,
+    ClaudeSDKClient,
     PermissionResultAllow,
-    ResultMessage,
-    TextBlock,
     ToolPermissionContext,
-    ToolResultBlock,
-    ToolUseBlock,
-    query,
 )
 
 from .engineer import ClaudeEngineer
@@ -241,7 +235,10 @@ Your final response should confirm the files were created and provide a brief su
         return PermissionResultAllow(updated_input=input_data)
 
     async def analyze_and_generate(self) -> dict[str, Any] | None:
-        """Run auto mode with MCP browser integration."""
+        """Run auto mode with MCP browser integration.
+
+        Reuses _process_streaming_response and follow-up loop from ClaudeEngineer.
+        """
         self.ui.header(self.run_id, self.prompt, self.model, mode="agent")
         self.ui.start_analysis()
         self.message_store.save_prompt(self._build_auto_prompt())
@@ -257,105 +254,44 @@ Your final response should confirm the files were created and provide a brief su
             ],
         }
 
-        # Required: dummy hook keeps the stream open for can_use_tool
-        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
-            return {"continue_": True}
-
-        async def _prompt_stream():
-            yield {
-                "type": "user",
-                "message": {"role": "user", "content": self._build_auto_prompt()},
-            }
-
         options = ClaudeAgentOptions(
             mcp_servers={"playwright": mcp_config},
+            permission_mode="bypassPermissions",
             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,
-            env={"CLAUDECODE": "", "CLAUDE_CODE_STREAM_CLOSE_TIMEOUT": "1800000"},
+            env={"CLAUDECODE": ""},
             stderr=self._handle_cli_stderr,
         )
 
-        final_result: dict[str, Any] | None = None
+        last_result: dict[str, Any] | None = None
 
         try:
-            # Do not break/return inside this loop — the SDK requires the
-            # async generator to be fully consumed to avoid cancel-scope errors.
-            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")
-                    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]")
-
-                        final_result = {
-                            "script_path": script_path,
-                            "usage": self.usage_metadata,
-                        }
-                        self.message_store.save_result(final_result)
+            async with ClaudeSDKClient(options=options) as client:
+                await client.query(self._build_auto_prompt())
+
+                # Process initial response
+                last_result = await self._process_streaming_response(client)
+                if last_result is None:
+                    return None
+
+                # Conversation loop: prompt for follow-ups
+                while True:
+                    follow_up = await self._prompt_follow_up()
+                    if not follow_up:
+                        return last_result
+
+                    self.ui.console.print()
+                    self.message_store.save_prompt(follow_up)
+                    await client.query(follow_up)
+
+                    result = await self._process_streaming_response(client)
+                    if result is not None:
+                        last_result = result
+
+        except KeyboardInterrupt:
+            self.ui.console.print("\n  [dim]run aborted[/dim]")
+            return last_result
 
         except Exception as e:
             error_msg = str(e)
@@ -374,8 +310,6 @@ Your final response should confirm the files were created and provide a brief su
                 self.ui.console.print("\n[dim]Make sure Claude Code CLI is installed: npm install -g @anthropic-ai/claude-code[/dim]")
             return None
 
-        return final_result
-
 
 class OpenCodeAutoEngineer(OpenCodeEngineer):
     """Auto mode using OpenCode SDK: Register MCP server dynamically."""

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.5.0}/src/reverse_api/base_engineer.py

@@ -1,5 +1,6 @@
 """Abstract base class for API reverse engineering."""
 
+import asyncio
 import os
 from abc import ABC, abstractmethod
 from pathlib import Path
@@ -15,6 +16,8 @@ from .utils import generate_folder_name, get_docs_dir, get_history_path, get_scr
 
 DEBUG = os.environ.get("DEBUG", "0") == "1"
 
+OTHER_OPTION = "Other (type your answer)"
+
 
 class BaseEngineer(ABC):
     """Abstract base class for API reverse engineering implementations."""
@@ -172,6 +175,7 @@ class BaseEngineer(ABC):
                         for opt in options
                     ]
                     if choices:
+                        choices.append(OTHER_OPTION)
                         selected = await questionary.checkbox(
                             f" > {question_text}",
                             choices=choices,
@@ -188,7 +192,20 @@ class BaseEngineer(ABC):
                         if selected is None:
                             raise KeyboardInterrupt
 
-                        labels = [s.split(" - ")[0] if " - " in s else s for s in selected]
+                        has_other = OTHER_OPTION in selected
+                        labels = [s.split(" - ")[0] if " - " in s else s for s in selected if s != OTHER_OPTION]
+
+                        if has_other:
+                            other_text = await questionary.text(
+                                "   > Your answer: ",
+                                qmark="",
+                                style=questionary.Style([("question", f"fg:{THEME_SECONDARY}")]),
+                            ).ask_async()
+                            if other_text is None:
+                                raise KeyboardInterrupt
+                            if other_text.strip():
+                                labels.append(other_text.strip())
+
                         answers[question_text] = ", ".join(labels)
                     else:
                         answer = await questionary.text(
@@ -207,6 +224,7 @@ class BaseEngineer(ABC):
                         for opt in options
                     ]
                     if choices:
+                        choices.append(OTHER_OPTION)
                         answer = await questionary.select(
                             f" > {question_text}",
                             choices=choices,
@@ -222,8 +240,18 @@ class BaseEngineer(ABC):
                         if answer is None:
                             raise KeyboardInterrupt
 
-                        label = answer.split(" - ")[0] if " - " in answer else answer
-                        answers[question_text] = label
+                        if answer == OTHER_OPTION:
+                            answer = await questionary.text(
+                                "   > Your answer: ",
+                                qmark="",
+                                style=questionary.Style([("question", f"fg:{THEME_SECONDARY}")]),
+                            ).ask_async()
+                            if answer is None:
+                                raise KeyboardInterrupt
+                            answers[question_text] = answer.strip()
+                        else:
+                            label = answer.split(" - ")[0] if " - " in answer else answer
+                            answers[question_text] = label
                     else:
                         answer = await questionary.text(
                             f" > {question_text}",
@@ -243,6 +271,23 @@ class BaseEngineer(ABC):
         self.ui.console.print()
         return answers
 
+    async def _prompt_follow_up(self) -> str | None:
+        """Prompt user for a follow-up message. Returns None to finish.
+
+        Uses plain input() via executor instead of questionary to avoid
+        terminal state issues after the SDK subprocess exits.
+        """
+        self.ui.console.print()
+        self.ui.console.print(f"  [{THEME_PRIMARY}]─[/{THEME_PRIMARY}] [dim]type a follow-up or press Enter to finish[/dim]")
+        try:
+            loop = asyncio.get_event_loop()
+            answer = await loop.run_in_executor(None, lambda: input("  > "))
+            if not answer or not answer.strip():
+                return None
+            return answer.strip()
+        except (KeyboardInterrupt, EOFError):
+            return None
+
     @staticmethod
     def _get_opt_field(opt: Any, field: str) -> str:
         """Get a field from an option, supporting both dict and object access."""
@@ -593,6 +638,14 @@ Here is the output directory where you should save your generated files:
 **IMPORTANT: You have access to the AskUserQuestion tool to ask clarifying questions during your analysis.**
 Use this tool when you need to clarify functional requirements, prioritize features, choose between implementation approaches, or gather any other information that would help you generate better {task_description}.
 
+The AskUserQuestion tool supports:
+- **Multiple questions** in a single call (list of question objects)
+- **Single-select** questions with predefined options (user picks one, or types a custom answer)
+- **Multi-select** questions with predefined options (user picks multiple, or adds a custom answer)
+- **Free-form** questions with no options (user types their answer freely)
+
+Use free-form questions (empty options list) for open-ended input like URLs, credentials, descriptions, or any question where predefined choices don't make sense.
+
 Your task is to:
 
 1. **Read and analyze the HAR file** to understand all API calls that were captured. Look for:

{reverse_api_engineer-0.4.4 → reverse_api_engineer-0.5.0}/src/reverse_api/cli.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+import random
 import re
 from pathlib import Path
 
@@ -62,6 +63,29 @@ MODE_DESCRIPTIONS = {
     "collector": "ai-powered data collection",
 }
 
+AGENT_TASK_SUGGESTIONS = [
+    "Go to github.com/trending and capture the top 10 trending repos' API calls",
+    "Navigate to news.ycombinator.com, browse the front page and capture API interactions",
+    "Go to weather.com, search for New York weather and capture the forecast API",
+    "Visit reddit.com/r/programming, browse posts and capture the Reddit API calls",
+    "Go to maps.google.com, search for restaurants near Times Square and capture API calls",
+    "Navigate to twitter.com/explore and capture trending topics API interactions",
+    "Go to amazon.com, search for 'mechanical keyboard' and capture product search API",
+    "Visit spotify.com/search, search for an artist and capture the search API",
+    "Navigate to stackoverflow.com, search for 'python async' and capture the search API",
+    "Go to npmjs.com, search for 'express' and capture the package registry API",
+    "Visit producthunt.com and capture the feed/listing API calls",
+    "Go to crunchbase.com and browse company profiles to capture their API",
+    "Navigate to linkedin.com/jobs, search for 'software engineer' and capture job search API",
+    "Go to airbnb.com, search for stays in Paris and capture the listing search API",
+    "Visit imdb.com, search for a movie and capture the title/search API calls",
+    "Go to wolframalpha.com, run a query and capture the computation API",
+    "Navigate to booking.com, search for hotels in Tokyo and capture the search API",
+    "Go to zillow.com, search for homes in San Francisco and capture the listing API",
+    "Visit translate.google.com, translate a paragraph and capture the translation API",
+    "Go to unsplash.com, search for 'mountains' and capture the photo search API",
+]
+
 
 def prompt_interactive_options(
     prompt: str | None = None,
@@ -217,6 +241,15 @@ def prompt_interactive_options(
             # If no completion, just move cursor right
             buff.cursor_right()
 
+    @kb.add("c-r")  # Ctrl+R: random task suggestion (agent mode)
+    def random_suggestion(event):
+        """Fill prompt with a random task suggestion for agent mode."""
+        if mode_state["mode"] == "agent":
+            suggestion = random.choice(AGENT_TASK_SUGGESTIONS)
+            buff = event.app.current_buffer
+            buff.text = suggestion
+            buff.cursor_position = len(suggestion)
+
     def get_prompt():
         """Generate prompt with current mode indicator."""
         mode = mode_state["mode"]
@@ -330,12 +363,20 @@ def prompt_interactive_options(
     }
 
 
-@click.group(invoke_without_command=True)
+CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+
+@click.group(invoke_without_command=True, context_settings=CONTEXT_SETTINGS)
 @click.pass_context
 @click.version_option(version=__version__)
 def main(ctx: click.Context):
-    """Reverse API - Capture browser traffic for API reverse engineering."""
+    """reverse-api-engineer: reverse engineer apis.
+
+    Run without a subcommand to start the interactive REPL; use agent, manual,
+    or engineer for CLI mode.
+    """
     setproctitle.setproctitle("reverse-api-engineer")
+    setproctitle.setthreadtitle("reverse-api-engineer")
     if ctx.invoked_subcommand is None:
         repl_loop()
 
@@ -358,7 +399,7 @@ def repl_loop():
         model = config_manager.get("claude_code_model", "claude-sonnet-4-6")
 
     display_banner(console, sdk=sdk, model=model)
-    console.print("  [dim]shift+tab to cycle modes: agent | manual | engineer | collector[/dim]")
+    console.print("  [dim]shift+tab to cycle modes | ctrl+r for random task (agent)[/dim]")
     display_footer(console)
 
     # Show update message if background check has completed
@@ -413,7 +454,7 @@ def repl_loop():
                 else:
                     # Unknown command - show error and available commands
                     console.print(f" [red]Unknown command:[/red] {cmd}")
-                    console.print(" [dim]Available commands: /settings, /history, /messages, /help, /exit[/dim]")
+                    console.print(" [dim]Available commands: /settings, /history, /messages, /help, /commands, /exit[/dim]")
                 continue
 
             mode = options.get("mode", "agent")
@@ -976,6 +1017,9 @@ def handle_agent_help(mode_color=THEME_PRIMARY):
     table.add_row("", "")
 
     table.add_row("Shift+Tab", "Cycle to other modes (Manual, Engineer).")
+    table.add_row("", "")
+
+    table.add_row("Ctrl+R", "Fill prompt with a random task suggestion.\n[dim]Press multiple times to cycle through ideas.[/dim]")
 
     console.print(table)
     console.print()
@@ -1078,7 +1122,10 @@ def handle_help(mode_color=THEME_PRIMARY):
     )
     commands_table.add_row("", "")
 
-    commands_table.add_row("/help", "Show this help message\n[dim]Usage: /help[/dim]")
+    commands_table.add_row(
+        "/help or /commands",
+        "Show this help message\n[dim]Usage: /help[/dim]",
+    )
     commands_table.add_row("", "")
 
     commands_table.add_row("/exit or /quit", "Exit the application\n[dim]Usage: /exit[/dim]")
@@ -1095,6 +1142,7 @@ def handle_help(mode_color=THEME_PRIMARY):
     modes_table.add_row("agent", "Autonomous agent + capture")
     modes_table.add_row("manual", "Full pipeline: browser + reverse engineering")
     modes_table.add_row("engineer", "Reverse engineer only (enter run_id)")
+    modes_table.add_row("collector", "AI-powered data collection")
 
     console.print(" [bold white]Modes[/bold white] [dim]Shift+Tab to cycle[/dim]")
     console.print(modes_table)
@@ -1181,6 +1229,27 @@ def manual(prompt, url, reverse_engineer, model, output_dir):
     run_manual_capture(prompt, url, reverse_engineer, model, output_dir)
 
 
+@main.command()
+@click.option("--prompt", "-p", default=None, help="Instruction for the autonomous agent.")
+@click.option("--url", "-u", default=None, help="Optional starting URL.")
+@click.option(
+    "--reverse-engineer/--no-engineer",
+    "reverse_engineer",
+    default=True,
+    help="Run reverse engineering after capture.",
+)
+@click.option(
+    "--model",
+    "-m",
+    type=click.Choice(["claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5"]),
+    default=None,
+)
+@click.option("--output-dir", "-o", default=None, help="Custom output directory.")
+def agent(prompt, url, reverse_engineer, model, output_dir):
+    """Run autonomous agent browser session."""
+    run_agent_capture(prompt=prompt, url=url, reverse_engineer=reverse_engineer, model=model, output_dir=output_dir)
+
+
 def run_manual_capture(prompt=None, url=None, reverse_engineer=True, model=None, output_dir=None):
     """Shared logic for manual capture."""
     output_dir = output_dir or config_manager.get("output_dir")
@@ -1521,6 +1590,8 @@ def run_auto_capture(prompt=None, url=None, model=None, output_dir=None):
 
         try:
             result = asyncio.run(engineer.analyze_and_generate())
+        except KeyboardInterrupt:
+            result = None
         finally:
             # Always stop sync when done
             engineer.stop_sync()