vmcode-cli 1.0.0

package/src/ui/displays.py

@@ -0,0 +1,167 @@
+"""UI display functions for command outputs."""
+
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+from llm import config
+
+
+def show_provider_table(current_provider: str, console):
+    """Display provider status table.
+
+    Args:
+        current_provider: Name of the currently active provider.
+        console: Rich Console instance for output.
+    """
+    table = Table("Provider", "Status", "Details", title="Providers", box=box.SIMPLE_HEAD)
+    for provider in config.get_providers():
+        cfg = config.get_provider_config(provider)
+        model = cfg.get('model', 'N/A')
+        if provider == 'local':
+            status = '✅' if cfg.get('model') else '❌ (set model path)'
+        else:
+            status = '✅' if cfg.get('api_key') else '❌ (set API key)'
+        active = ' [green](active)[/green]' if provider == current_provider else ''
+        table.add_row(provider.capitalize(), status, f"{model[:40]}{active}")
+
+    console.print(table)
+
+    help_text = """Usage: /provider <name>
+
+Examples:
+  /provider openrouter
+  /provider glm
+  /provider local
+  /provider gemini
+  /provider minimax
+  /provider anthropic
+  /provider kimi
+
+After switching, use:
+  /key <api_key>     - Set API key for current provider
+  /model <model>     - Set model for current provider"""
+    console.print(Panel(help_text, title="[cyan]Switch Provider[/cyan]"))
+    console.print("")
+
+
+def show_help_table(console):
+    """Display command help table.
+
+    Args:
+        console: Rich Console instance for output.
+    """
+    console.print("")
+    table = Table(show_header=True, box=box.SIMPLE_HEAD)
+    table.add_column("Command", no_wrap=True)
+    table.add_column("Description")
+
+    table.add_row("/help", "Show help")
+    table.add_row("/exit", "Exit chat")
+    table.add_row("/debug", "Toggle debug")
+    table.add_row("/mode", "Toggle Plan/Edit/Learn mode")
+    table.add_row("/logging", "Toggle conversation logging")
+    table.add_row("/preplan", "Toggle pre-tool planning")
+    table.add_row("/config", "Show all configuration settings")
+    table.add_row("/provider [name]", "Switch provider or show provider table")
+    table.add_row("/key <key>", "Set API key for current provider")
+    table.add_row("/model <name>", "Set model for current provider")
+    table.add_row("/usage [provider] [in|out] <cost>", "Set/view provider-specific token cost")
+    table.add_row("/compact [-a]", "Compact context with an AI summary (add -a for aggressive mode)")
+    table.add_row("/init", "Generate agents.md")
+    table.add_row("/edit, /e", "Open editor for multi-line input")
+
+    console.print(Panel(table, title="[bold cyan]Commands[/bold cyan]", border_style="grey23", padding=(0, 2)))
+
+    # Keybinds section
+    console.print()
+    keybinds = Table(show_header=True, box=box.SIMPLE_HEAD)
+    keybinds.add_column("Keybind", no_wrap=True)
+    keybinds.add_column("Action")
+
+    keybinds.add_row("Tab", "Toggle Plan/Edit/Learn mode")
+    keybinds.add_row("Shift+Tab", "Cycle plan/approval/learning mode (mode-dependent)")
+    keybinds.add_row("Ctrl+C", "Interrupt response")
+    keybinds.add_row("Ctrl+C (2x)", "Exit program")
+
+    console.print(Panel(keybinds, title="[bold cyan]Keybinds[/bold cyan]", border_style="grey23", padding=(0, 2)))
+    console.print("")
+
+
+def show_config_overview(chat_manager, console, debug_mode_container, current_provider):
+    """Display comprehensive configuration overview.
+
+    Args:
+        chat_manager: ChatManager instance for runtime state
+        console: Rich Console instance for output
+        debug_mode_container: Dict with 'debug' key for debug mode state
+        current_provider: Name of the currently active provider
+    """
+    from core.config_manager import ConfigManager
+    config_manager = ConfigManager()
+    config_data = config_manager.load()
+
+    console.print()
+    
+    # ===== Runtime Settings =====
+    runtime_table = Table("Setting", "Status", title="Runtime Settings", box=box.SIMPLE_HEAD)
+    debug_status = "[green]ON[/green]" if debug_mode_container.get('debug') else "[dim]OFF[/dim]"
+    runtime_table.add_row("Debug Mode", debug_status)
+    preplan_status = "[green]ON[/green]" if chat_manager.pre_tool_planning_enabled else "[dim]OFF[/dim]"
+    runtime_table.add_row("Pre-tool Planning", preplan_status)
+    logging_status = "[green]ON[/green]" if chat_manager.markdown_logger else "[dim]OFF[/dim]"
+    runtime_table.add_row("Conversation Logging", logging_status)
+    mode_labels = {"edit": "EDIT", "plan": "PLAN", "learn": "LEARN"}
+    mode_colors = {"edit": "green", "plan": "cyan", "learn": "magenta"}
+    mode = chat_manager.interaction_mode
+    mode_color = mode_colors.get(mode, "white")
+    runtime_table.add_row("Interaction Mode", f"[{mode_color}]{mode_labels.get(mode, mode.upper())}[/{mode_color}]")
+    approve_labels = {"safe": "SAFE", "normal": "NORMAL", "danger": "DANGER"}
+    approve_colors = {"safe": "green", "normal": "yellow", "danger": "red"}
+    approve_mode = chat_manager.approve_mode
+    approve_color = approve_colors.get(approve_mode, "white")
+    runtime_table.add_row("Approval Mode", f"[{approve_color}]{approve_labels.get(approve_mode, approve_mode.upper())}[/{approve_color}]")
+    console.print(runtime_table)
+
+    # ===== Provider Settings =====
+    console.print()
+    provider_table = Table("Provider", "Model", "$ in/out", "API Key", title="Providers", box=box.SIMPLE_HEAD)
+
+    active_provider = config_data.get('LAST_PROVIDER', 'Not set').upper()
+    provider_table.add_row("[green]Active[/green]", f"[green]{active_provider}[/green]", "", "")
+
+    def fmt(v, max_len=35):
+        return v[:max_len-3] + "..." if len(v) > max_len else v
+
+    # Local provider
+    local_model = config_data.get('LOCAL_MODEL_PATH', 'Not set')
+    provider_table.add_row("Local", fmt(local_model), "N/A", "N/A")
+
+    # API providers
+    for provider in ["OpenRouter", "GLM", "OpenAI", "Gemini", "MiniMax", "Anthropic", "Kimi"]:
+        model = config_data.get(f'{provider.upper()}_MODEL', 'Not set')
+        key = config_data.get(f'{provider.upper()}_API_KEY', '')
+        key_status = "[green]✓[/green]" if key else "[red]✗[/red]"
+
+        # Check for model-specific pricing
+        model_prices = config_data.get('MODEL_PRICES', {})
+        if model and model in model_prices:
+            cost_in = model_prices[model].get('cost_in', 0)
+            cost_out = model_prices[model].get('cost_out', 0)
+            if cost_in > 0 or cost_out > 0:
+                cost_str = f"${cost_in:.2f}/${cost_out:.2f}"
+            else:
+                cost_str = "Not set"
+        else:
+            cost_str = "Not set"
+
+        provider_table.add_row(provider, fmt(model), cost_str, key_status)
+
+    console.print(provider_table)
+
+    # ===== Quick Commands Reference =====
+    console.print()
+    help_text = """[bold cyan]Commands:[/bold cyan] /provider <name>  /model <path>  /key <key>
+[cyan]         :[/cyan] /usage [provider] [in|out] <$>  /debug  /mode  /logging  /preplan"""
+    console.print(Panel(help_text, title="[cyan]Quick Reference[/cyan]"))
+    console.print()
+

