tunacode-cli 0.0.17__py3-none-any.whl → 0.0.18__py3-none-any.whl

tunacode/cli/textual_app.py

@@ -18,10 +18,9 @@ from textual.binding import Binding
 from textual.containers import Container, Horizontal, Vertical, VerticalScroll
 from textual.message import Message
 from textual.reactive import reactive
-from textual.widgets import (
-    Button, Footer, Header, Input, Label, Markdown as MarkdownWidget, 
-    Static, TextArea, TabbedContent, TabPane
-)
+from textual.widgets import Button, Footer, Header, Input, Label
+from textual.widgets import Markdown as MarkdownWidget
+from textual.widgets import Static, TabbedContent, TabPane, TextArea
 
 from tunacode.configuration.settings import ApplicationSettings
 from tunacode.core.state import StateManager
@@ -31,52 +30,58 @@ from tunacode.utils.system import check_for_updates
 
 class ChatMessage(Static):
     """A single chat message widget."""
-    
+
     def __init__(self, sender: str, content: str, message_type: str = "user"):
         super().__init__()
         self.sender = sender
         self.content = content
         self.message_type = message_type
-        
+
     def compose(self) -> ComposeResult:
         """Compose the chat message."""
         if self.message_type == "user":
             yield Static(f"[bold cyan]❯ You[/bold cyan]\n{self.content}", classes="user-message")
         elif self.message_type == "agent":
-            yield Static(f"[bold green]🤖 TunaCode[/bold green]\n{self.content}", classes="agent-message")
+            yield Static(
+                f"[bold green]🤖 TunaCode[/bold green]\n{self.content}", classes="agent-message"
+            )
         elif self.message_type == "system":
-            yield Static(f"[bold yellow]⚠️ System[/bold yellow]\n{self.content}", classes="system-message")
+            yield Static(
+                f"[bold yellow]⚠️ System[/bold yellow]\n{self.content}", classes="system-message"
+            )
         elif self.message_type == "tool":
-            yield Static(f"[bold magenta]🔧 Tool[/bold magenta]\n{self.content}", classes="tool-message")
+            yield Static(
+                f"[bold magenta]🔧 Tool[/bold magenta]\n{self.content}", classes="tool-message"
+            )
 
 
 class Sidebar(Container):
     """Sidebar with model info and commands."""
-    
+
     def __init__(self, state_manager: StateManager):
         super().__init__()
         self.state_manager = state_manager
-    
+
     def compose(self) -> ComposeResult:
         """Compose the sidebar."""
         yield Static("[bold]TunaCode[/bold]", classes="sidebar-title")
         yield Static(f"Model: {self.state_manager.session.current_model}", id="current-model")
         yield Static("", classes="spacer")
-        
+
         yield Static("[bold]Commands[/bold]", classes="section-title")
         yield Static("/help - Show help", classes="command-item")
         yield Static("/clear - Clear chat", classes="command-item")
         yield Static("/model - Switch model", classes="command-item")
         yield Static("/yolo - Toggle confirmations", classes="command-item")
         yield Static("", classes="spacer")
-        
+
         yield Static("[bold]Status[/bold]", classes="section-title")
         yield Static("● Ready", id="status", classes="status-ready")
 
 
 class ChatHistory(VerticalScroll):
     """Scrollable chat history container."""
-    
+
     def add_message(self, sender: str, content: str, message_type: str = "user") -> None:
         """Add a new message to the chat history."""
         message = ChatMessage(sender, content, message_type)
@@ -86,20 +91,20 @@ class ChatHistory(VerticalScroll):
 
 class InputArea(Container):
     """Input area with text area and send button."""
-    
+
     class SendMessage(Message):
         """Message sent when user submits input."""
-        
+
         def __init__(self, content: str) -> None:
             self.content = content
             super().__init__()
-    
+
     def compose(self) -> ComposeResult:
         """Compose the input area."""
         with Horizontal():
             yield TextArea(id="message-input")
             yield Button("Send", id="send-button", variant="primary")
-    
+
     @on(Button.Pressed, "#send-button")
     def send_message(self) -> None:
         """Send the current message."""
@@ -108,7 +113,7 @@ class InputArea(Container):
         if content:
             self.post_message(self.SendMessage(content))
             text_area.clear()
-    
+
     def on_key(self, event) -> None:
         """Handle key events."""
         if event.key == "ctrl+enter":
@@ -117,7 +122,7 @@ class InputArea(Container):
 
 class TunaCodeApp(App):
     """Main TunaCode Textual application."""
