tunacode-cli 0.0.1__py3-none-any.whl

tunacode/ui/prompt_manager.py

@@ -0,0 +1,117 @@
+"""Prompt configuration and management for Sidekick UI."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from prompt_toolkit.completion import Completer
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.lexers import Lexer
+from prompt_toolkit.shortcuts import PromptSession
+from prompt_toolkit.styles import Style
+from prompt_toolkit.validation import Validator
+
+from tunacode.constants import UI_COLORS
+from tunacode.core.state import StateManager
+from tunacode.exceptions import UserAbortError
+
+
+@dataclass
+class PromptConfig:
+    """Configuration for prompt sessions."""
+
+    multiline: bool = False
+    is_password: bool = False
+    validator: Optional[Validator] = None
+    key_bindings: Optional[KeyBindings] = None
+    placeholder: Optional[FormattedText] = None
+    completer: Optional[Completer] = None
+    lexer: Optional[Lexer] = None
+    timeoutlen: float = 0.05
+
+
+class PromptManager:
+    """Manages prompt sessions and their lifecycle."""
+
+    def __init__(self, state_manager: Optional[StateManager] = None):
+        """Initialize the prompt manager.
+
+        Args:
+            state_manager: Optional state manager for session persistence
+        """
+        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'),
+        })
+
+    def get_session(self, session_key: str, config: PromptConfig) -> PromptSession:
+        """Get or create a prompt session.
+
+        Args:
+            session_key: Unique key for the session
+            config: Configuration for the session
+
+        Returns:
+            PromptSession instance
+        """
+        if self.state_manager:
+            # Use state manager's session storage
+            if session_key not in self.state_manager.session.input_sessions:
+                self.state_manager.session.input_sessions[session_key] = PromptSession(
+                    key_bindings=config.key_bindings,
+                    placeholder=config.placeholder,
+                    completer=config.completer,
+                    lexer=config.lexer,
+                    style=self._style,
+                )
+            return self.state_manager.session.input_sessions[session_key]
+        else:
+            # Use temporary storage
+            if session_key not in self._temp_sessions:
+                self._temp_sessions[session_key] = PromptSession(
+                    key_bindings=config.key_bindings,
+                    placeholder=config.placeholder,
+                    completer=config.completer,
+                    lexer=config.lexer,
+                    style=self._style,
+                )
+            return self._temp_sessions[session_key]
+
+    async def get_input(self, session_key: str, prompt: str, config: PromptConfig) -> str:
+        """Get user input using the specified configuration.
+
+        Args:
+            session_key: Unique key for the session
+            prompt: The prompt text to display
+            config: Configuration for the input
+
+        Returns:
+            User input string
+
+        Raises:
+            UserAbortError: If user cancels input
+        """
+        session = self.get_session(session_key, config)
+
+        try:
+            # Get user input
+            response = await session.prompt_async(
+                prompt,
+                is_password=config.is_password,
+                validator=config.validator,
+                multiline=config.multiline,
+            )
+
+            # Clean up response
+            if isinstance(response, str):
+                response = response.strip()
+
+            return response
+
+        except (KeyboardInterrupt, EOFError):
+            raise UserAbortError

tunacode/ui/tool_ui.py

@@ -0,0 +1,187 @@
+"""
+Tool confirmation UI components, separated from business logic.
+"""
+
+from rich.markdown import Markdown
+from rich.padding import Padding
+from rich.panel import Panel
+
+from tunacode.configuration.settings import ApplicationSettings
+from tunacode.constants import APP_NAME, TOOL_UPDATE_FILE, TOOL_WRITE_FILE, UI_COLORS
+from tunacode.core.tool_handler import ToolConfirmationRequest, ToolConfirmationResponse
+from tunacode.types import ToolArgs
+from tunacode.ui import console as ui
+from tunacode.utils.diff_utils import render_file_diff
+from tunacode.utils.file_utils import DotDict
+from tunacode.utils.text_utils import ext_to_lang, key_to_title
+
+
+class ToolUI:
+    """Handles tool confirmation UI presentation."""
+
+    def __init__(self):
+        self.colors = DotDict(UI_COLORS)
+
+    def _get_tool_title(self, tool_name: str) -> str:
+        """
+        Get the display title for a tool.
+
+        Args:
+            tool_name: Name of the tool.
+
+        Returns:
+            str: Display title.
+        """
+        app_settings = ApplicationSettings()
+        if tool_name in app_settings.internal_tools:
+            return f"Tool({tool_name})"
+        else:
+            return f"MCP({tool_name})"
+
+    def _create_code_block(self, filepath: str, content: str) -> Markdown:
+        """
+        Create a code block for the given file path and content.
+
+        Args:
+            filepath: The path to the file.
+            content: The content of the file.
+
+        Returns:
+            Markdown: A Markdown object representing the code block.
+        """
+        lang = ext_to_lang(filepath)
+        code_block = f"```{lang}\n{content}\n```"
+        return ui.markdown(code_block)
+
+    def _render_args(self, tool_name: str, args: ToolArgs) -> str:
+        """
+        Render the tool arguments for display.
+
+        Args:
+            tool_name: Name of the tool.
+            args: Tool arguments.
+
+        Returns:
+            str: Formatted arguments for display.
+        """
+        # Show diff between `target` and `patch` on file updates
+        if tool_name == TOOL_UPDATE_FILE:
+            return render_file_diff(args["target"], args["patch"], self.colors)
+
+        # Show file content on write_file
+        elif tool_name == TOOL_WRITE_FILE:
+            return self._create_code_block(args["filepath"], args["content"])
+
+        # Default to showing key and value on new line
+        content = ""
+        for key, value in args.items():
+            if isinstance(value, list):
+                content += f"{key_to_title(key)}:\n"
+                for item in value:
+                    content += f"  - {item}\n"
+                content += "\n"
+            else:
+                # If string length is over 200 characters, split to new line
+                value = str(value)
+                content += f"{key_to_title(key)}:"
+                if len(value) > 200:
+                    content += f"\n{value}\n\n"
+                else:
+                    content += f" {value}\n\n"
+        return content.strip()
+
+    async def show_confirmation(
+        self, request: ToolConfirmationRequest, state_manager=None
+    ) -> ToolConfirmationResponse:
+        """
+        Show tool confirmation UI and get user response.
+
+        Args:
+            request: The confirmation request.
+
+        Returns:
+            ToolConfirmationResponse: User's response to the confirmation.
+        """
+        title = self._get_tool_title(request.tool_name)
+        content = self._render_args(request.tool_name, request.args)
+
+        await ui.tool_confirm(title, content, filepath=request.filepath)
+
+        # If tool call has filepath, show it under panel
+        if request.filepath:
+            await ui.usage(f"File: {request.filepath}")
+
+        await ui.print("  1. Yes (default)")
+        await ui.print("  2. Yes, and don't ask again for commands like this")
+        await ui.print(f"  3. No, and tell {APP_NAME} what to do differently")
+        resp = (
+            await ui.input(
+                session_key="tool_confirm",
+                pretext="  Choose an option [1/2/3]: ",
+                state_manager=state_manager,
+            )
+            or "1"
+        )
+
+        if resp == "2":
+            return ToolConfirmationResponse(approved=True, skip_future=True)
+        elif resp == "3":
+            return ToolConfirmationResponse(approved=False, abort=True)
+        else:
+            return ToolConfirmationResponse(approved=True)
+
+    def show_sync_confirmation(self, request: ToolConfirmationRequest) -> ToolConfirmationResponse:
+        """
+        Show tool confirmation UI synchronously and get user response.
+
+        Args:
+            request: The confirmation request.
+
+        Returns:
+            ToolConfirmationResponse: User's response to the confirmation.
+        """
+        title = self._get_tool_title(request.tool_name)
+        content = self._render_args(request.tool_name, request.args)
+
+        # Display styled confirmation panel using direct console output
+        # Avoid using sync wrappers that might create event loop conflicts
+        panel_obj = Panel(
+            Padding(content, 1), title=title, title_align="left", border_style=self.colors.warning
+        )
+        # Add consistent spacing above panels
+        ui.console.print(Padding(panel_obj, (1, 0, 0, 0)))
+
+        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")
+        resp = input("  Choose an option [1/2/3]: ").strip() or "1"
+
+        # Add spacing after user choice for better readability
+        print()
+
+        if resp == "2":
+            return ToolConfirmationResponse(approved=True, skip_future=True)
+        elif resp == "3":
+            return ToolConfirmationResponse(approved=False, abort=True)
+        else:
+            return ToolConfirmationResponse(approved=True)
+
+    async def log_mcp(self, title: str, args: ToolArgs) -> None:
+        """
+        Display MCP tool with its arguments.
+
+        Args:
+            title: Title to display.
+            args: Arguments to display.
+        """
+        if not args:
+            return
+
+        await ui.info(title)
+        for key, value in args.items():
+            if isinstance(value, list):
+                value = ", ".join(value)
+            await ui.muted(f"{key}: {value}", spaces=4)

tunacode/ui/validators.py

@@ -0,0 +1,23 @@
+"""Input validators for Sidekick UI."""
+
+from prompt_toolkit.validation import ValidationError, Validator
+
+
+class ModelValidator(Validator):
+    """Validate default provider selection"""
+
+    def __init__(self, index):
+        self.index = index
+
+    def validate(self, document) -> None:
+        text = document.text.strip()
+        if not text:
+            raise ValidationError(message="Provider number cannot be empty")
+        elif text and not text.isdigit():
+            raise ValidationError(message="Invalid provider number")
+        elif text.isdigit():
+            number = int(text)
+            if number < 0 or number >= self.index:
+                raise ValidationError(
+                    message="Invalid provider number",
+                )

tunacode/utils/bm25.py

@@ -0,0 +1,55 @@
+import math
+import re
+from collections import Counter
+from typing import Iterable, List
+
+
+def tokenize(text: str) -> List[str]:
+    """Simple whitespace and punctuation tokenizer."""
+    return re.findall(r"\w+", text.lower())
+
+
+class BM25:
+    """Minimal BM25 implementation for small corpora."""
+
+    def __init__(self, corpus: Iterable[str], k1: float = 1.5, b: float = 0.75):
+        self.k1 = k1
+        self.b = b
+        self.documents = [tokenize(doc) for doc in corpus]
+        self.doc_freqs = []
+        self.doc_lens = []
+        self.idf = {}
+        self.avgdl = 0.0
+        self._initialize()
+
+    def _initialize(self) -> None:
+        df = Counter()
+        for doc in self.documents:
+            freqs = Counter(doc)
+            self.doc_freqs.append(freqs)
+            self.doc_lens.append(len(doc))
+            for word in freqs:
+                df[word] += 1
+        self.avgdl = sum(self.doc_lens) / len(self.documents) if self.documents else 0.0
+        total_docs = len(self.documents)
+        for word, freq in df.items():
+            self.idf[word] = math.log(1 + (total_docs - freq + 0.5) / (freq + 0.5))
+
+    def get_scores(self, query: Iterable[str]) -> List[float]:
+        """Calculate BM25 scores for a query."""
+        scores = [0.0] * len(self.documents)
+        query_terms = list(query)
+        for idx, doc in enumerate(self.documents):
+            freqs = self.doc_freqs[idx]
+            doc_len = self.doc_lens[idx]
+            score = 0.0
+            for term in query_terms:
+                if term not in freqs:
+                    continue
+                idf = self.idf.get(term, 0.0)
+                tf = freqs[term]
+                numerator = tf * (self.k1 + 1)
+                denominator = tf + self.k1 * (1 - self.b + self.b * doc_len / self.avgdl)
+                score += idf * numerator / denominator
+            scores[idx] = score
+        return scores

tunacode/utils/diff_utils.py

@@ -0,0 +1,69 @@
+"""
+Module: sidekick.utils.diff_utils
+
+Provides diff visualization utilities for file changes.
+Generates styled text diffs between original and modified content using the difflib library.
+"""
+
+import difflib
+
+from rich.text import Text
+
+
+def render_file_diff(target: str, patch: str, colors=None) -> Text:
+    """
+    Create a formatted diff between target and patch text.
+
+    Args:
+        target (str): The original text to be replaced.
+        patch (str): The new text to insert.
+        colors (dict, optional): Dictionary containing style colors.
+                                If None, no styling will be applied.
+
+    Returns:
+        Text: A Rich Text object containing the formatted diff.
+    """
+    # Create a clean diff with styled text
+    diff_text = Text()
+
+    # Get lines and create a diff sequence
+    target_lines = target.splitlines()
+    patch_lines = patch.splitlines()
+
+    # Use difflib to identify changes
+    matcher = difflib.SequenceMatcher(None, target_lines, patch_lines)
+
+    for op, i1, i2, j1, j2 in matcher.get_opcodes():
+        if op == "equal":
+            # Unchanged lines
+            for line in target_lines[i1:i2]:
+                diff_text.append(f"  {line}\n")
+        elif op == "delete":
+            # Removed lines - show in red with (-) prefix
+            for line in target_lines[i1:i2]:
+                if colors:
+                    diff_text.append(f"- {line}\n", style=colors.error)
+                else:
+                    diff_text.append(f"- {line}\n")
+        elif op == "insert":
+            # Added lines - show in green with (+) prefix
+            for line in patch_lines[j1:j2]:
+                if colors:
+                    diff_text.append(f"+ {line}\n", style=colors.success)
+                else:
+                    diff_text.append(f"+ {line}\n")
+        elif op == "replace":
+            # Removed lines with (-) prefix
+            for line in target_lines[i1:i2]:
+                if colors:
+                    diff_text.append(f"- {line}\n", style=colors.error)
+                else:
+                    diff_text.append(f"- {line}\n")
+            # Added lines with (+) prefix
+            for line in patch_lines[j1:j2]:
+                if colors:
+                    diff_text.append(f"+ {line}\n", style=colors.success)
+                else:
+                    diff_text.append(f"+ {line}\n")
+
+    return diff_text

tunacode/utils/file_utils.py

@@ -0,0 +1,41 @@
+"""
+Module: sidekick.utils.file_utils
+
+Provides file system utilities and helper classes.
+Includes DotDict for dot notation access and stdout capture functionality.
+"""
+
+import io
+import sys
+from contextlib import contextmanager
+
+
+class DotDict(dict):
+    """dot.notation access to dictionary attributes"""
+
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+@contextmanager
+def capture_stdout():
+    """
+    Context manager to capture stdout output.
+
+    Example:
+        with capture_stdout() as stdout_capture:
+            print("This will be captured")
+
+        captured_output = stdout_capture.getvalue()
+
+    Returns:
+        StringIO object containing the captured output
+    """
+    stdout_capture = io.StringIO()
+    original_stdout = sys.stdout
+    sys.stdout = stdout_capture
+    try:
+        yield stdout_capture
+    finally:
+        sys.stdout = original_stdout

tunacode/utils/ripgrep.py

@@ -0,0 +1,17 @@
+import subprocess
+from typing import List
+
+
+def ripgrep(pattern: str, directory: str = ".") -> List[str]:
+    """Return a list of file paths matching a pattern using ripgrep."""
+    try:
+        result = subprocess.run(
+            ["rg", "--files", "-g", pattern, directory],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=5,
+        )
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+        return []