tunacode-cli 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

tunacode/ui/completers.py

@@ -10,117 +10,54 @@ from ..cli.commands import CommandRegistry
 
 
 class CommandCompleter(Completer):
-    """Completer for slash commands and their arguments."""
-
+    """Completer for slash commands."""
+    
     def __init__(self, command_registry: Optional[CommandRegistry] = None):
         self.command_registry = command_registry
-        self._model_selector = None
-
+    
     def get_completions(
         self, document: Document, complete_event: CompleteEvent
     ) -> Iterable[Completion]:
-        """Get completions for slash commands and model names."""
+        """Get completions for slash commands."""
         # Get the text before cursor
         text = document.text_before_cursor
-
-        # Check if we're completing model names after /model or /m command
-        if self._should_complete_model_names(text):
-            yield from self._get_model_completions(document, text)
-            return
-
+        
         # Check if we're at the start of a line or after whitespace
-        if text and not text.isspace() and text[-1] != "\n":
+        if text and not text.isspace() and text[-1] != '\n':
             # Only complete commands at the start of input or after a newline
-            last_newline = text.rfind("\n")
-            line_start = text[last_newline + 1 :] if last_newline >= 0 else text  # noqa: E203
-
+            last_newline = text.rfind('\n')
+            line_start = text[last_newline + 1:] if last_newline >= 0 else text
+            
             # Skip if not at the beginning of a line
-            if line_start and not line_start.startswith("/"):
+            if line_start and not line_start.startswith('/'):
                 return
-
+        
         # Get the word before cursor
         word_before_cursor = document.get_word_before_cursor(WORD=True)
-
+        
         # Only complete if word starts with /
-        if not word_before_cursor.startswith("/"):
+        if not word_before_cursor.startswith('/'):
             return
-
+            
         # Get command names from registry
         if self.command_registry:
             command_names = self.command_registry.get_command_names()
         else:
             # Fallback list of commands
-            command_names = [
-                "/help",
-                "/clear",
-                "/dump",
-                "/yolo",
-                "/undo",
-                "/branch",
-                "/compact",
-                "/model",
-                "/m",
-                "/init",
-            ]
-
+            command_names = ['/help', '/clear', '/dump', '/yolo', '/undo', 
+                           '/branch', '/compact', '/model']
+        
         # Get the partial command (without /)
         partial = word_before_cursor[1:].lower()
-
+        
         # Yield completions for matching commands
         for cmd in command_names:
-            if cmd.startswith("/") and cmd[1:].lower().startswith(partial):
+            if cmd.startswith('/') and cmd[1:].lower().startswith(partial):
                 yield Completion(
                     text=cmd,
                     start_position=-len(word_before_cursor),
                     display=cmd,
-                    display_meta="command",
-                )
-
-    def _should_complete_model_names(self, text: str) -> bool:
-        """Check if we should complete model names."""
-        # Look for /model or /m command followed by space
-        import re
-
-        pattern = r"(?:^|\n)\s*(?:/model|/m)\s+\S*$"
-        return bool(re.search(pattern, text))
-
-    def _get_model_completions(self, document: Document, text: str) -> Iterable[Completion]:
-        """Get completions for model names."""
-        # Lazy import and cache
-        if self._model_selector is None:
-            try:
-                from ..cli.model_selector import ModelSelector
-
-                self._model_selector = ModelSelector()
-            except ImportError:
-                return
-
-        # Get the partial model name
-        word_before_cursor = document.get_word_before_cursor(WORD=True)
-        partial = word_before_cursor.lower()
-
-        # Yield model short names and indices
-        seen = set()
-        for i, model in enumerate(self._model_selector.models):
-            # Complete by index
-            index_str = str(i)
-            if index_str.startswith(partial) and index_str not in seen:
-                seen.add(index_str)
-                yield Completion(
-                    text=index_str,
-                    start_position=-len(word_before_cursor),
-                    display=f"{index_str} - {model.display_name}",
-                    display_meta=model.provider.value[2],
-                )
-
-            # Complete by short name
-            if model.short_name.lower().startswith(partial) and model.short_name not in seen:
-                seen.add(model.short_name)
-                yield Completion(
-                    text=model.short_name,
-                    start_position=-len(word_before_cursor),
-                    display=f"{model.short_name} - {model.display_name}",
-                    display_meta=model.provider.value[2],
+                    display_meta='command'
                 )
 
 
