tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/widgets/status_bar.py

@@ -0,0 +1,98 @@
+"""Status bar widget for TunaCode REPL."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from typing import TYPE_CHECKING
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Static
+
+if TYPE_CHECKING:
+    from tunacode.types import ToolProgress
+
+# Maximum length for operation text in status bar
+MAX_STATUS_OPERATION_LEN = 25
+
+
+class StatusBar(Horizontal):
+    """Bottom status bar - 3 zones."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._edited_files: set[str] = set()
+        self._location_text: str = ""
+
+    def compose(self) -> ComposeResult:
+        yield Static("main ● ~/proj", id="status-left")
+        yield Static("edited: -", id="status-mid")
+        yield Static("last: -", id="status-right")
+
+    def on_mount(self) -> None:
+        self._refresh_location()
+
+    def _refresh_location(self) -> None:
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                capture_output=True,
+                text=True,
+                timeout=1,
+            )
+            branch = result.stdout.strip() or "main"
+        except Exception:
+            branch = "main"
+
+        dirname = os.path.basename(os.getcwd()) or "~"
+        self._location_text = f"{branch} ● {dirname}"
+        self.query_one("#status-left", Static).update(self._location_text)
+
+    def update_last_action(self, tool_name: str) -> None:
+        self.query_one("#status-right", Static).update(f"last: {tool_name}")
+
+    def update_running_action(self, tool_name: str) -> None:
+        self.query_one("#status-right", Static).update(f"running: {tool_name}")
+
+    def update_subagent_progress(self, progress: ToolProgress) -> None:
+        """Update status with subagent progress.
+
+        Shows format: running: research [3] grep pattern...
+        """
+        operation = progress.operation
+        # Truncate operation to fit status bar
+        if len(operation) > MAX_STATUS_OPERATION_LEN:
+            operation = operation[: MAX_STATUS_OPERATION_LEN - 3] + "..."
+
+        # Format: running: subagent [current/?] operation
+        progress_text = f"running: {progress.subagent} [{progress.current}] {operation}"
+        self.query_one("#status-right", Static).update(progress_text)
+
+    def add_edited_file(self, filepath: str) -> None:
+        """Track an edited file and update display."""
+        filename = os.path.basename(filepath)
+        self._edited_files.add(filename)
+        self._update_edited_display()
+
+    def _update_edited_display(self) -> None:
+        """Update mid zone with edited files list."""
+        files = sorted(self._edited_files)
+        if not files:
+            text = "edited: -"
+        elif len(files) <= 3:
+            text = f"edited: {', '.join(files)}"
+        else:
+            shown = ", ".join(files[:2])
+            text = f"edited: {shown} +{len(files) - 2}"
+        self.query_one("#status-mid", Static).update(text)
+
+    def set_mode(self, mode: str | None) -> None:
+        """Show mode indicator in status bar."""
+        left = self.query_one("#status-left", Static)
+        if mode:
+            left.add_class("mode-active")
+            left.update(f"[{mode}] {self._location_text}")
+        else:
+            left.remove_class("mode-active")
+            left.update(self._location_text)

tunacode/utils/config/__init__.py

@@ -0,0 +1,13 @@
+"""Configuration utilities: user config persistence."""
+
+from tunacode.utils.config.user_configuration import (
+    load_config,
+    save_config,
+    set_default_model,
+)
+
+__all__ = [
+    "load_config",
+    "save_config",
+    "set_default_model",
+]

tunacode/utils/config/user_configuration.py