package/src/ui/main.py

@@ -0,0 +1,351 @@
+"""Main entry point for vmCode chatbot."""
+
+import os
+import sys
+import time
+from pathlib import Path
+
+# Add src directory to Python path so we can import llm, core, utils modules
+src_dir = Path(__file__).resolve().parent.parent
+if str(src_dir) not in sys.path:
+    sys.path.insert(0, str(src_dir))
+
+from rich.console import Console
+from rich.theme import Theme
+from rich.markdown import Markdown
+from rich.text import Text
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.formatted_text import ANSI
+from prompt_toolkit.styles import Style
+
+from llm import config
+from llm.config import TOOLS_ENABLED
+from core.chat_manager import ChatManager
+from ui.commands import process_command
+from ui.banner import display_startup_banner
+from ui.prompt_utils import get_bottom_toolbar_text
+from core.agentic import agentic_answer
+from utils.settings import MonokaiDarkBGStyle
+from utils.markdown import left_align_headings
+from exceptions import VmCodeError
+
+# Console setup
+console = Console(theme=Theme({
+    "markdown.hr": "grey50",
+    "markdown.heading": "default",
+    "markdown.h1": "default",
+    "markdown.h2": "default",
+    "markdown.h3": "default",
+    "markdown.h4": "default",
+    "markdown.h5": "default",
+    "markdown.h6": "default",
+}))
+
+# Debug mode container (used as mutable reference)
+DEBUG_MODE_CONTAINER = {'debug': False}
+
+# Ctrl+C exit tracking (for double Ctrl+C to exit)
+CTRL_C_TRACKER = {
+    'last_time': 0,
+    'exit_window': 2.0,  # 2 second window for double Ctrl+C
+    'exit_requested': False
+}
+
+# Path constants
+REPO_ROOT = Path.cwd().resolve()
+APP_ROOT = (
+    Path(sys.executable).resolve().parent
+    if getattr(sys, "frozen", False)
+    else Path(__file__).resolve().parents[2]
+)
+# Platform-agnostic ripgrep path: 'rg' on Unix/Linux, 'rg.exe' on Windows
+RG_EXE_NAME = "rg.exe" if os.name == "nt" else "rg"
+RG_EXE_PATH = (APP_ROOT / "bin" / RG_EXE_NAME).resolve()
+
+
+class ThinkingIndicator:
+    """Simple spinner wrapper that always cleans up."""
+
+    def __init__(self, console, message="Thinking ...", spinner="dots"):
+        self.console = console
+        self.message = message
+        self.spinner = spinner
+        self._status = None
+        self._active = False
+
+    def start(self):
+        if self._status is None:
+            self._status = self.console.status(self.message, spinner=self.spinner, spinner_style="cyan")
+        if not self._active:
+            self._status.start()
+            self._active = True
+
+    def stop(self):
+        if self._status and self._active:
+            self._status.stop()
+            self._active = False
+
+    def pause(self):
+        self.stop()
+
+    def resume(self):
+        self.start()
+
+
+def check_double_ctrl_c() -> bool:
+    """
+    Check if this is a double Ctrl+C (within exit window).
+    Returns True if should exit, False otherwise.
+    Updates the tracker timestamp and exit_requested flag.
+    """
+    # Check if exit was already requested
+    if CTRL_C_TRACKER['exit_requested']:
+        return True
+
+    current_time = time.time()
+    time_since_last = current_time - CTRL_C_TRACKER['last_time']
+
+    if time_since_last <= CTRL_C_TRACKER['exit_window']:
+        # Double Ctrl+C detected - set exit flag and return True
+        CTRL_C_TRACKER['exit_requested'] = True
+        return True
+    else:
+        # First Ctrl+C or too much time passed - update timestamp and continue
+        CTRL_C_TRACKER['last_time'] = current_time
+        return False
+
+
+def main():
+    """Main interactive chat loop."""
+    # Check for config.yaml and provide helpful message if missing
+    config_path = Path(__file__).resolve().parents[1].parent / "config.yaml"
+    config_example = Path(__file__).resolve().parents[1].parent / "config.yaml.example"
+    
+    if not config_path.exists():
+        console.print("\n[yellow]No config.yaml found![/yellow]")
+        console.print("\n[cyan]Getting Started:[/cyan]\n")
+        
+        if config_example.exists():
+            console.print(f"1. Copy the example config:")
+            console.print(f"   [dim]cp config.yaml.example config.yaml[/dim]\n")
+            console.print(f"2. Edit config.yaml and add your API keys\n")
+            console.print(f"3. Or set environment variables:")
+            console.print(f"   [dim]export OPENAI_API_KEY='sk-your-key'[/dim]\n")
+            console.print(f"4. Then run: [green]vmcode[/green]\n")
+            console.print(f"[dim]You can also set keys interactively with: /key <your-key>[/dim]\n")
+        else:
+            console.print("[red]config.yaml.example not found. Please reinstall vmcode.[/red]\n")
+        
+        # Continue anyway - user can set keys via /key command
+        console.print("[yellow]Continuing... You can set API keys with the /key command.[/yellow]\n")
+    
+    chat_manager = ChatManager()
+    thinking_indicator = ThinkingIndicator(console)
+    # Start server if needed
+    console.print("[yellow]Initializing...[/yellow]")
+    chat_manager.server_process = chat_manager.start_server_if_needed()
+    if not chat_manager.server_process and chat_manager.client.provider == "local":
+        console.print("[red]Failed to start local server![/red]")
+        return
+
+    display_startup_banner(chat_manager.approve_mode, chat_manager.interaction_mode)
+
+    # Setup prompt_toolkit with Tab key binding
+    bindings = KeyBindings()
+
+    def get_prompt(chat_manager):
+        """Return colored prompt based on current mode."""
+        if chat_manager.interaction_mode == "plan":
+            prompt_text = Text.assemble(
+                (" Plan", "bold cyan"),
+                (" > ", "white")
+            )
+        elif chat_manager.interaction_mode == "edit":
+            prompt_text = Text.assemble(
+                (" Edit", "green"),
+                (" > ", "white")
+            )
+        else:
+            prompt_text = Text.assemble(
+                (" Learn", "magenta"),
+                (" > ", "white")
+            )         
+        with console.capture() as capture:
+            console.print(prompt_text, end="")
+        return ANSI(capture.get())
+
+    @bindings.add('tab')
+    def toggle_mode(event):
+        """Toggle between Plan and Edit modes."""
+        chat_manager.toggle_interaction_mode()
+        event.app.invalidate()
+
+    @bindings.add('s-tab')
+    def toggle_approve_mode(event):
+        """Toggle plan types (Plan), approval modes (Edit), or learning modes (Learn) using Shift+Tab."""
+        if chat_manager.interaction_mode == "learn":
+            chat_manager.cycle_learning_mode()
+        else:
+            chat_manager.cycle_approve_mode()
+        event.app.invalidate()
+
+    @bindings.add('escape', 'escape')
+    def clear_input(event):
+        """Clear the current input line on double ESC press."""
+        buffer = event.app.current_buffer
+        if buffer is not None:
+            buffer.text = ""
+        event.app.invalidate()
+
+    toolbar_style = Style.from_dict({
+        "bottom-toolbar": "bg:default fg:white noreverse",
+        "bottom-toolbar.text": "bg:default fg:white noreverse",
+    })
+    session = PromptSession(key_bindings=bindings, style=toolbar_style)
+
+    try:
+        while True:
+            # Check if exit was requested via double Ctrl+C
+            if CTRL_C_TRACKER['exit_requested']:
+                break
+
+            try:
+                # Use prompt_toolkit for input with Tab key binding and dynamic prompt
+                prompt_kwargs = {
+                    "bottom_toolbar": lambda: get_bottom_toolbar_text(chat_manager),
+                }
+                user_input = session.prompt(
+                    lambda: get_prompt(chat_manager),
+                    **prompt_kwargs,
+                ).strip()
+
+                if not user_input:
+                    continue
+
+                # Process commands
+                cmd_result, modified_input = process_command(chat_manager, user_input, console, DEBUG_MODE_CONTAINER)
+                if cmd_result == "exit":
+                    break
+                elif cmd_result == "handled":
+                    continue
+
+                # Use modified input if provided (from /edit command)
+                final_input = modified_input if modified_input else user_input
+
+                chat_manager.maybe_auto_compact(console)
+
+                thinking_indicator.start()
+                try:
+                    console.print()  # Extra newline after user input to separate from LLM response
+                    # Add user message
+                    if TOOLS_ENABLED:
+                        chat_manager.command_history.clear()
+                        try:
+                            agentic_answer(
+                                chat_manager,
+                                final_input,
+                                console,
+                                REPO_ROOT,
+                                RG_EXE_PATH,
+                                DEBUG_MODE_CONTAINER['debug'],
+                                thinking_indicator=thinking_indicator,
+                                pre_tool_planning_enabled=chat_manager.pre_tool_planning_enabled,
+                            )
+                            chat_manager._update_context_tokens()
+                        except KeyboardInterrupt:
+                            if not check_double_ctrl_c():
+                                console.print("\n[yellow]Response interrupted (Ctrl+C). Press Ctrl+C again to exit.[/yellow]")
+                            console.print()  # Extra spacing
+                        except VmCodeError as e:
+                            # Handle all vmCode custom exceptions gracefully
+                            console.print(f"[red]Error: {e}[/red]", markup=False)
+                            if hasattr(e, 'details') and e.details:
+                                console.print(f"[dim]Details: {e.details}[/dim]", markup=False)
+                    else:
+                        chat_manager.messages.append({"role": "user", "content": final_input})
+
+                        try:
+                            stream = chat_manager.client.chat_completion(
+                                chat_manager.messages, stream=True
+                            )
+                            if isinstance(stream, str):
+                                console.print(f"[red]Error: {stream}[/red]")
+                                continue
+
+                            try:
+                                # Stream response
+                                chunks = []
+                                usage_data = None
+                                for chunk in stream:
+                                    # Check if this is usage data (final chunk)
+                                    if isinstance(chunk, dict) and '__usage__' in chunk:
+                                        usage_data = chunk['__usage__']
+                                    else:
+                                        chunks.append(chunk)
+                                full_response = "".join(chunks)
+
+                                if full_response.strip():
+                                    md = Markdown(left_align_headings(full_response), code_theme=MonokaiDarkBGStyle, justify="left")
+                                    console.print(md)
+
+                                chat_manager.messages.append(
+                                    {"role": "assistant", "content": full_response}
+                                )
+
+                                # Add usage tracking
+                                if usage_data:
+                                    chat_manager.token_tracker.add_usage(usage_data)
+
+                                chat_manager._update_context_tokens()
+
+                                console.print()  # Extra spacing
+                            except KeyboardInterrupt:
+                                # Ctrl+C pressed during streaming
+                                if not check_double_ctrl_c():
+                                    console.print("\n[yellow]Response interrupted (Ctrl+C). Press Ctrl+C again to exit.[/yellow]")
+                                    # Save partial response
+                                    if chunks:
+                                        partial = "".join(chunks)
+                                        if partial.strip():
+                                            partial_with_note = partial + "\n\n*[Response interrupted]*"
+                                            md = Markdown(left_align_headings(partial_with_note), code_theme=MonokaiDarkBGStyle, justify="left")
+                                            console.print(md)
+                                            chat_manager.messages.append(
+                                                {"role": "assistant", "content": partial}
+                                            )
+                                console.print()  # Extra spacing
+                            finally:
+                                # Ensure HTTP connection is closed
+                                if hasattr(stream, 'close'):
+                                    stream.close()
+
+                        except VmCodeError as e:
+                            # Handle all vmCode custom exceptions gracefully
+                            console.print(f"[red]Error: {e}[/red]", markup=False)
+                            if hasattr(e, 'details') and e.details:
+                                console.print(f"[dim]Details: {e.details}[/dim]", markup=False)
+                        except Exception as e:
+                            console.print(f"[red]Error during generation: {e}[/red]", markup=False)
+                finally:
+                    thinking_indicator.stop()
+
+            except KeyboardInterrupt:
+                # Ctrl+C pressed while waiting for input
+                if check_double_ctrl_c():
+                    break
+                else:
+                    console.print("\n[dim](Press Ctrl+C again to exit, or type 'exit' to quit)[/dim]")
+                    continue
+
+    finally:
+        # Display session summary before cleanup
+        summary = chat_manager.token_tracker.get_session_summary()
+        console.print(f"\n[white]Session Summary: {summary}[/white]")
+
+        chat_manager.cleanup()
+        console.print("[yellow]Goodbye![/yellow]")
+
+
+if __name__ == "__main__":
+    main()