@@ -133,14 +70,14 @@ class FileReferenceCompleter(Completer):
         """Get completions for @file references."""
         # Get the word before cursor
         word_before_cursor = document.get_word_before_cursor(WORD=True)
-
+        
         # Check if we're in an @file reference
         if not word_before_cursor.startswith("@"):
             return
-
+            
         # Get the path part after @
         path_part = word_before_cursor[1:]  # Remove @
-
+        
         # Determine directory and prefix
         if "/" in path_part:
             # Path includes directory
@@ -150,18 +87,18 @@ class FileReferenceCompleter(Completer):
             # Just filename, search in current directory
             dir_path = "."
             prefix = path_part
-
+            
         # Get matching files
         try:
             if os.path.exists(dir_path) and os.path.isdir(dir_path):
                 for item in sorted(os.listdir(dir_path)):
                     if item.startswith(prefix):
                         full_path = os.path.join(dir_path, item) if dir_path != "." else item
-
+                        
                         # Skip hidden files unless explicitly requested
                         if item.startswith(".") and not prefix.startswith("."):
                             continue
-
+                            
                         # Add / for directories
                         if os.path.isdir(full_path):
                             display = item + "/"
@@ -169,15 +106,15 @@ class FileReferenceCompleter(Completer):
                         else:
                             display = item
                             completion = full_path
-
+                            
                         # Calculate how much to replace
                         start_position = -len(path_part)
-
+                        
                         yield Completion(
                             text=completion,
                             start_position=start_position,
                             display=display,
-                            display_meta="dir" if os.path.isdir(full_path) else "file",
+                            display_meta="dir" if os.path.isdir(full_path) else "file"
                         )
         except (OSError, PermissionError):
             # Silently ignore inaccessible directories
@@ -186,9 +123,7 @@ class FileReferenceCompleter(Completer):
 
 def create_completer(command_registry: Optional[CommandRegistry] = None) -> Completer:
     """Create a merged completer for both commands and file references."""
-    return merge_completers(
-        [
-            CommandCompleter(command_registry),
-            FileReferenceCompleter(),
-        ]
-    )
+    return merge_completers([
+        CommandCompleter(command_registry),
+        FileReferenceCompleter(),
+    ])

tunacode/ui/input.py

@@ -4,9 +4,10 @@ from typing import Optional
 
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
 from prompt_toolkit.validation import Validator
 
-from tunacode.constants import UI_PROMPT_PREFIX
+from tunacode.constants import UI_COLORS, UI_PROMPT_PREFIX
 from tunacode.core.state import StateManager
 
 from .completers import create_completer
