tunacode-cli 0.0.45__py3-none-any.whl → 0.0.47__py3-none-any.whl

tunacode/cli/repl.py

@@ -344,7 +344,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
     except CancelledError:
         await ui.muted(MSG_REQUEST_CANCELLED)
     except UserAbortError:
-        await ui.muted(MSG_OPERATION_ABORTED)
+        await ui.muted(MSG_OPERATION_ABORTED_BY_USER)
     except UnexpectedModelBehavior as e:
         error_message = str(e)
         await ui.muted(error_message)
@@ -463,7 +463,6 @@ async def repl(state_manager: StateManager):
             state_manager.session.current_task = get_app().create_background_task(
                 process_request(line, state_manager)
             )
-            await state_manager.session.current_task
 
             state_manager.session.update_token_count()
             context_display = get_context_window_display(

tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.45"
+APP_VERSION = "0.0.47"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

tunacode/core/agents/main.py

@@ -34,7 +34,7 @@ from tunacode.core.recursive import RecursiveTaskExecutor
 from tunacode.core.state import StateManager
 from tunacode.core.token_usage.api_response_parser import ApiResponseParser
 from tunacode.core.token_usage.cost_calculator import CostCalculator
-from tunacode.exceptions import ToolBatchingJSONError
+from tunacode.exceptions import ToolBatchingJSONError, UserAbortError
 from tunacode.services.mcp import get_mcp_servers
 from tunacode.tools.bash import bash
 from tunacode.tools.glob import glob
@@ -752,300 +752,335 @@ async def process_request(
     tool_callback: Optional[ToolCallback] = None,
     streaming_callback: Optional[callable] = None,
 ) -> AgentRun:
-    agent = get_or_create_agent(model, state_manager)
-    mh = state_manager.session.messages.copy()
-    # Get max iterations from config (default: 40)
-    max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 40)
-    fallback_enabled = state_manager.session.user_config.get("settings", {}).get(
-        "fallback_response", True
-    )
+    try:
+        agent = get_or_create_agent(model, state_manager)
+        mh = state_manager.session.messages.copy()
+        # Get max iterations from config (default: 40)
+        max_iterations = state_manager.session.user_config.get("settings", {}).get(
+            "max_iterations", 40
+        )
+        fallback_enabled = state_manager.session.user_config.get("settings", {}).get(
+            "fallback_response", True
+        )
 
-    # Check if recursive execution is enabled
-    use_recursive = state_manager.session.user_config.get("settings", {}).get(
-        "use_recursive_execution", True
-    )
-    recursive_threshold = state_manager.session.user_config.get("settings", {}).get(
-        "recursive_complexity_threshold", 0.7
-    )
+        # Check if recursive execution is enabled
+        use_recursive = state_manager.session.user_config.get("settings", {}).get(
+            "use_recursive_execution", True
+        )
+        recursive_threshold = state_manager.session.user_config.get("settings", {}).get(
+            "recursive_complexity_threshold", 0.7
+        )
 
-    # Check if recursive execution should be used
-    if use_recursive and state_manager.session.current_recursion_depth == 0:
-        try:
-            # Initialize recursive executor
-            recursive_executor = RecursiveTaskExecutor(
-                state_manager=state_manager,
-                max_depth=state_manager.session.max_recursion_depth,
-                min_complexity_threshold=recursive_threshold,
-                default_iteration_budget=max_iterations,
-            )
+        # Check if recursive execution should be used
+        if use_recursive and state_manager.session.current_recursion_depth == 0:
+            try:
+                # Initialize recursive executor
+                recursive_executor = RecursiveTaskExecutor(
+                    state_manager=state_manager,
+                    max_depth=state_manager.session.max_recursion_depth,
+                    min_complexity_threshold=recursive_threshold,
+                    default_iteration_budget=max_iterations,
+                )
+
+                # Analyze task complexity
+                complexity_result = await recursive_executor.decomposer.analyze_and_decompose(
+                    message
+                )
 
-            # Analyze task complexity
-            complexity_result = await recursive_executor.decomposer.analyze_and_decompose(message)
+                if (
+                    complexity_result.should_decompose
+                    and complexity_result.total_complexity >= recursive_threshold
+                ):
+                    if state_manager.session.show_thoughts:
+                        from tunacode.ui import console as ui
 
-            if (
-                complexity_result.should_decompose
-                and complexity_result.total_complexity >= recursive_threshold
-            ):
-                if state_manager.session.show_thoughts:
-                    from tunacode.ui import console as ui
+                        await ui.muted(
+                            f"\n🔄 RECURSIVE EXECUTION: Task complexity {complexity_result.total_complexity:.2f} >= {recursive_threshold}"
+                        )
+                        await ui.muted(f"Reasoning: {complexity_result.reasoning}")
+                        await ui.muted(f"Subtasks: {len(complexity_result.subtasks)}")
 