package/src/ui/prompt_utils.py

@@ -0,0 +1,162 @@
+"""Shared prompt utilities for vmCode CLI."""
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
+from prompt_toolkit.formatted_text import HTML
+from llm.config import get_provider_config, APPROVE_MODE_LABELS, LEARNING_MODE_LABELS, PLAN_TYPE_LABELS
+
+
+def get_bottom_toolbar_text(chat_manager):
+    """Return bottom toolbar text with model, approval mode, and token count.
+
+    This is extracted from main.py for reuse in confirmation prompts.
+
+    Args:
+        chat_manager: ChatManager instance for state access
+
+    Returns:
+        HTML formatted toolbar text
+    """
+    provider_name = chat_manager.client.provider
+    model = get_provider_config(provider_name).get("model", "Unknown")
+
+    # Get token counts
+    tokens_curr = chat_manager.token_tracker.current_context_tokens
+    tokens_in = chat_manager.token_tracker.total_prompt_tokens
+    tokens_out = chat_manager.token_tracker.total_completion_tokens
+    tokens_total = chat_manager.token_tracker.total_tokens
+
+    # Format model name (take last part if path)
+    if "\\" in model or "/" in model:
+        model_display = model.split("\\")[-1].split("/")[-1]
+    else:
+        model_display = model
+    
+    # In Plan mode, show plan types
+    if chat_manager.interaction_mode == "plan":
+        plan_type = PLAN_TYPE_LABELS.get(
+            chat_manager.plan_type,
+            chat_manager.plan_type.upper()
+        )
+        # Colorize plan type
+        if chat_manager.plan_type == "feature":
+            plan_type_colored = f'<style fg="cyan">{plan_type}</style>'
+        elif chat_manager.plan_type == "refactor":
+            plan_type_colored = f'<style fg="green">{plan_type}</style>'
+        elif chat_manager.plan_type == "debug":
+            plan_type_colored = f'<style fg="red">{plan_type}</style>'
+        else:  # optimize
+            plan_type_colored = f'<style fg="yellow">{plan_type}</style>'
+
+        return HTML(
+            '<style fg="white">Model: {} | Plan: </style>{}'
+            '<style fg="white"> | </style><style fg="cyan">curr</style><style fg="white">: {:,} | </style>'
+            '<style fg="cyan">in</style><style fg="white">: {:,} | </style>'
+            '<style fg="cyan">out</style><style fg="white">: {:,} | </style>'
+            '<style fg="cyan">total</style><style fg="white">: {:,}</style>'.format(
+                model_display or provider_name,
+                plan_type_colored,
+                tokens_curr,
+                tokens_in,
+                tokens_out,
+                tokens_total
+            )
+        )
+    
+    # In Learn mode, show learning modes instead of approval modes
+    if chat_manager.interaction_mode == "learn":
+        learning_mode = LEARNING_MODE_LABELS.get(
+            chat_manager.learning_mode, 
+            chat_manager.learning_mode.upper()
+        )
+        # Colorize learning mode
+        if chat_manager.learning_mode == "succinct":
+            learning_mode_colored = f'<style fg="cyan">{learning_mode}</style>'
+        elif chat_manager.learning_mode == "balanced":
+            learning_mode_colored = f'<style fg="green">{learning_mode}</style>'
+        else:  # verbose
+            learning_mode_colored = f'<style fg="magenta">{learning_mode}</style>'
+
+        return HTML(
+            '<style fg="white">Model: {} | Learn: </style>{}'
+            '<style fg="white"> | </style><style fg="cyan">curr</style><style fg="white">: {:,} | </style>'
+            '<style fg="cyan">in</style><style fg="white">: {:,} | </style>'
+            '<style fg="cyan">out</style><style fg="white">: {:,} | </style>'
+            '<style fg="cyan">total</style><style fg="white">: {:,}</style>'.format(
+                model_display or provider_name,
+                learning_mode_colored,
+                tokens_curr,
+                tokens_in,
+                tokens_out,
+                tokens_total
+            )
+        )
+    
+    # Show approval modes for Plan/Edit modes
+    approval_mode = APPROVE_MODE_LABELS.get(
+        chat_manager.approve_mode, 
+        chat_manager.approve_mode.upper()
+    )
+    
+    # Colorize approval mode based on type
+    if chat_manager.approve_mode == "safe":
+        approval_mode_colored = f'<style fg="green">{approval_mode}</style>'
+    elif chat_manager.approve_mode == "accept_edits":
+        approval_mode_colored = f'<style fg="yellow">{approval_mode}</style>'
+    else:
+        approval_mode_colored = approval_mode
+    
+    return HTML(
+        '<style fg="white">Model: {} | Approval: </style>{}'
+        '<style fg="white"> | </style><style fg="cyan">curr</style><style fg="white">: {:,} | </style>'
+        '<style fg="cyan">in</style><style fg="white">: {:,} | </style>'
+        '<style fg="cyan">out</style><style fg="white">: {:,} | </style>'
+        '<style fg="cyan">total</style><style fg="white">: {:,}</style>'.format(
+            model_display or provider_name,
+            approval_mode_colored,
+            tokens_curr,
+            tokens_in,
+            tokens_out,
+            tokens_total
+        )
+    )
+
+
+def create_confirmation_prompt_session(chat_manager, message_func):
+    """Create a PromptSession for confirmation prompts with key bindings and toolbar.
+    
+    This provides:
+    - Shift+Tab to toggle approval mode
+    - Bottom toolbar showing model, approval mode, and token counts
+    - Dynamic prompt message that updates when mode changes
+    
+    Args:
+        chat_manager: ChatManager instance for state access
+        message_func: Function that returns the prompt message HTML (called on each redraw)
+        
+    Returns:
+        PromptSession configured with bindings and toolbar
+    """
+    bindings = KeyBindings()
+    
+    @bindings.add('s-tab')
+    def toggle_approve_mode(event):
+        """Toggle between approval modes using Shift+Tab."""
+        if chat_manager.interaction_mode == "learn":
+            chat_manager.cycle_learning_mode()
+        else:
+            chat_manager.cycle_approve_mode()
+        event.app.invalidate()
+    
+    toolbar_style = Style.from_dict({
+        "bottom-toolbar": "bg:default fg:white noreverse",
+        "bottom-toolbar.text": "bg:default fg:white noreverse",
+    })
+    
+    return PromptSession(
+        key_bindings=bindings,
+        style=toolbar_style,
+        bottom_toolbar=lambda: get_bottom_toolbar_text(chat_manager),
+        message=message_func
+    )

package/src/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for vmCode."""