tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/main.py

@@ -0,0 +1,252 @@
+"""CLI entry point for TunaCode."""
+
+import asyncio
+import json
+import os
+import sys
+
+import typer
+
+from tunacode.configuration.settings import ApplicationSettings
+from tunacode.constants import SETTINGS_BASE_URL
+from tunacode.core.state import StateManager
+from tunacode.exceptions import UserAbortError
+from tunacode.tools.authorization.handler import ToolHandler
+from tunacode.ui.headless import resolve_output
+from tunacode.ui.repl_support import run_textual_repl
+from tunacode.utils.system import check_for_updates
+
+DEFAULT_TIMEOUT_SECONDS = 600
+BASE_URL_HELP_TEXT = "API base URL (e.g., https://openrouter.ai/api/v1)"
+HEADLESS_NO_RESPONSE_ERROR = "Error: No response generated"
+
+app_settings = ApplicationSettings()
+app = typer.Typer(help="TunaCode - OS AI-powered development assistant")
+state_manager = StateManager()
+
+
+def _handle_background_task_error(task: asyncio.Task) -> None:
+    try:
+        exception = task.exception()
+        if exception is not None:
+            # Background task failed - just pass without logging
+            pass
+    except asyncio.CancelledError:
+        pass
+    except Exception:
+        pass
+
+
+def _print_version() -> None:
+    from tunacode.constants import APP_VERSION
+
+    print(f"tunacode {APP_VERSION}")
+
+
+def _apply_base_url_override(state_manager: StateManager, base_url: str | None) -> None:
+    if not base_url:
+        return
+
+    user_config = state_manager.session.user_config
+    settings = user_config.get("settings")
+    if settings is None:
+        settings = {}
+        user_config["settings"] = settings
+
+    settings[SETTINGS_BASE_URL] = base_url
+
+
+async def _run_textual_app(*, model: str | None, show_setup: bool) -> None:
+    update_task = asyncio.create_task(asyncio.to_thread(check_for_updates), name="update_check")
+    update_task.add_done_callback(_handle_background_task_error)
+
+    if model:
+        state_manager.session.current_model = model
+
+    try:
+        tool_handler = ToolHandler(state_manager)
+        state_manager.set_tool_handler(tool_handler)
+
+        await run_textual_repl(state_manager, show_setup=show_setup)
+    except (KeyboardInterrupt, UserAbortError):
+        update_task.cancel()
+        return
+    except Exception as exc:
+        from tunacode.exceptions import ConfigurationError
+
+        if isinstance(exc, ConfigurationError):
+            print(f"Error: {exc}")
+            update_task.cancel()
+            return
+
+        import traceback
+
+        print(f"Error: {exc}\n\nTraceback:\n{traceback.format_exc()}")
+        update_task.cancel()
+        return
+
+    try:
+        has_update, latest_version = await update_task
+        if has_update:
+            print(f"Update available: {latest_version}")
+    except asyncio.CancelledError:
+        return
+
+
+def _run_textual_cli(*, model: str | None, show_setup: bool) -> None:
+    asyncio.run(_run_textual_app(model=model, show_setup=show_setup))
+
+
+@app.callback(invoke_without_command=True)
+def _default_command(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Show version and exit."),
+    setup: bool = typer.Option(False, "--setup", help="Run setup wizard"),
+    baseurl: str | None = typer.Option(None, "--baseurl", help=BASE_URL_HELP_TEXT),
+    model: str | None = typer.Option(
+        None, "--model", help="Default model to use (e.g., openai/gpt-4)"
+    ),
+    _key: str = typer.Option(None, "--key", help="API key for the provider"),  # noqa: ARG001
+    _context: int = typer.Option(  # noqa: ARG001 - reserved for future use
+        None, "--context", help="Maximum context window size for custom models"
+    ),
+) -> None:
+    if version:
+        _print_version()
+        raise typer.Exit(code=0)
+
+    if ctx.invoked_subcommand is not None:
+        if setup:
+            raise typer.BadParameter("Use `tunacode --setup` without a subcommand.")
+        _apply_base_url_override(state_manager, baseurl)
+        if model:
+            state_manager.session.current_model = model
+        return
+
+    _apply_base_url_override(state_manager, baseurl)
+    _run_textual_cli(model=model, show_setup=setup)
+
+
+@app.command(hidden=True)
+def main(
+    version: bool = typer.Option(False, "--version", "-v", help="Show version and exit."),
+    baseurl: str | None = typer.Option(None, "--baseurl", help=BASE_URL_HELP_TEXT),
+    model: str | None = typer.Option(
+        None, "--model", help="Default model to use (e.g., openai/gpt-4)"
+    ),
+    _key: str = typer.Option(None, "--key", help="API key for the provider"),  # noqa: ARG001
+    _context: int = typer.Option(  # noqa: ARG001 - reserved for future use
+        None, "--context", help="Maximum context window size for custom models"
+    ),
+    setup: bool = typer.Option(False, "--setup", help="Run setup wizard"),
+) -> None:
+    """Deprecated alias for `tunacode`."""
+    if version:
+        _print_version()
+        raise typer.Exit(code=0)
+
+    _apply_base_url_override(state_manager, baseurl)
+    _run_textual_cli(model=model, show_setup=setup)
+
+
+@app.command(name="run")
+def run_headless(
+    prompt: str = typer.Argument(..., help="The prompt/instruction to execute"),
+    auto_approve: bool = typer.Option(
+        False, "--auto-approve", help="Skip tool authorization prompts"
+    ),
+    output_json: bool = typer.Option(False, "--output-json", help="Output trajectory as JSON"),
+    timeout: int = typer.Option(
+        DEFAULT_TIMEOUT_SECONDS, "--timeout", help="Execution timeout in seconds"
+    ),
+    cwd: str | None = typer.Option(None, "--cwd", help="Working directory for execution"),
+    baseurl: str | None = typer.Option(None, "--baseurl", help=BASE_URL_HELP_TEXT),
+    model: str | None = typer.Option(None, "--model", "-m", help="Model to use"),
+) -> None:
+    """Run TunaCode in non-interactive headless mode."""
+    from tunacode.core.agents.main import process_request
+
+    async def async_run() -> int:
+        # Change working directory if specified
+        if cwd:
+            if not os.path.isdir(cwd):
+                raise SystemExit(f"Invalid working directory: {cwd} (not a directory)")
+            if not os.access(cwd, os.R_OK | os.X_OK):
+                raise SystemExit(f"Inaccessible working directory: {cwd}")
+            os.chdir(cwd)
+
+        # Set model if provided
+        if model:
+            state_manager.session.current_model = model
+
+        _apply_base_url_override(state_manager, baseurl)
+
+        # Auto-approve mode (reuses existing yolo infrastructure)
+        if auto_approve:
+            state_manager.session.yolo = True
+
+        # Initialize tool handler
+        tool_handler = ToolHandler(state_manager)
+        state_manager.set_tool_handler(tool_handler)
+
+        try:
+            agent_run = await asyncio.wait_for(
+                process_request(
+                    message=prompt,
+                    model=state_manager.session.current_model,
+                    state_manager=state_manager,
+                    tool_callback=None,
+                    streaming_callback=None,
+                    tool_result_callback=None,
+                    tool_start_callback=None,
+                ),
+                timeout=timeout,
+            )
+
+            if output_json:
+                trajectory = {
+                    "messages": [_serialize_message(msg) for msg in state_manager.session.messages],
+                    "tool_calls": state_manager.session.tool_calls,
+                    "usage": state_manager.session.session_total_usage,
+                    "success": True,
+                }
+                print(json.dumps(trajectory, indent=2))
+                return 0
+
+            headless_output = resolve_output(agent_run, state_manager.session.messages)
+            if headless_output is None:
+                print(HEADLESS_NO_RESPONSE_ERROR, file=sys.stderr)
+                return 1
+
+            print(headless_output)
+
+            return 0
+
+        except TimeoutError:
+            if output_json:
+                print(json.dumps({"success": False, "error": "timeout"}))
+            else:
+                print("Error: Execution timed out", file=sys.stderr)
+            return 1
+        except Exception as e:
+            if output_json:
+                print(json.dumps({"success": False, "error": str(e)}))
+            else:
+                print(f"Error: {e}", file=sys.stderr)
+            return 1
+
+    exit_code = asyncio.run(async_run())
+    raise typer.Exit(code=exit_code)
+
+
+def _serialize_message(msg: object) -> dict:
+    """Serialize a message object to a dictionary."""
+    if hasattr(msg, "model_dump"):
+        return msg.model_dump()
+    if hasattr(msg, "__dict__"):
+        return msg.__dict__
+    return {"content": str(msg)}
+
+
+if __name__ == "__main__":
+    app()