-                    await ui.muted(
-                        f"\n🔄 RECURSIVE EXECUTION: Task complexity {complexity_result.total_complexity:.2f} >= {recursive_threshold}"
+                    # Execute recursively
+                    success, result, error = await recursive_executor.execute_task(
+                        request=message, parent_task_id=None, depth=0
                     )
-                    await ui.muted(f"Reasoning: {complexity_result.reasoning}")
-                    await ui.muted(f"Subtasks: {len(complexity_result.subtasks)}")
 
-                # Execute recursively
-                success, result, error = await recursive_executor.execute_task(
-                    request=message, parent_task_id=None, depth=0
-                )
+                    # For now, fall back to normal execution
+                    # TODO: Properly integrate recursive execution results
+                    pass
+            except Exception as e:
+                logger.warning(f"Recursive execution failed, falling back to normal: {e}")
+                # Continue with normal execution
 
-                # For now, fall back to normal execution
-                # TODO: Properly integrate recursive execution results
-                pass
-        except Exception as e:
-            logger.warning(f"Recursive execution failed, falling back to normal: {e}")
-            # Continue with normal execution
-
-    from tunacode.configuration.models import ModelRegistry
-    from tunacode.core.token_usage.usage_tracker import UsageTracker
-
-    parser = ApiResponseParser()
-    registry = ModelRegistry()
-    calculator = CostCalculator(registry)
-    usage_tracker = UsageTracker(parser, calculator, state_manager)
-    response_state = ResponseState()
-
-    # Reset iteration tracking for this request
-    state_manager.session.iteration_count = 0
-
-    # Create a request-level buffer for batching read-only tools across nodes
-    tool_buffer = ToolBuffer()
-
-    # Show TUNACODE.md preview if it was loaded and thoughts are enabled
-    if state_manager.session.show_thoughts and hasattr(state_manager, "tunacode_preview"):
-        from tunacode.ui import console as ui
-
-        await ui.muted(state_manager.tunacode_preview)
-        # Clear the preview after displaying it once
-        delattr(state_manager, "tunacode_preview")
-
-    # Show what we're sending to the API when thoughts are enabled
-    if state_manager.session.show_thoughts:
-        from tunacode.ui import console as ui
-
-        await ui.muted("\n" + "=" * 60)
-        await ui.muted("📤 SENDING TO API:")
-        await ui.muted(f"Message: {message}")
-        await ui.muted(f"Model: {model}")
-        await ui.muted(f"Message History Length: {len(mh)}")
-        await ui.muted("=" * 60)
-
-    async with agent.iter(message, message_history=mh) as agent_run:
-        i = 0
-        async for node in agent_run:
-            state_manager.session.current_iteration = i + 1
-
-            # Handle token-level streaming for model request nodes
-            if streaming_callback and STREAMING_AVAILABLE and Agent.is_model_request_node(node):
-                async with node.stream(agent_run.ctx) as request_stream:
-                    async for event in request_stream:
-                        if isinstance(event, PartDeltaEvent) and isinstance(
-                            event.delta, TextPartDelta
-                        ):
-                            # Stream individual token deltas
-                            if event.delta.content_delta:
-                                await streaming_callback(event.delta.content_delta)
-
-            await _process_node(
-                node,
-                tool_callback,
-                state_manager,
-                tool_buffer,
-                streaming_callback,
-                usage_tracker,
-            )
-            if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
-                if node.result.output:
-                    response_state.has_user_response = True
-            i += 1
-            state_manager.session.iteration_count = i
+        from tunacode.configuration.models import ModelRegistry
+        from tunacode.core.token_usage.usage_tracker import UsageTracker
 
-            # Display iteration progress if thoughts are enabled
-            if state_manager.session.show_thoughts:
-                from tunacode.ui import console as ui
+        parser = ApiResponseParser()
+        registry = ModelRegistry()
+        calculator = CostCalculator(registry)
+        usage_tracker = UsageTracker(parser, calculator, state_manager)
+        response_state = ResponseState()
 
-                await ui.muted(f"\nITERATION: {i}/{max_iterations}")
+        # Reset iteration tracking for this request
+        state_manager.session.iteration_count = 0
 
-                # Show summary of tools used so far
-                if state_manager.session.tool_calls:
-                    tool_summary = {}
-                    for tc in state_manager.session.tool_calls:
-                        tool_name = tc.get("tool", "unknown")
-                        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
+        # Create a request-level buffer for batching read-only tools across nodes
+        tool_buffer = ToolBuffer()
 
-                    summary_str = ", ".join(
-                        [f"{name}: {count}" for name, count in tool_summary.items()]
-                    )
-                    await ui.muted(f"TOOLS USED: {summary_str}")
+        # Show TUNACODE.md preview if it was loaded and thoughts are enabled
+        if state_manager.session.show_thoughts and hasattr(state_manager, "tunacode_preview"):
+            from tunacode.ui import console as ui
+
+            await ui.muted(state_manager.tunacode_preview)
+            # Clear the preview after displaying it once
+            delattr(state_manager, "tunacode_preview")
+
+        # Show what we're sending to the API when thoughts are enabled
+        if state_manager.session.show_thoughts:
+            from tunacode.ui import console as ui
+
+            await ui.muted("\n" + "=" * 60)
+            await ui.muted("📤 SENDING TO API:")
+            await ui.muted(f"Message: {message}")
+            await ui.muted(f"Model: {model}")
+            await ui.muted(f"Message History Length: {len(mh)}")
+            await ui.muted("=" * 60)
+
+        async with agent.iter(message, message_history=mh) as agent_run:
+            i = 0
+            async for node in agent_run:
+                state_manager.session.current_iteration = i + 1
+
+                # Handle token-level streaming for model request nodes
+                if streaming_callback and STREAMING_AVAILABLE and Agent.is_model_request_node(node):
+                    async with node.stream(agent_run.ctx) as request_stream:
+                        async for event in request_stream:
+                            if isinstance(event, PartDeltaEvent) and isinstance(
+                                event.delta, TextPartDelta
+                            ):
+                                # Stream individual token deltas
+                                if event.delta.content_delta:
+                                    await streaming_callback(event.delta.content_delta)
+
+                await _process_node(
+                    node,
+                    tool_callback,
+                    state_manager,
+                    tool_buffer,
+                    streaming_callback,
+                    usage_tracker,
+                )
+                if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
+                    if node.result.output:
+                        response_state.has_user_response = True
+                i += 1
+                state_manager.session.iteration_count = i
 
-            if i >= max_iterations:
+                # Display iteration progress if thoughts are enabled
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
 
-                    await ui.warning(f"Reached maximum iterations ({max_iterations})")
-                break
+                    await ui.muted(f"\nITERATION: {i}/{max_iterations}")
 
-        # Final flush: execute any remaining buffered read-only tools
-        if tool_callback and tool_buffer.has_tasks():
-            import time
+                    # Show summary of tools used so far
+                    if state_manager.session.tool_calls:
+                        tool_summary = {}
+                        for tc in state_manager.session.tool_calls:
+                            tool_name = tc.get("tool", "unknown")
+                            tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
 
-            from tunacode.ui import console as ui
-
-            buffered_tasks = tool_buffer.flush()
-            start_time = time.time()
+                        summary_str = ", ".join(
+                            [f"{name}: {count}" for name, count in tool_summary.items()]
+                        )
+                        await ui.muted(f"TOOLS USED: {summary_str}")
 
-            if state_manager.session.show_thoughts:
-                await ui.muted("\n" + "=" * 60)
-                await ui.muted(
-                    f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
-                )
-                await ui.muted("=" * 60)
+                if i >= max_iterations:
+                    if state_manager.session.show_thoughts:
+                        from tunacode.ui import console as ui
 
-                for idx, (part, node) in enumerate(buffered_tasks, 1):
-                    tool_desc = f"  [{idx}] {part.tool_name}"
-                    if hasattr(part, "args") and isinstance(part.args, dict):
-                        if part.tool_name == "read_file" and "file_path" in part.args:
-                            tool_desc += f" → {part.args['file_path']}"
-                        elif part.tool_name == "grep" and "pattern" in part.args:
-                            tool_desc += f" → pattern: '{part.args['pattern']}'"
-                            if "include_files" in part.args:
-                                tool_desc += f", files: '{part.args['include_files']}'"
-                        elif part.tool_name == "list_dir" and "directory" in part.args:
-                            tool_desc += f" → {part.args['directory']}"
-                        elif part.tool_name == "glob" and "pattern" in part.args:
-                            tool_desc += f" → pattern: '{part.args['pattern']}'"
-                    await ui.muted(tool_desc)
-                await ui.muted("=" * 60)
+                        await ui.warning(f"Reached maximum iterations ({max_iterations})")
+                    break
 
-            await execute_tools_parallel(buffered_tasks, tool_callback)
+            # Final flush: execute any remaining buffered read-only tools
+            if tool_callback and tool_buffer.has_tasks():
+                import time
 
-            elapsed_time = (time.time() - start_time) * 1000
-            sequential_estimate = len(buffered_tasks) * 100
-            speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
+                from tunacode.ui import console as ui
 
-            if state_manager.session.show_thoughts:
-                await ui.muted(
-                    f"✅ Final batch completed in {elapsed_time:.0f}ms "
-                    f"(~{speedup:.1f}x faster than sequential)\n"
-                )
+                buffered_tasks = tool_buffer.flush()
+                start_time = time.time()
 
-        # If we need to add a fallback response, create a wrapper
-        if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
-            patch_tool_messages("Task incomplete", state_manager=state_manager)
-            response_state.has_final_synthesis = True
-
-            # Extract context from the agent run
-            tool_calls_summary = []
-            files_modified = set()
-            commands_run = []
-
-            # Analyze message history for context
-            for msg in state_manager.session.messages:
-                if hasattr(msg, "parts"):
-                    for part in msg.parts:
-                        if hasattr(part, "part_kind") and part.part_kind == "tool-call":
-                            tool_name = getattr(part, "tool_name", "unknown")
-                            tool_calls_summary.append(tool_name)
-
-                            # Track specific operations
-                            if tool_name in ["write_file", "update_file"] and hasattr(part, "args"):
-                                if isinstance(part.args, dict) and "file_path" in part.args:
-                                    files_modified.add(part.args["file_path"])
-                            elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
-                                if isinstance(part.args, dict) and "command" in part.args:
-                                    commands_run.append(part.args["command"])
-
-            # Build fallback response with context
-            fallback = FallbackResponse(
-                summary="Reached maximum iterations without producing a final response.",
-                progress=f"Completed {i} iterations (limit: {max_iterations})",
-            )
+                if state_manager.session.show_thoughts:
+                    await ui.muted("\n" + "=" * 60)
+                    await ui.muted(
+                        f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
+                    )
+                    await ui.muted("=" * 60)
 
-            # Get verbosity setting
-            verbosity = state_manager.session.user_config.get("settings", {}).get(
-                "fallback_verbosity", "normal"
-            )
+                    for idx, (part, node) in enumerate(buffered_tasks, 1):
+                        tool_desc = f"  [{idx}] {part.tool_name}"
+                        if hasattr(part, "args") and isinstance(part.args, dict):
+                            if part.tool_name == "read_file" and "file_path" in part.args:
+                                tool_desc += f" → {part.args['file_path']}"
+                            elif part.tool_name == "grep" and "pattern" in part.args:
+                                tool_desc += f" → pattern: '{part.args['pattern']}'"
+                                if "include_files" in part.args:
+                                    tool_desc += f", files: '{part.args['include_files']}'"
+                            elif part.tool_name == "list_dir" and "directory" in part.args:
+                                tool_desc += f" → {part.args['directory']}"
+                            elif part.tool_name == "glob" and "pattern" in part.args:
+                                tool_desc += f" → pattern: '{part.args['pattern']}'"
+                        await ui.muted(tool_desc)
+                    await ui.muted("=" * 60)
 
-            if verbosity in ["normal", "detailed"]:
-                # Add what was attempted
-                if tool_calls_summary:
-                    tool_counts = {}
-                    for tool in tool_calls_summary:
-                        tool_counts[tool] = tool_counts.get(tool, 0) + 1
-
-                    fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
-                    for tool, count in sorted(tool_counts.items()):
-                        fallback.issues.append(f"  • {tool}: {count}x")
-
-                if verbosity == "detailed":
-                    if files_modified:
-                        fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
-                        for f in sorted(files_modified)[:5]:  # Limit to 5 files
-                            fallback.issues.append(f"  • {f}")
-                        if len(files_modified) > 5:
-                            fallback.issues.append(f"  • ... and {len(files_modified) - 5} more")
-
-                    if commands_run:
-                        fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
-                        for cmd in commands_run[:3]:  # Limit to 3 commands
-                            # Truncate long commands
-                            display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
-                            fallback.issues.append(f"  • {display_cmd}")
-                        if len(commands_run) > 3:
-                            fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
-
-            # Add helpful next steps
-            fallback.next_steps.append(
-                "The task may be too complex - try breaking it into smaller steps"
-            )
-            fallback.next_steps.append("Check the output above for any errors or partial progress")
-            if files_modified:
-                fallback.next_steps.append("Review modified files to see what changes were made")
+                await execute_tools_parallel(buffered_tasks, tool_callback)
 
-            # Create comprehensive output
-            output_parts = [fallback.summary, ""]
+                elapsed_time = (time.time() - start_time) * 1000
+                sequential_estimate = len(buffered_tasks) * 100
+                speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-            if fallback.progress:
-                output_parts.append(f"Progress: {fallback.progress}")
+                if state_manager.session.show_thoughts:
+                    await ui.muted(
+                        f"✅ Final batch completed in {elapsed_time:.0f}ms "
+                        f"(~{speedup:.1f}x faster than sequential)\n"
+                    )
 
-            if fallback.issues:
-                output_parts.append("\nWhat happened:")
-                output_parts.extend(fallback.issues)
+            # If we need to add a fallback response, create a wrapper
+            if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
+                patch_tool_messages("Task incomplete", state_manager=state_manager)
+                response_state.has_final_synthesis = True
+
+                # Extract context from the agent run
+                tool_calls_summary = []
+                files_modified = set()
+                commands_run = []
+
+                # Analyze message history for context
+                for msg in state_manager.session.messages:
+                    if hasattr(msg, "parts"):
+                        for part in msg.parts:
+                            if hasattr(part, "part_kind") and part.part_kind == "tool-call":
+                                tool_name = getattr(part, "tool_name", "unknown")
+                                tool_calls_summary.append(tool_name)
+
+                                # Track specific operations
+                                if tool_name in ["write_file", "update_file"] and hasattr(
+                                    part, "args"
+                                ):
+                                    if isinstance(part.args, dict) and "file_path" in part.args:
+                                        files_modified.add(part.args["file_path"])
+                                elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
+                                    if isinstance(part.args, dict) and "command" in part.args:
+                                        commands_run.append(part.args["command"])
+
+                # Build fallback response with context
+                fallback = FallbackResponse(
+                    summary="Reached maximum iterations without producing a final response.",
+                    progress=f"Completed {i} iterations (limit: {max_iterations})",
+                )
 
-            if fallback.next_steps:
-                output_parts.append("\nSuggested next steps:")
-                for step in fallback.next_steps:
-                    output_parts.append(f"  • {step}")
+                # Get verbosity setting
+                verbosity = state_manager.session.user_config.get("settings", {}).get(
+                    "fallback_verbosity", "normal"
+                )
 
-            comprehensive_output = "\n".join(output_parts)
+                if verbosity in ["normal", "detailed"]:
+                    # Add what was attempted
+                    if tool_calls_summary:
+                        tool_counts = {}
+                        for tool in tool_calls_summary:
+                            tool_counts[tool] = tool_counts.get(tool, 0) + 1
+
+                        fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
+                        for tool, count in sorted(tool_counts.items()):
+                            fallback.issues.append(f"  • {tool}: {count}x")
+
+                    if verbosity == "detailed":
+                        if files_modified:
+                            fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
+                            for f in sorted(files_modified)[:5]:  # Limit to 5 files
+                                fallback.issues.append(f"  • {f}")
+                            if len(files_modified) > 5:
+                                fallback.issues.append(
+                                    f"  • ... and {len(files_modified) - 5} more"
+                                )
+
+                        if commands_run:
+                            fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
+                            for cmd in commands_run[:3]:  # Limit to 3 commands
+                                # Truncate long commands
+                                display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
+                                fallback.issues.append(f"  • {display_cmd}")
+                            if len(commands_run) > 3:
+                                fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
+
+                # Add helpful next steps
+                fallback.next_steps.append(
+                    "The task may be too complex - try breaking it into smaller steps"
+                )
+                fallback.next_steps.append(
+                    "Check the output above for any errors or partial progress"
+                )
+                if files_modified:
+                    fallback.next_steps.append(
+                        "Review modified files to see what changes were made"
+                    )
 
-            # Create a wrapper object that mimics AgentRun with the required attributes
-            class AgentRunWrapper:
-                def __init__(self, wrapped_run, fallback_result):
+                # Create comprehensive output
+                output_parts = [fallback.summary, ""]
+
+                if fallback.progress:
+                    output_parts.append(f"Progress: {fallback.progress}")
+
+                if fallback.issues:
+                    output_parts.append("\nWhat happened:")
+                    output_parts.extend(fallback.issues)
+
+                if fallback.next_steps:
+                    output_parts.append("\nSuggested next steps:")
+                    for step in fallback.next_steps:
+                        output_parts.append(f"  • {step}")
+
+                comprehensive_output = "\n".join(output_parts)
+
+                # Create a wrapper object that mimics AgentRun with the required attributes
+                class AgentRunWrapper:
+                    def __init__(self, wrapped_run, fallback_result):
+                        self._wrapped = wrapped_run
+                        self._result = fallback_result
+                        self.response_state = response_state
+
+                    def __getattribute__(self, name):
+                        # Handle special attributes first to avoid conflicts
+                        if name in ["_wrapped", "_result", "response_state"]:
+                            return object.__getattribute__(self, name)
+
+                        # Explicitly handle 'result' to return our fallback result
+                        if name == "result":
+                            return object.__getattribute__(self, "_result")
+
+                        # Delegate all other attributes to the wrapped object
+                        try:
+                            return getattr(object.__getattribute__(self, "_wrapped"), name)
+                        except AttributeError:
+                            raise AttributeError(
+                                f"'{type(self).__name__}' object has no attribute '{name}'"
+                            )
+
+                return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
+
+            # For non-fallback cases, we still need to handle the response_state
+            # Create a minimal wrapper just to add response_state
+            class AgentRunWithState:
+                def __init__(self, wrapped_run):
                     self._wrapped = wrapped_run
-                    self._result = fallback_result
                     self.response_state = response_state
 
                 def __getattribute__(self, name):
-                    # Handle special attributes first to avoid conflicts
-                    if name in ["_wrapped", "_result", "response_state"]:
+                    # Handle special attributes first
+                    if name in ["_wrapped", "response_state"]:
                         return object.__getattribute__(self, name)
 
-                    # Explicitly handle 'result' to return our fallback result
-                    if name == "result":
-                        return object.__getattribute__(self, "_result")
-
                     # Delegate all other attributes to the wrapped object
                     try:
                         return getattr(object.__getattribute__(self, "_wrapped"), name)
@@ -1054,26 +1089,6 @@ async def process_request(
                             f"'{type(self).__name__}' object has no attribute '{name}'"
                         )
 
-            return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
-
-        # For non-fallback cases, we still need to handle the response_state
-        # Create a minimal wrapper just to add response_state
-        class AgentRunWithState:
-            def __init__(self, wrapped_run):
-                self._wrapped = wrapped_run
-                self.response_state = response_state
-
-            def __getattribute__(self, name):
-                # Handle special attributes first
-                if name in ["_wrapped", "response_state"]:
-                    return object.__getattribute__(self, name)
-
-                # Delegate all other attributes to the wrapped object
-                try:
-                    return getattr(object.__getattribute__(self, "_wrapped"), name)
-                except AttributeError:
-                    raise AttributeError(
-                        f"'{type(self).__name__}' object has no attribute '{name}'"
-                    )
-
-        return AgentRunWithState(agent_run)
+            return AgentRunWithState(agent_run)
+    except asyncio.CancelledError:
+        raise UserAbortError("User aborted the request.")

tunacode/core/token_usage/cost_calculator.py

@@ -49,6 +49,14 @@ class CostCalculator:
 
         pricing = model_config.pricing
 
+        # Safety check for None pricing
+        if not pricing:
+            return 0.0
+
+        # Safety check for None pricing attributes
+        if pricing.input is None or pricing.output is None:
+            return 0.0
+
         input_cost = (prompt_tokens / TOKENS_PER_MILLION) * pricing.input
 
         output_cost = (completion_tokens / TOKENS_PER_MILLION) * pricing.output

tunacode/core/token_usage/usage_tracker.py

@@ -60,18 +60,27 @@ class UsageTracker(UsageTrackerProtocol):
             if not api_model_name.startswith(provider_prefix + ":"):
                 final_model_name = f"{provider_prefix}:{api_model_name}"
 
-        return self.calculator.calculate_cost(
+        cost = self.calculator.calculate_cost(
             prompt_tokens=parsed_data.get("prompt_tokens", 0),
             completion_tokens=parsed_data.get("completion_tokens", 0),
             model_name=final_model_name,
         )
 
+        # Ensure cost is never None
+        return cost if cost is not None else 0.0
+
     def _update_state(self, parsed_data: dict, cost: float):
         """Updates the last_call and session_total usage in the state."""
         session = self.state_manager.session
         prompt_tokens = parsed_data.get("prompt_tokens", 0)
         completion_tokens = parsed_data.get("completion_tokens", 0)
 
+        # Initialize usage dicts if they're None
+        if session.last_call_usage is None:
+            session.last_call_usage = {"prompt_tokens": 0, "completion_tokens": 0, "cost": 0.0}
+        if session.session_total_usage is None:
+            session.session_total_usage = {"prompt_tokens": 0, "completion_tokens": 0, "cost": 0.0}
+
         # Update last call usage
         session.last_call_usage["prompt_tokens"] = prompt_tokens
         session.last_call_usage["completion_tokens"] = completion_tokens
@@ -85,6 +94,13 @@ class UsageTracker(UsageTrackerProtocol):
     async def _display_summary(self):
         """Formats and prints the usage summary to the console."""
         session = self.state_manager.session
+
+        # Initialize usage dicts if they're None
+        if session.last_call_usage is None:
+            session.last_call_usage = {"prompt_tokens": 0, "completion_tokens": 0, "cost": 0.0}
+        if session.session_total_usage is None:
+            session.session_total_usage = {"prompt_tokens": 0, "completion_tokens": 0, "cost": 0.0}
+
         prompt = session.last_call_usage["prompt_tokens"]
         completion = session.last_call_usage["completion_tokens"]
         last_cost = session.last_call_usage["cost"]

tunacode/ui/input.py

@@ -75,12 +75,13 @@ async def multiline_input(
     state_manager: Optional[StateManager] = None, command_registry=None
 ) -> str:
     """Get multiline input from the user with @file completion and highlighting."""
-    kb = create_key_bindings()
+    kb = create_key_bindings(state_manager)
     placeholder = formatted_text(
         (
             "<darkgrey>"
             "<bold>Enter</bold> to submit • "
             "<bold>Esc + Enter</bold> for new line • "
+            "<bold>Esc</bold> to cancel • "
             "<bold>/help</bold> for commands"
             "</darkgrey>"
         )

tunacode/ui/keybindings.py

@@ -1,9 +1,15 @@
 """Key binding handlers for TunaCode UI."""
 
+import logging
+
 from prompt_toolkit.key_binding import KeyBindings
 
+from ..core.state import StateManager
+
+logger = logging.getLogger(__name__)
 
-def create_key_bindings() -> KeyBindings:
+
+def create_key_bindings(state_manager: StateManager = None) -> KeyBindings:
     """Create and configure key bindings for the UI."""
     kb = KeyBindings()
 
@@ -22,4 +28,14 @@ def create_key_bindings() -> KeyBindings:
         """Insert a newline when escape then enter is pressed."""
         event.current_buffer.insert_text("\n")
 
+    @kb.add("escape")
+    def _escape(event):
+        """Immediately interrupts the current operation."""
+        current_task = state_manager.session.current_task if state_manager else None
+        if current_task and not current_task.done():
+            logger.debug("Interrupting current task")
+            current_task.cancel()
+        else:
+            logger.debug("Escape key pressed outside task context")
+
     return kb

{tunacode_cli-0.0.45.dist-info → tunacode_cli-0.0.47.dist-info}/METADATA

@@ -1,11 +1,13 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.45
+Version: 0.0.47
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/larock22/tunacode
-Project-URL: Repository, https://github.com/larock22/tunacode
+License: MIT
+Project-URL: Homepage, https://tunacode.xyz/
+Project-URL: Repository, https://github.com/alchemiststudiosDOTai/tunacode
+Project-URL: Issues, https://github.com/alchemiststudiosDOTai/tunacode/issues
+Project-URL: Documentation, https://github.com/alchemiststudiosDOTai/tunacode#readme
 Keywords: cli,agent,development,automation
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -16,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer==0.15.3
@@ -46,7 +48,7 @@ Dynamic: license-file
 
 **AI-powered CLI coding assistant**
 
-![Demo](docs/assets/demo.gif)
+![TunaCode Example](assets/tunacode_example.png)
 
 </div>
 
@@ -62,6 +64,29 @@ wget -qO- https://raw.githubusercontent.com/alchemiststudiosDOTai/tunacode/maste
 pip install tunacode-cli
 ```
 
+## Development Installation
+
+For contributors and developers who want to work on TunaCode:
+
+```bash
+# Clone the repository
+git clone https://github.com/alchemiststudiosDOTai/tunacode.git
+cd tunacode
+
+# Quick setup (recommended)
+./scripts/setup_dev_env.sh
+
+# Or manual setup
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -e ".[dev]"
+
+# Verify installation
+python -m tunacode --version
+```
+
+See [Development Guide](docs/DEVELOPMENT.md) for detailed instructions.
+
 ## Configuration
 
 Choose your AI provider and set your API key:
@@ -139,6 +164,7 @@ _Note: While the tool is fully functional, we're focusing on stability and core
 - [**Advanced Configuration**](docs/ADVANCED-CONFIG.md) - Provider setup, MCP, customization
 - [**Architecture**](docs/ARCHITECTURE.md) - Source code organization and design
 - [**Development**](docs/DEVELOPMENT.md) - Contributing and development setup
+- [**Troubleshooting**](docs/TROUBLESHOOTING.md) - Common issues and solutions
 
 ## Links
 

{tunacode_cli-0.0.45.dist-info → tunacode_cli-0.0.47.dist-info}/RECORD

@@ -1,5 +1,5 @@
 tunacode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/constants.py,sha256=RivEbBYCMFVkeAO8WwknYut7dIRzAbDjtpVIWMYhdS8,5168
+tunacode/constants.py,sha256=833fgfAmkcJmU1RmSYDhGCOzoU-eUMdgbcfBBwUQOZ4,5168
 tunacode/context.py,sha256=_gXVCyjU052jlyRAl9tklZSwl5U_zI_EIX8XN87VVWE,2786
 tunacode/exceptions.py,sha256=oDO1SVKOgjcKIylwqdbqh_g5my4roU5mB9Nv4n_Vb0s,3877
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -7,7 +7,7 @@ tunacode/setup.py,sha256=XPt4eAK-qcIZQv64jGZ_ryxcImDwps9OmXjJfIS1xcs,1899
 tunacode/types.py,sha256=Czq7jYXHq7fZQtyqkCN5_7eEu1wyYUcB50C6v3sTWDw,8188
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
 tunacode/cli/main.py,sha256=erP6jNXcxVQOVn8sm6uNaLEAYevniVXl6Sem872mW68,2755
-tunacode/cli/repl.py,sha256=58UJbKUcKCd1D1x0uOA5ipudZiiYOr-NXuJ6RmEn5_w,18962
+tunacode/cli/repl.py,sha256=rSsUievdOdTkxzHNIEgUHbuWbk0ki78743Wz5hVFe9s,18917
 tunacode/cli/commands/__init__.py,sha256=zmE9JcJ9Qd2xJhgdS4jMDJOoZsrAZmL5MAFxbKkk7F8,1670
 tunacode/cli/commands/base.py,sha256=GxUuDsDSpz0iXryy8MrEw88UM3C3yxL__kDK1QhshoA,2517
 tunacode/cli/commands/registry.py,sha256=XVuLpp5S4Fw7GfIZfLrVZFo4jMLMNmYNpYN7xWgXyOk,8223
@@ -27,7 +27,7 @@ tunacode/core/code_index.py,sha256=jgAx3lSWP_DwnyiP5Jkm1YvX4JJyI4teMzlNrJSpEOA,1
 tunacode/core/state.py,sha256=2lsDgq0uIIc_MnXPE9SG_1fYFBDWWlgqgqm2Ik1iFBs,5599
 tunacode/core/tool_handler.py,sha256=BPjR013OOO0cLXPdLeL2FDK0ixUwOYu59FfHdcdFhp4,2277
 tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
-tunacode/core/agents/main.py,sha256=jaEGGyqlBdu_GWGAQSIz0jUMkBxUebcgza4VrlrdQls,45967
+tunacode/core/agents/main.py,sha256=BRy3joJnn4GpUW47PyhiKK1JLMSamlK7wDMLwAGzSG0,47441
 tunacode/core/agents/utils.py,sha256=7kJAiUlkyWO3-b4T07XsGgycVrcNhv3NEPLdaktBnP4,12847
 tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/background/manager.py,sha256=rJdl3eDLTQwjbT7VhxXcJbZopCNR3M8ZGMbmeVnwwMc,1126
@@ -46,8 +46,8 @@ tunacode/core/setup/coordinator.py,sha256=oVTN2xIeJERXitVJpkIk9tDGLs1D1bxIRmaogJ
 tunacode/core/setup/environment_setup.py,sha256=n3IrObKEynHZSwtUJ1FddMg2C4sHz7ca42awemImV8s,2225
 tunacode/core/setup/git_safety_setup.py,sha256=CRIqrQt0QUJQRS344njty_iCqTorrDhHlXRuET7w0Tk,6714
 tunacode/core/token_usage/api_response_parser.py,sha256=CTtqGaFaxpkzkW3TEbe00QJzyRULpWN1EQxIYMleseg,1622
-tunacode/core/token_usage/cost_calculator.py,sha256=oQPMphGhqIt7NKdOg1o5Zbo59_nwFWmRJMQ30ViiCWs,1835
-tunacode/core/token_usage/usage_tracker.py,sha256=uKCpdZgmDfLauwsawSCifMu0kJE3lAnK7Sjd-0KYUgA,3894
+tunacode/core/token_usage/cost_calculator.py,sha256=RjO-O0JENBuGOrWP7QgBZlZxeXC-PAIr8tj_9p_BxOU,2058
+tunacode/core/token_usage/usage_tracker.py,sha256=kuAjUCyQkFykPy5mqsLRbKhZW298pyiCuFGn-ptBpy4,4657
 tunacode/prompts/system.md,sha256=hXpjZ8Yiv2Acr2_6EmC2uOklP8FbmvyYR9oais-1KLk,16290
 tunacode/services/__init__.py,sha256=w_E8QK6RnvKSvU866eDe8BCRV26rAm4d3R-Yg06OWCU,19
 tunacode/services/mcp.py,sha256=R48X73KQjQ9vwhBrtbWHSBl-4K99QXmbIhh5J_1Gezo,3046
@@ -68,8 +68,8 @@ tunacode/ui/completers.py,sha256=Jx1zyCESwdm_4ZopvCBtb0bCJF-bRy8aBWG2yhPQtDc,487
 tunacode/ui/console.py,sha256=icb7uYrV8XmZg9glreEy5MrvDkmrKxbf_ZkNqElN1uE,2120
 tunacode/ui/constants.py,sha256=A76B_KpM8jCuBYRg4cPmhi8_j6LLyWttO7_jjv47r3w,421
 tunacode/ui/decorators.py,sha256=e2KM-_pI5EKHa2M045IjUe4rPkTboxaKHXJT0K3461g,1914
-tunacode/ui/input.py,sha256=E_zAJqNYoAVFA-j4xE9Qgs22y-GrdSZNqiseX-Or0ho,2955
-tunacode/ui/keybindings.py,sha256=h0MlD73CW_3i2dQzb9EFSPkqy0raZ_isgjxUiA9u6ts,691
+tunacode/ui/input.py,sha256=x_7G9VVdvydpEk2kcyG-OBKND5lL5ADbiGcDXF1n5UA,3014
+tunacode/ui/keybindings.py,sha256=tn0q0eRw72j8xPWX0673Xc-vmwlvFEyuhy3C451ntfE,1233
 tunacode/ui/lexers.py,sha256=tmg4ic1enyTRLzanN5QPP7D_0n12YjX_8ZhsffzhXA4,1340
 tunacode/ui/output.py,sha256=51O0VHajte4dXHK5Az5SSP4IOb2q5SbCwvqdAoxyg7c,5665
 tunacode/ui/panels.py,sha256=dBZEVIJqliWreY-hz6HpW5rdBmPOJZ6sPrv8KQ3eNhk,8570
@@ -91,9 +91,9 @@ tunacode/utils/system.py,sha256=FSoibTIH0eybs4oNzbYyufIiV6gb77QaeY2yGqW39AY,1138
 tunacode/utils/text_utils.py,sha256=6YBD9QfkDO44-6jxnwRWIpmfIifPG-NqMzy_O2NAouc,7277
 tunacode/utils/token_counter.py,sha256=lLbkrNUraRQn5RMhwnGurqq1RHFDyn4AaFhruONWIxo,2690
 tunacode/utils/user_configuration.py,sha256=Ilz8dpGVJDBE2iLWHAPT0xR8D51VRKV3kIbsAz8Bboc,3275
-tunacode_cli-0.0.45.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.45.dist-info/METADATA,sha256=ZEVJDRAxDDjMG8DR64Hj9_Txw7h0lD9YwrhAAwft_nY,5137
-tunacode_cli-0.0.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tunacode_cli-0.0.45.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.45.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
-tunacode_cli-0.0.45.dist-info/RECORD,,
+tunacode_cli-0.0.47.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.47.dist-info/METADATA,sha256=oHfTMPtEUgbgVd7Nm0bb39wAKAuPKRHskBpZmDnBxMM,5902
+tunacode_cli-0.0.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.47.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.47.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
+tunacode_cli-0.0.47.dist-info/RECORD,,