-    
+
     CSS = """
     Sidebar {
         width: 30;
@@ -202,79 +207,75 @@ class TunaCodeApp(App):
         margin-left: 1;
     }
     """
-    
+
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit"),
         Binding("ctrl+l", "clear_chat", "Clear"),
         Binding("f1", "help", "Help"),
         Binding("f2", "model_info", "Model"),
     ]
-    
+
     def __init__(self, state_manager: StateManager):
         super().__init__()
         self.state_manager = state_manager
         self.chat_history: Optional[ChatHistory] = None
         self.sidebar: Optional[Sidebar] = None
         self.input_area: Optional[InputArea] = None
-    
+
     def compose(self) -> ComposeResult:
         """Compose the main application layout."""
         yield Header()
-        
+
         with Horizontal():
             self.sidebar = Sidebar(self.state_manager)
             yield self.sidebar
-            
+
             with Vertical():
                 self.chat_history = ChatHistory()
                 yield self.chat_history
-                
+
                 self.input_area = InputArea()
                 yield self.input_area
-        
+
         yield Footer()
-    
+
     def on_mount(self) -> None:
         """Called when the app is mounted."""
         # Add welcome messages
         self.chat_history.add_message(
-            "System", 
-            "Welcome to TunaCode v0.11 - Your AI-powered development assistant", 
-            "system"
+            "System", "Welcome to TunaCode v0.11 - Your AI-powered development assistant", "system"
         )
         self.chat_history.add_message(
-            "System",
-            f"Current model: {self.state_manager.session.current_model}",
-            "system"
+            "System", f"Current model: {self.state_manager.session.current_model}", "system"
         )
         self.chat_history.add_message(
             "System",
             "⚠️ IMPORTANT: Always use git branches before making major changes\nType '/help' for available commands",
-            "system"
+            "system",
         )
-    
+
     @on(InputArea.SendMessage)
     async def handle_message(self, message: InputArea.SendMessage) -> None:
         """Handle incoming messages from the input area."""
         content = message.content
-        
+
         # Add user message to chat
         self.chat_history.add_message("You", content, "user")
-        
+
         # Update status
         status_widget = self.sidebar.query_one("#status", Static)
         status_widget.update("● Processing...")
         status_widget.classes = "status-busy"
-        
+
         if content.startswith("/"):
             await self.handle_command(content)
         else:
             await self.handle_user_input(content)
-        
+
         # Reset status
         status_widget.update("● Ready")
         status_widget.classes = "status-ready"
-    
+
     async def handle_command(self, command: str) -> None:
         """Handle slash commands."""
         if command == "/help":
@@ -293,57 +294,58 @@ F1 - Help
 F2 - Model info
 Ctrl+Enter - Send message"""
             self.chat_history.add_message("System", help_text, "system")
-            
+
         elif command == "/clear":
             await self.action_clear_chat()
-            
+
         elif command == "/model":
             model_info = f"Current model: {self.state_manager.session.current_model}"
             self.chat_history.add_message("System", model_info, "system")
-            
+
         elif command == "/yolo":
             # Toggle yolo mode
-            current_state = getattr(self.state_manager.session, 'yolo_mode', False)
+            current_state = getattr(self.state_manager.session, "yolo_mode", False)
             self.state_manager.session.yolo_mode = not current_state
             new_state = "enabled" if not current_state else "disabled"
             self.chat_history.add_message("System", f"Confirmation prompts {new_state}", "system")
-            
+
         elif command == "/quit":
             await self.action_quit()
-            
+
         else:
             self.chat_history.add_message("System", f"Unknown command: {command}", "system")
-    
+
     async def handle_user_input(self, text: str) -> None:
         """Handle regular user input."""
         try:
             # Use the bridge to process the input
-            if not hasattr(self, '_bridge'):
+            if not hasattr(self, "_bridge"):
                 from tunacode.cli.textual_bridge import TextualAgentBridge
+
                 self._bridge = TextualAgentBridge(self.state_manager, self._bridge_message_callback)
-            
+
             # Process the request
             response = await self._bridge.process_user_input(text)
-            
+
             # Add the agent's response to chat
             self.chat_history.add_message("TunaCode", response, "agent")
-            
+
         except Exception as e:
             self.chat_history.add_message("System", f"Error: {str(e)}", "system")
-    
+
     async def _bridge_message_callback(self, message_type: str, content: str) -> None:
         """Callback for bridge to send messages to the UI."""
         self.chat_history.add_message("System", content, message_type)
-    
+
     def action_clear_chat(self) -> None:
         """Clear the chat history."""
         self.chat_history.remove_children()
         self.chat_history.add_message("System", "Chat cleared", "system")
-    
+
     def action_help(self) -> None:
         """Show help information."""
         self.handle_command("/help")
-    
+
     def action_model_info(self) -> None:
         """Show model information."""
         self.handle_command("/model")
@@ -358,29 +360,30 @@ async def run_textual_app(state_manager: StateManager) -> None:
 def main():
     """Main entry point for the Textual app."""
     import sys
-    
+
     # Handle command line arguments
     version_flag = "--version" in sys.argv or "-v" in sys.argv
     if version_flag:
         from tunacode.constants import APP_VERSION
+
         print(f"TunaCode v{APP_VERSION}")
         return
-    
+
     # Initialize state manager
     state_manager = StateManager()
     app_settings = ApplicationSettings()
-    
+
     # Show banner
     print("🐟 TunaCode - Modern AI Development Assistant")
     print("=" * 50)
-    
+
     # Check for updates
     has_update, latest_version = check_for_updates()
     if has_update:
         print(f"📦 Update available: v{latest_version}")
         print("Run: pip install --upgrade tunacode-cli")
         print()
-    
+
     # Parse CLI arguments for configuration
     cli_config = {}
     args = sys.argv[1:]
@@ -400,24 +403,24 @@ def main():
             i += 1
         else:
             i += 1
-    
+
     async def run_app():
         try:
             # Run setup
             run_setup = cli_config.get("setup", False)
             await setup(run_setup, state_manager, cli_config)
-            
+
             # Run the Textual app
             await run_textual_app(state_manager)
-            
+
         except KeyboardInterrupt:
             print("\n👋 Goodbye!")
         except Exception as e:
             print(f"❌ Error: {e}")
-    
+
     # Run the async app
     asyncio.run(run_app())
 
 
 if __name__ == "__main__":
-    main()
+    main()

tunacode/cli/textual_bridge.py

@@ -6,90 +6,89 @@ with the new Textual-based interface while maintaining compatibility.
 """
 
 import asyncio