tunacode/ui/renderers/__init__.py

@@ -0,0 +1,41 @@
+"""Rich content renderers for Textual TUI."""
+
+from .errors import render_exception, render_tool_error, render_user_abort
+from .panels import (
+    ErrorDisplayData,
+    RichPanelRenderer,
+    SearchResultData,
+    ToolDisplayData,
+    error_panel,
+    search_panel,
+    tool_panel,
+    tool_panel_smart,
+)
+from .search import (
+    CodeSearchResult,
+    FileSearchResult,
+    SearchDisplayRenderer,
+    code_search_panel,
+    file_search_panel,
+    quick_results,
+)
+
+__all__ = [
+    "CodeSearchResult",
+    "ErrorDisplayData",
+    "FileSearchResult",
+    "RichPanelRenderer",
+    "SearchDisplayRenderer",
+    "SearchResultData",
+    "ToolDisplayData",
+    "code_search_panel",
+    "error_panel",
+    "file_search_panel",
+    "quick_results",
+    "render_exception",
+    "render_tool_error",
+    "render_user_abort",
+    "search_panel",
+    "tool_panel",
+    "tool_panel_smart",
+]

tunacode/ui/renderers/errors.py

@@ -0,0 +1,197 @@
+"""Error Panel System for Textual TUI."""
+
+from __future__ import annotations
+
+from rich.console import RenderableType
+
+from tunacode.ui.renderers.panels import ErrorDisplayData, RichPanelRenderer
+
+ERROR_SEVERITY_MAP: dict[str, str] = {
+    "ToolExecutionError": "error",
+    "FileOperationError": "error",
+    "AgentError": "error",
+    "GitOperationError": "error",
+    "GlobalRequestTimeoutError": "error",
+    "ToolBatchingJSONError": "error",
+    "ConfigurationError": "warning",
+    "ModelConfigurationError": "warning",
+    "ValidationError": "warning",
+    "SetupValidationError": "warning",
+    "UserAbortError": "info",
+    "StateError": "info",
+}
+
+EXCEPTION_CONTEXT_ATTRS: dict[str, str] = {
+    "tool_name": "Tool",
+    "path": "Path",
+    "operation": "Operation",
+    "server_name": "Server",
+    "model": "Model",
+    "step": "Step",
+    "validation_type": "Validation",
+}
+
+
+def _extract_exception_context(exc: Exception) -> dict[str, str]:
+    context: dict[str, str] = {}
+    for attr, label in EXCEPTION_CONTEXT_ATTRS.items():
+        if hasattr(exc, attr):
+            value = getattr(exc, attr)
+            if value is not None:
+                context[label] = str(value)
+    return context
+
+
+DEFAULT_RECOVERY_COMMANDS: dict[str, list[str]] = {
+    "ConfigurationError": [
+        "tunacode --setup  # Run setup wizard",
+        "cat ~/.tunacode/tunacode.json  # Check config",
+    ],
+    "ModelConfigurationError": [
+        "/model  # List available models",
+        "tunacode --setup  # Reconfigure",
+    ],
+    "FileOperationError": [
+        "ls -la <path>  # Check permissions",
+        "pwd  # Verify current directory",
+    ],
+    "GitOperationError": [
+        "git status  # Check repository state",
+        "git stash  # Stash uncommitted changes",
+    ],
+    "GlobalRequestTimeoutError": [
+        "Check network connectivity",
+        "Increase timeout in tunacode.json",
+    ],
+}
+
+
+def render_exception(exc: Exception) -> RenderableType:
+    error_type = type(exc).__name__
+    severity = ERROR_SEVERITY_MAP.get(error_type, "error")
+
+    suggested_fix = getattr(exc, "suggested_fix", None)
+    recovery_commands = getattr(exc, "recovery_commands", None)
+
+    context = _extract_exception_context(exc)
+
+    if not recovery_commands:
+        recovery_commands = DEFAULT_RECOVERY_COMMANDS.get(error_type)
+
+    message = str(exc)
+    for prefix in ("Fix: ", "Suggested fix: ", "Recovery commands:"):
+        if prefix in message:
+            message = message.split(prefix)[0].strip()
+
+    data = ErrorDisplayData(
+        error_type=error_type,
+        message=message,
+        suggested_fix=suggested_fix,
+        recovery_commands=recovery_commands,
+        context=context if context else None,
+        severity=severity,
+    )
+
+    return RichPanelRenderer.render_error(data)
+
+
+def render_tool_error(
+    tool_name: str,
+    message: str,
+    suggested_fix: str | None = None,
+    file_path: str | None = None,
+) -> RenderableType:
+    context = {}
+    if file_path:
+        context["Path"] = file_path
+        recovery_commands = [
+            f"Check file exists: ls -la {file_path}",
+            "Try with different arguments",
+        ]
+    else:
+        recovery_commands = ["Try with different arguments"]
+
+    data = ErrorDisplayData(
+        error_type=f"{tool_name} Error",
+        message=message,
+        suggested_fix=suggested_fix,
+        recovery_commands=recovery_commands,
+        context=context if context else None,
+        severity="error",
+    )
+
+    return RichPanelRenderer.render_error(data)
+
+
+def render_validation_error(
+    field: str,
+    message: str,
+    valid_examples: list[str] | None = None,
+) -> RenderableType:
+    suggested_fix = None
+    if valid_examples:
+        suggested_fix = f"Valid examples: {', '.join(valid_examples[:3])}"
+
+    data = ErrorDisplayData(
+        error_type="Validation Error",
+        message=f"{field}: {message}",
+        suggested_fix=suggested_fix,
+        context={"Field": field},
+        severity="warning",
+    )
+
+    return RichPanelRenderer.render_error(data)
+
+
+def render_connection_error(
+    service: str,
+    message: str,
+    retry_available: bool = True,
+) -> RenderableType:
+    recovery = []
+    if retry_available:
+        recovery.append("Retry the operation")
+    recovery.extend(
+        [
+            "Check network connectivity",
+            f"Verify {service} service status",
+        ]
+    )
+
+    data = ErrorDisplayData(
+        error_type=f"{service} Connection Error",
+        message=message,
+        recovery_commands=recovery,
+        severity="error",
+    )
+
+    return RichPanelRenderer.render_error(data)
+
+
+def render_user_abort() -> RenderableType:
+    data = ErrorDisplayData(
+        error_type="Operation Cancelled",
+        message="User cancelled the operation",
+        severity="info",
+    )
+
+    return RichPanelRenderer.render_error(data)
+
+
+def render_catastrophic_error(exc: Exception, context: str | None = None) -> RenderableType:
+    """Render a user-friendly error when something goes very wrong.
+
+    This is the catch-all error display for unexpected failures.
+    Shows a clear message asking the user to try again.
+    """
+    error_details = str(exc)[:200] if str(exc) else type(exc).__name__
+
+    data = ErrorDisplayData(
+        error_type="Something Went Wrong",
+        message="An unexpected error occurred. Please try again.",
+        suggested_fix="If this persists, check the logs or report the issue.",
+        context={"Details": error_details} if error_details else None,
+        severity="error",
+    )
+
+    return RichPanelRenderer.render_error(data)