@@ -32,7 +33,6 @@ async def input(
     lexer=None,
     timeoutlen: float = 0.05,
     state_manager: Optional[StateManager] = None,
-    default: str = "",
 ) -> str:
     """
     Prompt for user input using simplified prompt management.
@@ -49,7 +49,6 @@ async def input(
         lexer: Optional lexer for syntax highlighting
         timeoutlen: Timeout length for input
         state_manager: The state manager for session storage
-        default: Default value to pre-fill in the input
 
     Returns:
         User input string
@@ -64,7 +63,6 @@ async def input(
         completer=completer,
         lexer=lexer,
         timeoutlen=timeoutlen,
-        default=default,
     )
 
     # Create prompt manager
@@ -74,26 +72,24 @@ async def input(
     return await manager.get_input(session_key, pretext, config)
 
 
-async def multiline_input(
-    state_manager: Optional[StateManager] = None, command_registry=None
-) -> str:
+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()
     placeholder = formatted_text(
         (
             "<darkgrey>"
-            "<bold>Enter</bold> to submit, "
-            "<bold>Esc + Enter</bold> for new line, "
+            "<bold>Enter</bold> to submit • "
+            "<bold>Esc + Enter</bold> for new line • "
             "<bold>/help</bold> for commands"
             "</darkgrey>"
         )
     )
     return await input(
-        "multiline",
-        key_bindings=kb,
-        multiline=True,
+        "multiline", 
+        key_bindings=kb, 
+        multiline=True, 
         placeholder=placeholder,
         completer=create_completer(command_registry),
         lexer=FileReferenceLexer(),
-        state_manager=state_manager,
+        state_manager=state_manager
     )

tunacode/ui/keybindings.py

@@ -7,6 +7,8 @@ def create_key_bindings() -> KeyBindings:
     """Create and configure key bindings for the UI."""
     kb = KeyBindings()
 
+    
+
     @kb.add("enter")
     def _submit(event):
         """Submit the current buffer."""
@@ -16,7 +18,7 @@ def create_key_bindings() -> KeyBindings:
     def _newline(event):
         """Insert a newline character."""
         event.current_buffer.insert_text("\n")
-
+    
     @kb.add("escape", "enter")
     def _escape_enter(event):
         """Insert a newline when escape then enter is pressed."""

tunacode/ui/lexers.py

@@ -2,44 +2,45 @@
 
 import re
 
+from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.lexers import Lexer
 
 
 class FileReferenceLexer(Lexer):
     """Lexer that highlights @file references in light blue."""
-
+    
     # Pattern to match @file references
-    FILE_REF_PATTERN = re.compile(r"@([\w./_-]+)")
-
+    FILE_REF_PATTERN = re.compile(r'@([\w./_-]+)')
+    
     def lex_document(self, document):
         """Return a formatted text list for the given document."""
-        lines = document.text.split("\n")
-
+        lines = document.text.split('\n')
+        
         def get_line_tokens(line_number):
             """Get tokens for a specific line."""
             if line_number >= len(lines):
                 return []
-
+                
             line = lines[line_number]
             tokens = []
             last_end = 0
-
+            
             # Find all @file references in the line
             for match in self.FILE_REF_PATTERN.finditer(line):
                 start, end = match.span()
-
+                
                 # Add text before the match
                 if start > last_end:
-                    tokens.append(("", line[last_end:start]))
-
+                    tokens.append(('', line[last_end:start]))
+                
                 # Add the @file reference with styling
-                tokens.append(("class:file-reference", match.group(0)))
+                tokens.append(('class:file-reference', match.group(0)))
                 last_end = end
-
+            
             # Add remaining text
             if last_end < len(line):
-                tokens.append(("", line[last_end:]))
-
+                tokens.append(('', line[last_end:]))
+                
             return tokens
-
-        return get_line_tokens
+        
+        return get_line_tokens

tunacode/ui/output.py

@@ -16,15 +16,9 @@ from .decorators import create_sync_wrapper
 console = Console()
 colors = DotDict(UI_COLORS)
 
-BANNER = (
-    "[bold #00d7ff]┌─────────────────────────────────────────────────────────────────┐"
-    "[/bold #00d7ff]\n"
-    "[bold #00d7ff]│[/bold #00d7ff] [bold white]T U N A C O D E[/bold white] "
-    "[dim #64748b]• Agentic AI Development Environment[/dim #64748b] "
-    "[bold #00d7ff]│[/bold #00d7ff]\n"
-    "[bold #00d7ff]└─────────────────────────────────────────────────────────────────┘"
-    "[/bold #00d7ff]"
-)
+BANNER = """[bold #00d7ff]╭─────────────────────────────────────────────────────────────────╮[/bold #00d7ff]
+[bold #00d7ff]│[/bold #00d7ff] [bold white]T U N A C O D E[/bold white] [dim #64748b]• Agentic AI Development Environment[/dim #64748b] [bold #00d7ff]│[/bold #00d7ff]
+[bold #00d7ff]╰─────────────────────────────────────────────────────────────────╯[/bold #00d7ff]"""
 
 
 @create_sync_wrapper
@@ -34,8 +28,8 @@ async def print(message, **kwargs) -> None:
 
 
 async def line() -> None:
-    """Print a line to the console."""
-    await run_in_terminal(lambda: console.line())
+    """Print an empty line for spacing."""
+    await print("")
 
 
 async def info(text: str) -> None:
@@ -53,9 +47,9 @@ async def warning(text: str) -> None:
     await print(f"[{colors.warning}]⚠[/{colors.warning}] {text}")
 
 
-async def muted(text: str, spaces: int = 0) -> None:
-    """Print a muted message."""
-    await print(f"{' ' * spaces}[{colors.muted}]•[/{colors.muted}] [dim]{text}[/dim]")
+async def muted(text: str) -> None:
+    """Print muted text."""
+    await print(text, style=colors.muted)
 
 
 async def usage(usage: str) -> None:

tunacode/ui/panels.py

@@ -2,6 +2,7 @@
 
 from typing import Any, Optional, Union
 
+from rich.box import ROUNDED
 from rich.markdown import Markdown
 from rich.padding import Padding
 from rich.panel import Panel
@@ -38,11 +39,12 @@ async def panel(
     """Display a rich panel with modern styling."""
     border_style = border_style or kwargs.get("style") or colors.border
     panel_obj = Panel(
-        Padding(text, (0, 1, 0, 1)),
-        title=f"[bold]{title}[/bold]",
-        title_align="left",
+        Padding(text, (0, 1, 0, 1)), 
+        title=f"[bold]{title}[/bold]", 
+        title_align="left", 
         border_style=border_style,
         padding=(0, 1),
+        box=ROUNDED  # Use ROUNDED box style
     )
     await print(Padding(panel_obj, (top, right, bottom, left)), **kwargs)
 
@@ -83,8 +85,8 @@ async def models(state_manager: StateManager = None) -> None:
 
 async def help(command_registry=None) -> None:
     """Display the available commands organized by category."""
-    table = Table(show_header=False, box=None, padding=(0, 3, 0, 0))
-    table.add_column("Command", style=f"bold {colors.primary}", justify="right", min_width=16)
+    table = Table(show_header=False, box=None, padding=(0, 2, 0, 0))
+    table.add_column("Command", style=f"bold {colors.primary}", justify="right", min_width=18)
     table.add_column("Description", style=colors.muted)
 
     if command_registry:

tunacode/ui/prompt_manager.py

@@ -28,7 +28,6 @@ class PromptConfig:
     completer: Optional[Completer] = None
     lexer: Optional[Lexer] = None
     timeoutlen: float = 0.05
-    default: str = ""
 
 
 class PromptManager:
@@ -43,14 +42,12 @@ class PromptManager:
         self.state_manager = state_manager
         self._temp_sessions = {}  # For when no state manager is available
         self._style = self._create_style()
-
+    
     def _create_style(self) -> Style:
         """Create the style for the prompt with file reference highlighting."""
-        return Style.from_dict(
-            {
-                "file-reference": UI_COLORS.get("file_ref", "light_blue"),
-            }
-        )
+        return Style.from_dict({
+            'file-reference': UI_COLORS.get('file_ref', 'light_blue'),
+        })
 
     def get_session(self, session_key: str, config: PromptConfig) -> PromptSession:
         """Get or create a prompt session.
@@ -108,7 +105,6 @@ class PromptManager:
                 is_password=config.is_password,
                 validator=config.validator,
                 multiline=config.multiline,
-                default=config.default,
             )
 
             # Clean up response

tunacode/ui/tool_ui.py

@@ -154,9 +154,9 @@ class ToolUI:
         if request.filepath:
             ui.console.print(f"File: {request.filepath}", style=self.colors.muted)
 
-        ui.console.print("  1. Yes (default)")
-        ui.console.print("  2. Yes, and don't ask again for commands like this")
-        ui.console.print(f"  3. No, and tell {APP_NAME} what to do differently")
+        ui.console.print("  [1] Yes (default)")
+        ui.console.print("  [2] Yes, and don't ask again for commands like this")
+        ui.console.print(f"  [3] No, and tell {APP_NAME} what to do differently")
         resp = input("  Choose an option [1/2/3]: ").strip() or "1"
 
         # Add spacing after user choice for better readability

tunacode/utils/system.py

@@ -277,46 +277,6 @@ def check_for_updates():
         return False, current_version
 
 
-async def update_tunacode():
-    """
-    Update TunaCode to the latest version using pip.
-    """
-    from ..ui import console as ui
-    
-    await ui.info("🔄 Checking for updates...")
-    
-    has_update, latest_version = check_for_updates()
-    
-    if not has_update:
-        await ui.success("✅ TunaCode is already up to date!")
-        return
-    
-    app_settings = ApplicationSettings()
-    current_version = app_settings.version
-    
-    await ui.info(f"📦 Updating from v{current_version} to v{latest_version}...")
-    
-    try:
-        # Run pip install --upgrade tunacode-cli
-        result = subprocess.run(
-            ["pip", "install", "--upgrade", "tunacode-cli"],
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        
-        if result.returncode == 0:
-            await ui.success(f"🎉 Successfully updated to v{latest_version}!")
-            await ui.info("Please restart TunaCode to use the new version.")
-        else:
-            await ui.error(f"❌ Update failed: {result.stderr}")
-            
-    except subprocess.CalledProcessError as e:
-        await ui.error(f"❌ Update failed: {e.stderr}")
-    except Exception as e:
-        await ui.error(f"❌ Update failed: {str(e)}")
-
-
 def list_cwd(max_depth=3):
     """
     Lists files in the current working directory up to a specified depth,