-from typing import Callable, Optional
 from asyncio.exceptions import CancelledError
+from typing import Callable, Optional
 
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 
+from tunacode.cli.commands import CommandRegistry
+from tunacode.cli.repl import _parse_args
 from tunacode.core.agents import main as agent
 from tunacode.core.agents.main import patch_tool_messages
 from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import AgentError, UserAbortError, ValidationError
 from tunacode.types import StateManager
-from tunacode.cli.commands import CommandRegistry
-from tunacode.cli.repl import _parse_args
 from tunacode.ui.tool_ui import ToolUI
 
 
 class TextualAgentBridge:
     """Bridge between Textual UI and existing agent logic."""
-    
+
     def __init__(self, state_manager: StateManager, message_callback: Callable):
         self.state_manager = state_manager
         self.message_callback = message_callback
         self.tool_ui = ToolUI()
         self.command_registry = CommandRegistry()
         self.command_registry.register_all_default_commands()
-        
+
     async def process_user_input(self, text: str) -> str:
         """Process user input and return the agent's response."""
         if text.startswith("/"):
             return await self._handle_command(text)
         else:
             return await self._process_agent_request(text)
-    
+
     async def _handle_command(self, command: str) -> str:
         """Handle slash commands."""
         try:
             from tunacode.types import CommandContext
-            
+
             # Create command context
             context = CommandContext(
-                state_manager=self.state_manager, 
-                process_request=self._process_agent_request
+                state_manager=self.state_manager, process_request=self._process_agent_request
             )
-            
+
             # Set the process_request callback for commands that need it
             self.command_registry.set_process_request_callback(self._process_agent_request)
-            
+
             # Execute the command
             result = await self.command_registry.execute(command, context)
-            
+
             if result == "restart":
                 return "Application restart requested."
             elif result:
                 return str(result)
             else:
                 return f"Command '{command}' executed successfully."
-                
+
         except ValidationError as e:
             return f"Error: {str(e)}"
         except Exception as e:
             return f"Command error: {str(e)}"
-    
+
     async def _process_agent_request(self, text: str) -> str:
         """Process input using the agent."""
         try:
             # Expand @file references before sending to the agent
             try:
                 from tunacode.utils.text_utils import expand_file_refs
+
                 text = expand_file_refs(text)
             except ValueError as e:
                 return f"Error: {str(e)}"
-            
+
             # Notify UI about processing start
             await self.message_callback("tool", "Processing request...")
-            
+
             # Create a tool callback that integrates with Textual
             def tool_callback_with_state(part, node):
                 return self._tool_handler(part, node)