@@ -0,0 +1,91 @@
+"""
+Module: tunacode.utils.user_configuration
+
+Provides user configuration file management.
+Handles loading, saving, and updating user preferences including model selection.
+"""
+
+import json
+from json import JSONDecodeError
+from typing import TYPE_CHECKING
+
+from tunacode.configuration.settings import ApplicationSettings
+from tunacode.exceptions import ConfigurationError
+from tunacode.types import ModelName, UserConfig
+
+if TYPE_CHECKING:
+    from tunacode.core.state import StateManager
+
+import hashlib
+
+_config_fingerprint = None
+_config_cache = None
+
+
+def load_config() -> UserConfig | None:
+    """Load user config from file, using fingerprint fast path if available."""
+    global _config_fingerprint, _config_cache
+    app_settings = ApplicationSettings()
+    try:
+        with open(app_settings.paths.config_file) as f:
+            raw = f.read()
+            loaded = json.loads(raw)
+            new_fp = hashlib.sha1(raw.encode()).hexdigest()[:12]
+            # If hash matches, return in-memory cached config object
+            if new_fp == _config_fingerprint and _config_cache is not None:
+                return _config_cache
+            # else, update fast path
+            _config_fingerprint = new_fp
+            _config_cache = loaded
+
+            # Initialize onboarding defaults for new configurations
+            _ensure_onboarding_defaults(loaded)
+
+            return loaded
+    except FileNotFoundError:
+        return None
+    except JSONDecodeError as err:
+        msg = f"Invalid JSON in config file at {app_settings.paths.config_file}"
+        raise ConfigurationError(msg) from err
+    except Exception as err:
+        raise ConfigurationError(f"Failed to load configuration: {err}") from err
+
+
+def save_config(state_manager: "StateManager") -> bool:
+    """Save user config to file"""
+    app_settings = ApplicationSettings()
+    try:
+        # Ensure config directory exists
+        app_settings.paths.config_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+        # Write config file
+        with open(app_settings.paths.config_file, "w") as f:
+            json.dump(state_manager.session.user_config, f, indent=4)
+        return True
+    except PermissionError as e:
+        raise ConfigurationError(
+            f"Permission denied writing to {app_settings.paths.config_file}: {e}"
+        ) from e
+    except OSError as e:
+        raise ConfigurationError(
+            f"Failed to save configuration to {app_settings.paths.config_file}: {e}"
+        ) from e
+    except Exception as e:
+        raise ConfigurationError(f"Unexpected error saving configuration: {e}") from e
+
+
+def set_default_model(model_name: ModelName, state_manager: "StateManager") -> bool:
+    """Set the default model in the user config and save"""
+    state_manager.session.user_config["default_model"] = model_name
+    try:
+        save_config(state_manager)
+        return True
+    except ConfigurationError:
+        # Re-raise ConfigurationError to be handled by caller
+        raise
+
+
+def _ensure_onboarding_defaults(config: UserConfig) -> None:
+    """Ensure onboarding-related default settings are present in config."""
+    if "settings" not in config:
+        config["settings"] = {}

tunacode/utils/messaging/__init__.py

@@ -0,0 +1,10 @@
+"""Messaging utilities: content extraction and token counting."""
+
+from tunacode.utils.messaging.message_utils import get_message_content
+from tunacode.utils.messaging.token_counter import estimate_tokens, get_encoding
+
+__all__ = [
+    "get_message_content",
+    "estimate_tokens",
+    "get_encoding",
+]

tunacode/utils/messaging/message_utils.py

@@ -0,0 +1,34 @@
+"""Utilities for processing message history."""
+
+from typing import Any
+
+
+def get_message_content(message: Any) -> str:
+    """Extracts the content from a message object of any type."""
+    if isinstance(message, str):
+        return message
+    if isinstance(message, dict):
+        if "content" in message:
+            content = message["content"]
+            # Handle nested content structures
+            if isinstance(content, list):
+                return " ".join(get_message_content(item) for item in content)
+            return str(content)
+        if "parts" in message:
+            parts = message["parts"]
+            if isinstance(parts, list):
+                return " ".join(get_message_content(part) for part in parts)
+            return str(parts)
+        if "thought" in message:
+            return str(message["thought"])
+    if hasattr(message, "content"):
+        content = message.content
+        if isinstance(content, list):
+            return " ".join(get_message_content(item) for item in content)
+        return str(content)
+    if hasattr(message, "parts"):
+        parts = message.parts
+        if isinstance(parts, list):
+            return " ".join(get_message_content(part) for part in parts)
+        return str(parts)
+    return ""

tunacode/utils/messaging/token_counter.py

@@ -0,0 +1,77 @@
+"""Token counting utility using tiktoken for accurate, offline token estimation."""
+
+from functools import lru_cache
+from typing import Any
+
+# Cache for tokenizer encodings
+_encoding_cache: dict[str, Any] = {}
+
+
+@lru_cache(maxsize=8)
+def get_encoding(model_name: str):
+    """Get the appropriate tiktoken encoding for a model.
+
+    Args:
+        model_name: The model name in format "provider:model"
+
+    Returns:
+        A tiktoken encoding instance
+    """
+    try:
+        import tiktoken
+    except ImportError:
+        return None
+
+    # Extract the model part from "provider:model" format
+    if ":" in model_name:
+        provider, model = model_name.split(":", 1)
+    else:
+        provider, model = "unknown", model_name
+
+    # Map common models to their tiktoken encodings
+    if provider == "openai":
+        if "gpt-4" in model:
+            encoding_name = "cl100k_base"  # GPT-4 encoding
+        elif "gpt-3.5" in model:
+            encoding_name = "cl100k_base"  # GPT-3.5-turbo encoding
+        else:
+            encoding_name = "cl100k_base"  # Default for newer models
+    elif provider == "anthropic":
+        # Claude models use similar tokenization to GPT-4
+        encoding_name = "cl100k_base"
+    else:
+        # Default encoding for unknown models
+        encoding_name = "cl100k_base"
+
+    try:
+        return tiktoken.get_encoding(encoding_name)
+    except Exception:
+        return None
+
+
+def estimate_tokens(text: str, model_name: str | None = None) -> int:
+    """
+    Estimate token count using tiktoken for accurate results.
+
+    Args:
+        text: The text to count tokens for.
+        model_name: Optional model name for model-specific tokenization.
+
+    Returns:
+        The estimated number of tokens.
+    """
+    if not text:
+        return 0
+
+    # Try tiktoken first if model is specified
+    if model_name:
+        encoding = get_encoding(model_name)
+        if encoding:
+            try:
+                return len(encoding.encode(text))
+            except Exception:
+                pass
+
+    # Fallback to character-based estimation
+    # This is roughly accurate for English text
+    return len(text) // 4

tunacode/utils/parsing/__init__.py

@@ -0,0 +1,13 @@
+from .command_parser import parse_args
+from .tool_parser import (
+    ParsedToolCall,
+    has_potential_tool_call,
+    parse_tool_calls_from_text,
+)
+
+__all__ = [
+    "parse_args",
+    "ParsedToolCall",
+    "has_potential_tool_call",
+    "parse_tool_calls_from_text",
+]

tunacode/utils/parsing/command_parser.py

@@ -0,0 +1,55 @@
+"""Module: tunacode.cli.command_parser
+
+Command parsing utilities for the Textual REPL."""
+
+import json
+
+from tunacode.constants import (
+    JSON_PARSE_BASE_DELAY,
+    JSON_PARSE_MAX_DELAY,
+    JSON_PARSE_MAX_RETRIES,
+)
+from tunacode.exceptions import ValidationError
+from tunacode.types import ToolArgs
+from tunacode.utils.parsing.json_utils import safe_json_parse
+from tunacode.utils.parsing.retry import retry_json_parse
+
+
+def parse_args(args) -> ToolArgs:
+    """
+    Parse tool arguments from a JSON string or dictionary with retry logic.
+
+    Args:
+        args (str or dict): A JSON-formatted string or a dictionary containing tool arguments.
+
+    Returns:
+        dict: The parsed arguments.
+
+    Raises:
+        ValidationError: If 'args' is not a string or dictionary, or if the string
+        is not valid JSON.
+    """
+    if isinstance(args, str):
+        try:
+            return retry_json_parse(
+                args,
+                max_retries=JSON_PARSE_MAX_RETRIES,
+                base_delay=JSON_PARSE_BASE_DELAY,
+                max_delay=JSON_PARSE_MAX_DELAY,
+            )
+        except json.JSONDecodeError as e:
+            if "Extra data" in str(e):
+                try:
+                    result = safe_json_parse(args, allow_concatenated=True)
+                    if isinstance(result, dict):
+                        return result
+                    elif isinstance(result, list) and result:
+                        return result[0]
+                except Exception:
+                    pass
+
+            raise ValidationError(f"Invalid JSON: {args}") from e
+    elif isinstance(args, dict):
+        return args
+    else:
+        raise ValidationError(f"Invalid args type: {type(args)}")

tunacode/utils/parsing/json_utils.py

@@ -0,0 +1,188 @@
+"""
+Module: tunacode.utils.json_utils
+
+JSON parsing utilities with enhanced error handling and concatenated object support.
+"""
+
+import json
+from typing import Any
+
+from tunacode.constants import READ_ONLY_TOOLS
+
+
+class ConcatenatedJSONError(Exception):
+    """Raised when concatenated JSON objects are detected but cannot be safely handled."""
+
+    def __init__(self, message: str, objects_found: int, tool_name: str | None = None):
+        self.message = message
+        self.objects_found = objects_found
+        self.tool_name = tool_name
+        super().__init__(message)
+
+
+def split_concatenated_json(json_string: str) -> list[dict[str, Any]]:
+    """
+    Split concatenated JSON objects like {"a": 1}{"b": 2} into separate objects.
+
+    Args:
+        json_string: String containing potentially concatenated JSON objects
+
+    Returns:
+        List of parsed JSON objects
+
+    Raises:
+        json.JSONDecodeError: If no valid JSON objects can be extracted
+    """
+    objects = []
+    brace_count = 0
+    start_pos = 0
+    in_string = False
+    escape_next = False
+
+    for i, char in enumerate(json_string):
+        if escape_next:
+            escape_next = False
+            continue
+
+        if char == "\\":
+            escape_next = True
+            continue
+
+        if char == '"' and not escape_next:
+            in_string = not in_string
+            continue
+
+        if in_string:
+            continue
+
+        if char == "{":
+            if brace_count == 0:
+                start_pos = i
+            brace_count += 1
+        elif char == "}":
+            brace_count -= 1
+            if brace_count == 0:
+                potential_json = json_string[start_pos : i + 1].strip()
+                try:
+                    parsed = json.loads(potential_json)
+                except json.JSONDecodeError:
+                    continue
+
+                if isinstance(parsed, dict):
+                    objects.append(parsed)
+
+    if not objects:
+        raise json.JSONDecodeError("No valid JSON objects found", json_string, 0)
+
+    return objects
+
+
+def validate_tool_args_safety(objects: list[dict[str, Any]], tool_name: str | None = None) -> bool:
+    """
+    Validate whether it's safe to execute multiple JSON objects for a given tool.
+
+    Args:
+        objects: List of JSON objects to validate
+        tool_name: Name of the tool (if known)
+
+    Returns:
+        bool: True if safe to execute, False otherwise
+
+    Raises:
+        ConcatenatedJSONError: If multiple objects detected for unsafe tool
+    """
+    if len(objects) <= 1:
+        return True
+
+    # Check if tool is read-only (safer to execute multiple times)
+    if tool_name and tool_name in READ_ONLY_TOOLS:
+        return True
+
+    # For write/execute tools, multiple objects are potentially dangerous
+    if tool_name is None:
+        return False
+
+    raise ConcatenatedJSONError(
+        f"Multiple JSON objects not safe for tool {tool_name}",
+        objects_found=len(objects),
+        tool_name=tool_name,
+    )
+
+
+def safe_json_parse(
+    json_string: str, tool_name: str | None = None, allow_concatenated: bool = False
+) -> dict[str, Any] | list[dict[str, Any]]:
+    """
+    Safely parse JSON with optional concatenated object support.
+
+    Args:
+        json_string: JSON string to parse
+        tool_name: Name of the tool (for safety validation)
+        allow_concatenated: Whether to attempt splitting concatenated objects
+
+    Returns:
+        Single dict if one object, or list of dicts if multiple objects
+
+    Raises:
+        json.JSONDecodeError: If parsing fails
+        ConcatenatedJSONError: If concatenated objects are unsafe
+    """
+    try:
+        # First, try normal JSON parsing
+        result = json.loads(json_string)
+    except json.JSONDecodeError as e:
+        if not allow_concatenated or "Extra data" not in str(e):
+            raise
+
+        # Try to split concatenated objects
+        objects = split_concatenated_json(json_string)
+
+        # Validate safety - fail loud if multiple objects would be discarded
+        if not validate_tool_args_safety(objects, tool_name):
+            if len(objects) > 1:
+                raise ConcatenatedJSONError(
+                    "Multiple JSON objects detected but tool safety unknown",
+                    objects_found=len(objects),
+                    tool_name=tool_name,
+                ) from None
+            return objects[0]
+
+        if len(objects) == 1:
+            return objects[0]
+
+        return objects
+
+    if not isinstance(result, dict):
+        raise json.JSONDecodeError(f"Expected dict, got {type(result)}", json_string, 0)
+
+    return result
+
+
+def merge_json_objects(objects: list[dict[str, Any]], strategy: str = "first") -> dict[str, Any]:
+    """
+    Merge multiple JSON objects using different strategies.
+
+    Args:
+        objects: List of JSON objects to merge
+        strategy: Merge strategy ("first", "last", "combine")
+
+    Returns:
+        Single merged JSON object
+    """
+    if not objects:
+        return {}
+
+    if len(objects) == 1:
+        return objects[0]
+
+    if strategy == "first":
+        return objects[0]
+    if strategy == "last":
+        return objects[-1]
+    if strategy == "combine":
+        result: dict[str, Any] = {}
+        for obj in objects:
+            result.update(obj)
+        return result
+
+    raise ValueError(f"Unknown merge strategy: {strategy}")