tsugite-cli 0.3.3__py3-none-any.whl

tsugite/cli/history.py

@@ -0,0 +1,193 @@
+"""History management CLI commands."""
+
+import json
+from datetime import datetime
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from tsugite.history import (
+    ConversationMetadata,
+    Turn,
+    get_history_dir,
+    load_conversation,
+    query_index,
+    rebuild_index,
+)
+from tsugite.ui.chat_history import format_conversation_for_display
+
+console = Console()
+
+history_app = typer.Typer(help="Manage conversation history")
+
+
+@history_app.command("list")
+def history_list(
+    machine: str = typer.Option(None, "--machine", help="Filter by machine name"),
+    agent: str = typer.Option(None, "--agent", help="Filter by agent name"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Maximum number of results"),
+):
+    """List conversations with optional filters.
+
+    Examples:
+        tsugite history list
+        tsugite history list --machine laptop
+        tsugite history list --agent chat_assistant --limit 10
+    """
+    try:
+        conversations = query_index(machine=machine, agent=agent, limit=limit)
+
+        if not conversations:
+            console.print("[yellow]No conversations found[/yellow]")
+
+            history_dir = get_history_dir()
+            if not history_dir.exists():
+                console.print(f"\nHistory directory doesn't exist yet: {history_dir}")
+                console.print("Conversations will be saved automatically when you use chat mode.")
+            return
+
+        table = Table(title=f"Conversation History ({len(conversations)} found)")
+        table.add_column("ID", style="cyan", no_wrap=True)
+        table.add_column("Agent", style="green")
+        table.add_column("Machine", style="dim")
+        table.add_column("Turns", justify="right")
+        table.add_column("Tokens", justify="right", style="dim")
+        table.add_column("Updated", style="dim")
+
+        for conv in conversations:
+            conv_id = conv.get("conversation_id", "unknown")
+            agent_name = conv.get("agent", "unknown")
+            machine_name = conv.get("machine", "unknown")
+            turn_count = conv.get("turn_count", 0)
+            total_tokens = conv.get("total_tokens", 0)
+            updated_at = conv.get("updated_at", "unknown")
+
+            # Format date
+            try:
+                dt = datetime.fromisoformat(updated_at)
+                updated_str = dt.strftime("%Y-%m-%d %H:%M")
+            except (ValueError, TypeError):
+                updated_str = updated_at[:16] if len(updated_at) > 16 else updated_at
+
+            table.add_row(
+                conv_id,
+                agent_name,
+                machine_name,
+                str(turn_count),
+                f"{total_tokens:,}" if total_tokens > 0 else "-",
+                updated_str,
+            )
+
+        console.print(table)
+
+        # Show usage hint
+        console.print("\n[dim]Use 'tsugite history show CONVERSATION_ID' to view details[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]Failed to list conversations: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@history_app.command("show")
+def history_show(
+    conversation_id: str = typer.Argument(help="Conversation ID to show"),
+    format: str = typer.Option("plain", "--format", "-f", help="Output format (plain, json, markdown)"),
+):
+    """Show full conversation details.
+
+    Examples:
+        tsugite history show 20251024_103000_chat_abc123
+        tsugite history show 20251024_103000_chat_abc123 --format json
+        tsugite history show 20251024_103000_chat_abc123 --format markdown
+    """
+    try:
+        turns = load_conversation(conversation_id)
+
+        if not turns:
+            console.print(f"[yellow]Conversation '{conversation_id}' is empty[/yellow]")
+            return
+
+        if format == "json":
+            # JSON output - convert Pydantic models to dicts
+            turns_as_dicts = [t.model_dump(mode="json") for t in turns]
+            output = json.dumps(turns_as_dicts, indent=2, ensure_ascii=False)
+            # Use plain print to avoid Rich wrapping that breaks JSON
+            print(output)
+
+        elif format == "markdown":
+            # Markdown output
+            metadata = next((t for t in turns if isinstance(t, ConversationMetadata)), None)
+
+            console.print(f"# Conversation: {conversation_id}\n")
+            if metadata:
+                console.print(f"- **Agent**: {metadata.agent}")
+                console.print(f"- **Model**: {metadata.model}")
+                console.print(f"- **Machine**: {metadata.machine}")
+                console.print(f"- **Created**: {metadata.created_at}\n")
+            console.print("---\n")
+
+            for turn in turns:
+                if isinstance(turn, Turn):
+                    console.print(f"## Turn ({turn.timestamp})\n")
+                    console.print(f"**User**: {turn.user}\n")
+                    console.print(f"**Assistant**: {turn.assistant}\n")
+
+                    if turn.tools:
+                        console.print(f"*Tools*: {', '.join(turn.tools)}\n")
+
+                    # Display execution steps if available
+                    if turn.steps:
+                        console.print("### Execution Steps\n")
+                        for step in turn.steps:
+                            step_num = step.get("step_number", "?")
+                            thought = step.get("thought", "").strip()
+                            code = step.get("code", "").strip()
+                            output = step.get("output", "").strip()
+                            error = step.get("error")
+                            tools_called = step.get("tools_called", [])
+
+                            console.print(f"**Step {step_num}**\n")
+                            if thought:
+                                console.print(f"*Thought*: {thought}\n")
+                            if tools_called:
+                                console.print(f"*Tools used*: {', '.join(tools_called)}\n")
+                            if code:
+                                console.print("*Code*:")
+                                console.print(f"```python\n{code}\n```\n")
+                            if output:
+                                console.print(f"*Output*: {output}\n")
+                            if error:
+                                console.print(f"*Error*: {error}\n")
+
+                    console.print(f"*Tokens*: {turn.tokens or 0} | *Cost*: ${turn.cost or 0.0:.4f}\n")
+                    console.print("---\n")
+
+        else:
+            # Plain text output (default)
+            output = format_conversation_for_display(turns)
+            console.print(output)
+
+    except FileNotFoundError:
+        console.print(f"[red]Conversation '{conversation_id}' not found[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Failed to load conversation: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@history_app.command("rebuild-index")
+def history_rebuild_index():
+    """Rebuild conversation index from JSONL files.
+
+    Scans all conversation files and rebuilds the index.
+    Useful after manual file changes or index corruption.
+    """
+    try:
+        console.print("Rebuilding conversation index...")
+        count = rebuild_index()
+        console.print(f"[green]✓ Indexed {count} conversations[/green]")
+
+    except Exception as e:
+        console.print(f"[red]Failed to rebuild index: {e}[/red]")
+        raise typer.Exit(1)

tsugite/cli/init.py

@@ -0,0 +1,387 @@
+"""Initialization command for first-time setup."""
+
+import logging
+import shutil
+import subprocess
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List, Optional
+
+import questionary
+import typer
+from prompt_toolkit.styles import Style
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from tsugite.config import get_config_path, load_config, save_config
+
+console = Console()
+
+# Custom questionary style for better readability
+# Uses dark background for popup with light text for good contrast
+questionary_style = Style(
+    [
+        ("qmark", "fg:ansicyan bold"),  # Question mark
+        ("question", "bold"),  # Question text
+        ("answer", "fg:ansicyan bold"),  # Selected answer
+        ("pointer", "fg:ansicyan bold"),  # Pointer arrow
+        ("highlighted", "fg:ansiwhite bg:ansiblue"),  # Highlighted choice - white on blue
+        ("selected", "fg:ansicyan"),  # Selected text
+        ("separator", "fg:ansiblack"),  # Separator
+        ("instruction", ""),  # Instructions
+        ("text", ""),  # Default text
+        # Autocomplete-specific styles
+        ("completion-menu", "bg:ansiblack fg:ansiwhite"),  # Popup background
+        ("completion-menu.completion", "fg:ansiwhite bg:ansiblack"),  # Individual items
+        ("completion-menu.completion.current", "fg:ansiblack bg:ansicyan bold"),  # Current selection - black on cyan
+    ]
+)
+
+
+@contextmanager
+def suppress_litellm_warnings():
+    """Temporarily suppress LiteLLM warnings."""
+    litellm_logger = logging.getLogger("LiteLLM")
+    original_level = litellm_logger.level
+    litellm_logger.setLevel(logging.ERROR)
+    try:
+        yield
+    finally:
+        litellm_logger.setLevel(original_level)
+
+
+def detect_ollama() -> bool:
+    """Check if Ollama is running."""
+    try:
+        result = subprocess.run(
+            ["ollama", "list"],
+            capture_output=True,
+            timeout=2,
+            check=False,
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def fetch_provider_models(provider: str) -> List[str]:
+    """Get available models for a provider using LiteLLM.
+
+    Args:
+        provider: Provider name (ollama, openai, anthropic, google)
+
+    Returns:
+        List of model strings in LiteLLM format (e.g., "ollama/qwen2.5-coder:7b")
+    """
+    try:
+        from litellm import get_valid_models
+
+        with suppress_litellm_warnings():
+            # For ollama, check endpoint to get locally installed models
+            if provider == "ollama":
+                models = get_valid_models(
+                    custom_llm_provider="ollama",
+                    check_provider_endpoint=True,
+                )
+            # For cloud providers, get models based on API key presence
+            elif provider == "openai":
+                models = get_valid_models(custom_llm_provider="openai")
+            elif provider == "anthropic":
+                models = get_valid_models(custom_llm_provider="anthropic")
+            elif provider == "google":
+                # Use "gemini" instead of "google" for LiteLLM
+                models = get_valid_models(custom_llm_provider="gemini")
+                # Convert gemini/* to google:* for consistency
+                models = [m.replace("gemini/", "google/") for m in models]
+            else:
+                return []
+
+        return models if models else []
+    except Exception:
+        # Silently return empty list on error
+        return []
+
+
+def litellm_to_tsugite_format(model: str) -> str:
+    """Convert LiteLLM model format to Tsugite format.
+
+    Args:
+        model: Model in LiteLLM format (e.g., "ollama/qwen2.5-coder:7b")
+
+    Returns:
+        Model in Tsugite format (e.g., "ollama:qwen2.5-coder:7b")
+    """
+    # Replace first / with :
+    return model.replace("/", ":", 1)
+
+
+def detect_available_providers() -> dict[str, int]:
+    """Detect which LLM providers are available and count their models.
+
+    Returns:
+        Dict of provider name -> model count (0 if unavailable)
+    """
+    providers = {}
+
+    # Check each provider
+    for provider_name in ["ollama", "openai", "anthropic", "google"]:
+        models = fetch_provider_models(provider_name)
+        providers[provider_name] = len(models)
+
+    return providers
+
+
+def prompt_for_model(providers: dict[str, int], skip_prompt: bool = False, default_model: Optional[str] = None) -> str:
+    """Prompt user to select a provider and then a model with arrow-key navigation.
+
+    Args:
+        providers: Dict of provider name -> model count
+        skip_prompt: If True, auto-select first available provider and model
+        default_model: If provided, skip prompts entirely
+
+    Returns:
+        Model string in Tsugite format (e.g., "ollama:qwen2.5-coder:7b")
+    """
+    if default_model:
+        return default_model
+
+    console.print("\n[bold cyan]Model Selection[/bold cyan]")
+
+    # Filter available providers
+    provider_choices = [(name, count) for name, count in providers.items() if count > 0]
+
+    if not provider_choices:
+        console.print("\n[yellow]No providers detected. You can still configure manually.[/yellow]")
+        if skip_prompt:
+            return "ollama:qwen2.5-coder:7b"
+
+        model = questionary.text(
+            "Enter model string (e.g., 'ollama:qwen2.5-coder:7b', 'openai:gpt-4o-mini'):",
+            default="ollama:qwen2.5-coder:7b",
+            style=questionary_style,
+        ).ask()
+        return model or "ollama:qwen2.5-coder:7b"
+
+    # Loop to allow going back
+    while True:
+        # Step 1: Select Provider
+        if skip_prompt:
+            selected_provider = provider_choices[0][0]
+        else:
+            provider_options = [f"{name} ({count} models)" for name, count in provider_choices]
+
+            selected_display = questionary.select(
+                "Select a provider:",
+                choices=provider_options,
+                style=questionary_style,
+            ).ask()
+
+            if not selected_display:  # User cancelled (Ctrl+C)
+                raise KeyboardInterrupt
+
+            # Extract provider name from display string
+            selected_provider = selected_display.split(" (")[0]
+
+        # Step 2: Select Model from Provider
+        console.print(f"\n[bold cyan]Fetching {selected_provider} models...[/bold cyan]")
+        models = fetch_provider_models(selected_provider)
+
+        if not models:
+            console.print(f"[yellow]No models found for {selected_provider}[/yellow]")
+            if skip_prompt:
+                return f"{selected_provider}:default"
+
+            model = questionary.text(
+                f"Enter {selected_provider} model name:",
+                default="default",
+                style=questionary_style,
+            ).ask()
+            return f"{selected_provider}:{model or 'default'}"
+
+        # Convert to Tsugite format
+        tsugite_models = [litellm_to_tsugite_format(m) for m in models]
+
+        if skip_prompt:
+            return tsugite_models[0]
+
+        # Build model choices with Back option at the end
+        special_choices = ["← Back to provider selection", "✎ Enter custom model name"]
+        model_choices = tsugite_models + special_choices
+
+        # Use autocomplete for searchable/filterable list
+        console.print("\n[dim]💡 Tip: Type to filter models, use arrow keys to navigate[/dim]")
+        selected_model = questionary.autocomplete(
+            f"Select a model from {selected_provider}:",
+            choices=model_choices,
+            match_middle=True,  # Allow matching in middle of string
+            style=questionary_style,
+        ).ask()
+
+        if not selected_model:  # User cancelled
+            raise KeyboardInterrupt
+
+        if selected_model == "← Back to provider selection":
+            # Go back to provider selection
+            continue
+        elif selected_model == "✎ Enter custom model name":
+            # Custom model name
+            model_name = questionary.text(
+                f"Enter {selected_provider} model name:",
+                style=questionary_style,
+            ).ask()
+            if model_name:
+                return f"{selected_provider}:{model_name}"
+            else:
+                continue  # Go back if empty
+        else:
+            # Regular model selected
+            return selected_model
+
+
+def copy_template_agent(config_dir: Path) -> Path:
+    """Copy template assistant agent to config directory."""
+    agents_dir = config_dir / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    template_path = Path(__file__).parent.parent / "templates" / "assistant.md"
+    destination = agents_dir / "assistant.md"
+
+    if not destination.exists():
+        shutil.copy(template_path, destination)
+        console.print(f"[green]✓[/green] Created default agent: {destination}")
+    else:
+        console.print(f"[dim]Agent already exists: {destination}[/dim]")
+
+    return destination
+
+
+def test_setup(model: str, skip_test: bool = False) -> bool:
+    """Run a quick test to verify setup works."""
+    if skip_test:
+        return True
+
+    console.print("\n[bold cyan]Testing Setup[/bold cyan]")
+
+    if not Confirm.ask("Run a quick test?", default=True):
+        return True
+
+    try:
+        from io import StringIO
+
+        from rich.console import Console as RichConsole
+
+        from tsugite.agent_runner import run_agent
+        from tsugite.ui import custom_agent_ui
+
+        # Find the assistant agent
+        config_dir = get_config_path().parent
+        agent_path = config_dir / "agents" / "assistant.md"
+
+        if not agent_path.exists():
+            console.print("[yellow]Warning: Assistant agent not found, skipping test[/yellow]")
+            return False
+
+        console.print("[dim]Running: tsugite run +assistant 'say hello'[/dim]")
+
+        # Create a quiet logger that doesn't output anything
+        quiet_console = RichConsole(file=StringIO())
+        with custom_agent_ui(
+            quiet_console,
+            show_code=False,
+            show_observations=False,
+            show_progress=False,
+            show_llm_messages=False,
+            show_execution_results=False,
+            show_execution_logs=False,
+            show_panels=False,
+        ) as logger:
+            result = run_agent(
+                agent_path=agent_path,
+                prompt="Say hello in one sentence",
+                model_override=model,
+                debug=False,
+                custom_logger=logger,
+            )
+
+        console.print("[green]✓[/green] Test successful!")
+        console.print(
+            f"[dim]Response: {result[:100]}...[/dim]" if len(result) > 100 else f"[dim]Response: {result}[/dim]"
+        )
+        return True
+
+    except Exception as e:
+        console.print(f"[yellow]Warning: Test failed: {e}[/yellow]")
+        console.print("[dim]You can still use tsugite, but you may need to configure your model.[/dim]")
+        return False
+
+
+def init(
+    model: Optional[str] = typer.Option(None, "--model", help="Model to use (skip prompt)"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing configuration"),
+):
+    """Initialize tsugite with global configuration."""
+    from tsugite.cli.helpers import get_logo
+
+    # Show welcome
+    console.print(get_logo(console), style="cyan")
+    console.print()
+    console.print(
+        Panel(
+            "[bold]Welcome to Tsugite![/bold]\n\n"
+            "This wizard will set up your global configuration.\n"
+            "You can reconfigure anytime with: [cyan]tsugite config[/cyan]",
+            border_style="blue",
+            title="First-Time Setup",
+        )
+    )
+
+    # Check if already configured
+    config_path = get_config_path()
+    config = load_config()
+
+    if config_path.exists() and config.default_model and not force:
+        console.print(f"\n[yellow]Configuration already exists at: {config_path}[/yellow]")
+        console.print(f"Current default model: [cyan]{config.default_model}[/cyan]")
+
+        if not Confirm.ask("Reconfigure?", default=False):
+            console.print("\n[dim]Setup cancelled. Use --force to overwrite.[/dim]")
+            return
+
+    # Detect providers
+    console.print("\n[bold cyan]Detecting LLM Providers[/bold cyan]")
+    providers = detect_available_providers()
+
+    # Prompt for model
+    selected_model = prompt_for_model(providers, skip_prompt=bool(model), default_model=model)
+
+    # Create config
+    console.print("\n[bold cyan]Creating Configuration[/bold cyan]")
+    config.default_model = selected_model
+    save_config(config)
+
+    console.print(f"[green]✓[/green] Configuration saved to: [dim]{config_path}[/dim]")
+    console.print(f"[green]✓[/green] Default model: [cyan]{selected_model}[/cyan]")
+
+    # Copy template agent
+    console.print("\n[bold cyan]Setting Up Default Agent[/bold cyan]")
+    config_dir = config_path.parent
+    agent_path = copy_template_agent(config_dir)
+
+    # Show next steps
+    console.print("\n" + "=" * 60)
+    console.print("[bold green]Setup Complete![/bold green]")
+    console.print("=" * 60)
+
+    console.print("\n[bold]Next Steps:[/bold]")
+    console.print("  1. Run the assistant: [cyan]tsugite run +assistant 'your task'[/cyan]")
+    console.print("  2. View configuration: [cyan]tsugite config show[/cyan]")
+    console.print("  3. Explore examples: [cyan]tsugite agents list[/cyan]")
+    console.print(f"  4. Customize your agent: [cyan]{agent_path}[/cyan]")
+
+    console.print("\n[bold]Documentation:[/bold]")
+    console.print("  • Quick start: See README.md")
+    console.print("  • Agent guide: See CLAUDE.md")
+    console.print("  • Examples: See examples/ directory")
+
+    console.print()