-            
+
             # Get or create agent instance
             instance = agent.get_or_create_agent(
-                self.state_manager.session.current_model, 
-                self.state_manager
+                self.state_manager.session.current_model, self.state_manager
             )
-            
+
             # Process the request
             async with instance.run_mcp_servers():
                 res = await agent.process_request(
@@ -98,12 +97,12 @@ class TextualAgentBridge:
                     self.state_manager,
                     tool_callback=tool_callback_with_state,
                 )
-                
+
                 if res and res.result:
                     return res.result.output
                 else:
                     return "Request processed (no output)."
-                    
+
         except CancelledError:
             return "Request cancelled."
         except UserAbortError:
@@ -117,29 +116,31 @@ class TextualAgentBridge:
             agent_error = AgentError(f"Agent processing failed: {str(e)}")
             agent_error.__cause__ = e
             return f"Error: {str(e)}"
-    
+
     async def _tool_handler(self, part, node):
         """Handle tool execution with Textual UI integration."""
         await self.message_callback("tool", f"Tool: {part.tool_name}")
-        
+
         try:
             # Create tool handler with state
             tool_handler = ToolHandler(self.state_manager)
             args = _parse_args(part.args)
-            
+
             # Check if confirmation is needed
             if tool_handler.should_confirm(part.tool_name):
                 # Create confirmation request
                 request = tool_handler.create_confirmation_request(part.tool_name, args)
-                
+
                 # For now, show a simple confirmation in the UI
                 # In a full implementation, this would show a proper modal dialog
-                await self.message_callback("system", f"Tool confirmation: {part.tool_name} with args: {args}")
-                
+                await self.message_callback(
+                    "system", f"Tool confirmation: {part.tool_name} with args: {args}"
+                )
+
                 # For demo purposes, auto-approve (in production, this should be interactive)
                 if not tool_handler.process_confirmation(True, part.tool_name):
                     raise UserAbortError("User aborted tool execution.")
-            
+
         except UserAbortError:
             patch_tool_messages("Operation aborted by user.", self.state_manager)
             raise
@@ -147,12 +148,12 @@ class TextualAgentBridge:
 
 class TextualToolConfirmation:
     """Handle tool confirmations in Textual UI."""
-    
+
     def __init__(self, app_instance):
         self.app = app_instance
-        
+
     async def show_confirmation(self, tool_name: str, args: dict) -> bool:
         """Show tool confirmation dialog and return user's choice."""
         # This would show a modal dialog in the Textual app
         # For now, return True (auto-approve)
-        return True
+        return True

tunacode/configuration/settings.py

@@ -7,15 +7,8 @@ Handles configuration paths, model registries, and application metadata.
 
 from pathlib import Path
 
-from tunacode.constants import (
-    APP_NAME,
-    APP_VERSION,
-    CONFIG_FILE_NAME,
-    TOOL_READ_FILE,
-    TOOL_RUN_COMMAND,
-    TOOL_UPDATE_FILE,
-    TOOL_WRITE_FILE,
-)
+from tunacode.constants import (APP_NAME, APP_VERSION, CONFIG_FILE_NAME, TOOL_READ_FILE,
+                                TOOL_RUN_COMMAND, TOOL_UPDATE_FILE, TOOL_WRITE_FILE)
 from tunacode.types import ConfigFile, ConfigPath, ToolName
 
 

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.17"
+APP_VERSION = "0.0.18"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"
@@ -101,9 +101,7 @@ ERROR_INVALID_PROVIDER = "Invalid provider number"
 ERROR_FILE_NOT_FOUND = "Error: File not found at '{filepath}'."
 ERROR_FILE_TOO_LARGE = "Error: File '{filepath}' is too large (> 100KB)."
 ERROR_FILE_DECODE = "Error reading file '{filepath}': Could not decode using UTF-8."
-ERROR_FILE_DECODE_DETAILS = (
-    "It might be a binary file or use a different encoding. {error}"
-)
+ERROR_FILE_DECODE_DETAILS = "It might be a binary file or use a different encoding. {error}"
 ERROR_COMMAND_NOT_FOUND = "Error: Command not found or failed to execute:"
 ERROR_COMMAND_EXECUTION = (
     "Error: Command not found or failed to execute: {command}. Details: {error}"

tunacode/context.py

@@ -4,8 +4,8 @@ import subprocess
 from pathlib import Path
 from typing import Dict, List
 
-from tunacode.utils.system import list_cwd
 from tunacode.utils.ripgrep import ripgrep
+from tunacode.utils.system import list_cwd
 
 
 async def get_git_status() -> Dict[str, object]: