major refactor of the deepdrone repo, to be a CLI agent

.env-example

@@ -1,8 +0,0 @@
-# DeepDrone Environment Variables
-# Make a copy of this file and name it '.env', then fill in your API tokens
-
-# Hugging Face API token (required for AI functionality)
-# Get your token at https://huggingface.co/settings/tokens
-HF_TOKEN=your_huggingface_token_here
-
-# Add any additional API keys or environment variables below 

README.md

@@ -1,53 +1,198 @@
----
-title: DeepDrone
-emoji: 🚁
-colorFrom: green
-colorTo: green
-sdk: streamlit
-sdk_version: 1.41.1
-app_file: main.py
-pinned: false
----
+# 🚁 DeepDrone - AI-Powered Drone Control Terminal
 
-# DeepDrone
+A powerful terminal-based application for controlling drones using various AI models including OpenAI, Anthropic, Hugging Face, and local Ollama models. Built with DroneKit integration for real drone control.
 
-A drone chat agent for drone analytics and operations, built on the smolagents framework with DroneKit integration for real drone control.
+## ✨ Features
 
-![DeepDrone Interface](https://i.imgur.com/5ZfQW8i.png)
-![DeepDrone Visualization](https://i.imgur.com/h3zmVIz.png)
+### 🤖 Multi-Model AI Support
+- **OpenAI**: GPT-3.5, GPT-4, and other OpenAI models
+- **Anthropic**: Claude 3 models
+- **Ollama**: Local models (Llama 3.1, Codestral, etc.)
+- **Hugging Face**: Any model available through their API
+- **LiteLLM**: Unified interface for all providers
 
+### 🚁 Drone Control & Operations
+- **Real Drone Control**: Connect to and control real drones using DroneKit
+- **Flight Operations**: Take off, land, navigate to GPS coordinates
+- **Mission Planning**: Execute complex waypoint missions
+- **Safety Features**: Return to home, emergency stop
+- **Telemetry**: Monitor battery, location, and flight status
 
-## Features
+### 💻 Terminal Interface
+- **Rich CLI**: Beautiful command-line interface with colors and formatting
+- **Interactive Chat**: Natural language conversation with AI models
+- **Model Management**: Easy switching between different AI models
+- **Configuration**: Persistent settings and API key management
 
-- **Drone Chat**: Interact with a drone assistant through a chat interface
-- **Visualizations**: Generate flight paths and sensor readings visualizations
-- **Maintenance Recommendations**: Get maintenance suggestions based on flight hours
-- **Mission Planning**: Generate mission plans for various drone operations
-- **Real Drone Control**: Connect to and control real drones using DroneKit
-  - Take off and land
-  - Navigate to GPS coordinates
-  - Return to home
-  - Execute waypoint missions
-  - Monitor battery and location
+## 🚀 Quick Start
 
-## Getting Started
+### Installation
 
-1. Clone this repository
-2. Copy `.env-example` to `.env` and add your Hugging Face API token
-3. Install dependencies: `pip install -r requirements.txt`
-4. **For Python 3.10+ users**: Run the compatibility patch: `python dronekit_patch.py`
-5. Run the application: `streamlit run main.py`
+1. **Clone the repository**
+   ```bash
+   git clone <repository-url>
+   cd deepdrone
+   ```
 
-## Using DroneKit Integration
+2. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
 
-The DroneKit integration allows you to control drones running ArduPilot or PX4 firmware.
+3. **Start the interactive session**
+   ```bash
+   python main.py
+   ```
 
-### Python 3.10+ Compatibility
+### Interactive Setup
+
+When you run `python main.py`, DeepDrone will guide you through:
+
+1. **🔮 Provider Selection** - Choose from OpenAI, Anthropic, Google, Meta, Mistral, or Ollama
+2. **🤖 Model Selection** - Pick from popular models or enter your own
+3. **🔑 API Key Entry** - Securely enter your API credentials (Ollama skips this)
+4. **✅ Connection Test** - Verify everything works
+5. **🚁 Simulator Setup** - Instructions for drone connection
+6. **💬 Chat Interface** - Start controlling your drone with natural language
+
+### Command Line Usage (Advanced)
+
+For advanced users who prefer command-line options:
+
+```bash
+# List available models
+python main.py models list
+
+# Add API keys for cloud models
+python main.py models set-key gpt-3.5-turbo
+
+# Start a specific chat session
+python main.py chat -m gpt-3.5-turbo
+
+# Check Ollama models (for local AI)
+python main.py ollama check
 
-If you're using Python 3.10 or newer, you need to run the patch script before using DroneKit:
+# View configuration
+python main.py config
+```
+
+## 🛠️ Configuration
+
+### Setting Up AI Models
+
+#### OpenAI Models
+```bash
+# Add your OpenAI API key
+python main.py models set-key gpt-3.5-turbo
+# Get API key from: https://platform.openai.com/api-keys
+```
+
+#### Anthropic Models
+```bash
+# Add your Anthropic API key
+python main.py models set-key claude-3-sonnet
+# Get API key from: https://console.anthropic.com/
+```
 
+#### Local Ollama Models
+```bash
+# First install and run Ollama: https://ollama.ai
+ollama pull llama3.1
+ollama pull codestral
+
+# Check available models
+python main.py ollama check
 ```
-python dronekit_patch.py
+
+### Drone Connection
+
+#### Using the Built-in Simulator
+
+**🎯 Quick Start:**
+1. Open a new terminal and run:
+   ```bash
+   python simulate_drone.py
+   ```
+2. The simulator will display a connection string like `udp:127.0.0.1:14550`
+3. In DeepDrone chat, use that connection string to connect
+
+#### Real Drone Connections
+
+For real drones:
+- **Serial**: `/dev/ttyACM0` (Linux) or `COM3` (Windows)
+- **TCP**: `tcp:192.168.1.100:5760`
+- **UDP**: `udp:127.0.0.1:14550`
+
+#### Professional Simulation
+
+For advanced simulation, install ArduPilot SITL:
+```bash
+# Get installation help
+python simulate_drone.py --install-help
+```
+
+## 🎯 Usage Examples
+
+### Basic Chat
+```bash
+# Start chat with GPT-3.5
+python main.py chat -m gpt-3.5-turbo
+
+# Start chat with local Ollama model
+python main.py chat -m llama3.1
+```
+
+### Interactive Chat Session
+
+Once in the chat interface, you can control your drone with natural language:
+
+```
+╭─────────────── DeepDrone Control Center ───────────────╮
+│ 🚁 DEEPDRONE CHAT INTERFACE                           │
+│                                                        │
+│ AI Model: claude-3-5-sonnet (anthropic)               │
+│ Drone Connection: udp:127.0.0.1:14550                 │
+│ Status: Ready for commands                             │
+╰────────────────────────────────────────────────────────╯
+
+🚁 DeepDrone> Connect to the drone simulator and take off to 30 meters
+
+🤖 DeepDrone AI: I'll connect to the simulator and take off to 30 meters...
+[Executes Python code to control drone]
+✅ Connected and airborne at 30 meters!
+
+🚁 DeepDrone> Fly in a square pattern with 50 meter sides
+
+🤖 DeepDrone AI: I'll create a square flight pattern...
+[Plans and executes waypoint mission]
+✅ Square pattern completed!
+
+🚁 DeepDrone> Return home and land
+
+🤖 DeepDrone AI: Returning to launch point and landing safely...
+✅ Mission complete, drone landed safely!
+```
+
+### Model Management
+```bash
+# Add a custom model
+python main.py models add my-gpt4 openai gpt-4 --max-tokens 4096
+
+# Remove a model
+python main.py models remove my-gpt4
+
+# View configuration
+python main.py config
+```
+
+## 🛡️ DroneKit Integration
+
+### Python 3.10+ Compatibility
+
+If you're using Python 3.10 or newer, run the patch script:
+
+```bash
+python drone/dronekit_patch.py
 ```
 
 This script fixes the "AttributeError: module 'collections' has no attribute 'MutableMapping'" error by patching the DroneKit library to use collections.abc instead of collections.

drone/__init__.py

@@ -4,9 +4,11 @@ Drone control and interface module.
 This package contains all the drone-related functionality including:
 - DroneKit integration
 - Drone control and mission planning
-- Chat interface for natural language interactions with the drone
+- Terminal interface for natural language interactions with the drone
+- LiteLLM and Ollama integration for various AI models
 """
 
 # Import main components for easier access
 from .drone_control import DroneController, connect_drone, disconnect_drone, takeoff, land, return_home
-from .drone_chat import DroneAssistant, generate_mission_plan 
+from .config import config_manager
+from .drone_tools import DroneToolsManager 

drone/cli.py

@@ -0,0 +1,280 @@
+"""
+Command Line Interface for DeepDrone terminal application.
+"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich import print as rprint
+from typing import Optional
+import getpass
+
+from .config import config_manager, ModelConfig
+# Import will be done inside functions to avoid circular imports
+
+app = typer.Typer(
+    name="deepdrone",
+    help="🚁 DeepDrone - AI-Powered Drone Control Terminal",
+    add_completion=False
+)
+
+console = Console()
+
+@app.command()
+def chat(
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Model to use for chat"),
+    connection: Optional[str] = typer.Option(None, "--connection", "-c", help="Drone connection string")
+):
+    """Start interactive chat with drone AI."""
+    
+    # Show welcome banner
+    console.print(Panel.fit(
+        "[bold green]🚁 DEEPDRONE TERMINAL[/bold green]\n"
+        "[dim]AI-Powered Drone Control System[/dim]",
+        border_style="bright_green"
+    ))
+    
+    # Select model if not provided
+    if not model:
+        model = select_model()
+        if not model:
+            return
+    
+    # Validate model exists
+    model_config = config_manager.get_model(model)
+    if not model_config:
+        console.print(f"[red]Error: Model '{model}' not found[/red]")
+        console.print("Use 'deepdrone models list' to see available models")
+        return
+    
+    # Check if model needs API key
+    if model_config.provider in ["openai", "anthropic", "huggingface"] and not model_config.api_key:
+        console.print(f"[yellow]Model '{model}' requires an API key[/yellow]")
+        if Confirm.ask("Would you like to set it now?"):
+            set_api_key_interactive(model)
+            # Reload model config after setting API key
+            model_config = config_manager.get_model(model)
+    
+    # Start chat
+    try:
+        from .terminal_chat import TerminalDroneChat
+        chat_session = TerminalDroneChat(model_config, connection)
+        chat_session.start()
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Chat session ended[/yellow]")
+    except Exception as e:
+        console.print(f"[red]Error starting chat: {e}[/red]")
+
+# Create models subcommand group
+models_app = typer.Typer(help="Manage AI models")
+app.add_typer(models_app, name="models")
+
+@models_app.command("list")
+def list_models():
+    """List all available models."""
+    models = config_manager.list_models()
+    
+    if not models:
+        console.print("[yellow]No models configured[/yellow]")
+        return
+    
+    table = Table(title="Available Models")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Provider", style="magenta")
+    table.add_column("Model ID", style="blue")
+    table.add_column("API Key", style="green")
+    table.add_column("Status", style="yellow")
+    
+    for name in models:
+        config = config_manager.get_model(name)
+        api_key_status = "✓" if config.api_key else "✗"
+        
+        # Check status
+        if config.provider == "ollama":
+            status = "Local"
+        elif config.api_key:
+            status = "Ready"
+        else:
+            status = "Needs API Key"
+        
+        table.add_row(
+            name,
+            config.provider,
+            config.model_id,
+            api_key_status,
+            status
+        )
+    
+    console.print(table)
+    
+    # Show usage hint
+    console.print("\n[dim]Use 'deepdrone chat -m <model_name>' to start chatting[/dim]")
+
+@models_app.command("add")
+def add_model(
+    name: str = typer.Argument(..., help="Name for the model"),
+    provider: str = typer.Argument(..., help="Provider (openai, anthropic, ollama, etc.)"),
+    model_id: str = typer.Argument(..., help="Model ID/identifier"),
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="Base URL for API"),
+    max_tokens: int = typer.Option(2048, "--max-tokens", help="Maximum tokens"),
+    temperature: float = typer.Option(0.7, "--temperature", help="Temperature setting")
+):
+    """Add a new model configuration."""
+    
+    model_config = ModelConfig(
+        name=name,
+        provider=provider,
+        model_id=model_id,
+        base_url=base_url,
+        max_tokens=max_tokens,
+        temperature=temperature
+    )
+    
+    config_manager.add_model(model_config)
+    console.print(f"[green]Model '{name}' added successfully[/green]")
+    
+    # Ask for API key if needed
+    if provider in ["openai", "anthropic", "huggingface"]:
+        if Confirm.ask(f"Would you like to set the API key for '{name}' now?"):
+            set_api_key_interactive(name)
+
+@models_app.command("remove")
+def remove_model(name: str = typer.Argument(..., help="Name of model to remove")):
+    """Remove a model configuration."""
+    
+    if not config_manager.get_model(name):
+        console.print(f"[red]Model '{name}' not found[/red]")
+        return
+    
+    if Confirm.ask(f"Are you sure you want to remove model '{name}'?"):
+        if config_manager.remove_model(name):
+            console.print(f"[green]Model '{name}' removed successfully[/green]")
+        else:
+            console.print(f"[red]Failed to remove model '{name}'[/red]")
+
+@models_app.command("set-key")
+def set_api_key(
+    model: str = typer.Argument(..., help="Model name"),
+    key: Optional[str] = typer.Option(None, "--key", help="API key (will prompt if not provided)")
+):
+    """Set API key for a model."""
+    set_api_key_interactive(model, key)
+
+@app.command("config")
+def show_config():
+    """Show current configuration."""
+    
+    console.print(Panel.fit(
+        f"[bold]Configuration Directory:[/bold] {config_manager.settings.config_dir}\n"
+        f"[bold]Models File:[/bold] {config_manager.settings.models_file}\n"
+        f"[bold]Default Model:[/bold] {config_manager.settings.default_model}\n"
+        f"[bold]Default Connection:[/bold] {config_manager.settings.drone.default_connection_string}",
+        title="DeepDrone Configuration",
+        border_style="blue"
+    ))
+
+# Create ollama subcommand group
+ollama_app = typer.Typer(help="Ollama-specific commands")
+app.add_typer(ollama_app, name="ollama")
+
+@ollama_app.command("check")
+def check_ollama():
+    """Check if Ollama is running and list available models."""
+    try:
+        import ollama
+        
+        # Try to connect to Ollama
+        models = ollama.list()
+        
+        if not hasattr(models, 'models') or not models.models:
+            console.print("[yellow]Ollama is running but no models are installed[/yellow]")
+            console.print("Install a model with: ollama pull llama3.1")
+            return
+            
+        table = Table(title="Ollama Models")
+        table.add_column("Name", style="cyan")
+        table.add_column("Size", style="blue")
+        table.add_column("Modified", style="green")
+        
+        for model in models.models:
+            table.add_row(
+                model.model,
+                f"{model.size / (1024**3):.1f} GB" if hasattr(model, 'size') else "Unknown",
+                str(model.modified_at)[:19] if hasattr(model, 'modified_at') else 'Unknown'
+            )
+        
+        console.print(table)
+        console.print("\n[dim]Use 'deepdrone models add <name> ollama <model_name>' to add to DeepDrone[/dim]")
+        
+    except ImportError:
+        console.print("[red]Ollama Python package not installed[/red]")
+        console.print("Install with: pip install ollama")
+    except Exception as e:
+        console.print(f"[red]Error connecting to Ollama: {e}[/red]")
+        console.print("Make sure Ollama is running: ollama serve")
+
+def select_model() -> Optional[str]:
+    """Interactive model selection."""
+    models = config_manager.list_models()
+    
+    if not models:
+        console.print("[red]No models configured[/red]")
+        console.print("Use 'deepdrone models add' to add a model")
+        return None
+    
+    console.print("\n[bold]Available Models:[/bold]")
+    for i, model_name in enumerate(models, 1):
+        config = config_manager.get_model(model_name)
+        status = "✓" if config.api_key or config.provider == "ollama" else "⚠ (needs API key)"
+        console.print(f"  {i}. {model_name} ({config.provider}) {status}")
+    
+    while True:
+        try:
+            choice = Prompt.ask(
+                "\nSelect model",
+                choices=[str(i) for i in range(1, len(models) + 1)] + models,
+                default="1"
+            )
+            
+            if choice.isdigit():
+                return models[int(choice) - 1]
+            elif choice in models:
+                return choice
+        except (ValueError, IndexError):
+            console.print("[red]Invalid selection[/red]")
+
+def set_api_key_interactive(model_name: str, api_key: Optional[str] = None):
+    """Set API key interactively."""
+    model_config = config_manager.get_model(model_name)
+    if not model_config:
+        console.print(f"[red]Model '{model_name}' not found[/red]")
+        return
+    
+    if model_config.provider == "ollama":
+        console.print(f"[yellow]Model '{model_name}' is an Ollama model and doesn't need an API key[/yellow]")
+        return
+    
+    if not api_key:
+        console.print(f"\n[bold]Setting API key for {model_name} ({model_config.provider})[/bold]")
+        
+        if model_config.provider == "openai":
+            console.print("Get your OpenAI API key from: https://platform.openai.com/api-keys")
+        elif model_config.provider == "anthropic":
+            console.print("Get your Anthropic API key from: https://console.anthropic.com/")
+        elif model_config.provider == "huggingface":
+            console.print("Get your Hugging Face token from: https://huggingface.co/settings/tokens")
+        
+        api_key = getpass.getpass("Enter API key (hidden): ")
+    
+    if api_key.strip():
+        if config_manager.set_api_key(model_name, api_key.strip()):
+            console.print(f"[green]API key set for '{model_name}'[/green]")
+        else:
+            console.print(f"[red]Failed to set API key for '{model_name}'[/red]")
+    else:
+        console.print("[yellow]No API key provided[/yellow]")
+
+if __name__ == "__main__":
+    app()

drone/config.py

@@ -0,0 +1,183 @@
+"""
+Configuration management for DeepDrone terminal application.
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Dict, Optional, List
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
+class ModelConfig(BaseModel):
+    """Configuration for a specific model."""
+    name: str
+    provider: str  # 'openai', 'anthropic', 'ollama', 'huggingface', etc.
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    model_id: str
+    max_tokens: int = 2048
+    temperature: float = 0.7
+
+class DroneConfig(BaseModel):
+    """Configuration for drone connection."""
+    default_connection_string: str = "udp:127.0.0.1:14550"
+    timeout: int = 30
+    default_altitude: float = 30.0
+    max_altitude: float = 100.0
+
+class AppSettings(BaseSettings):
+    """Main application settings."""
+    
+    # File paths
+    config_dir: Path = Field(default_factory=lambda: Path.home() / ".deepdrone")
+    models_file: Path = Field(default_factory=lambda: Path.home() / ".deepdrone" / "models.json")
+    
+    # Default model
+    default_model: str = "gpt-3.5-turbo"
+    
+    # Drone settings
+    drone: DroneConfig = Field(default_factory=DroneConfig)
+    
+    # Terminal settings
+    show_thinking: bool = True
+    auto_save_chat: bool = True
+    chat_history_limit: int = 100
+    
+    class Config:
+        env_prefix = "DEEPDRONE_"
+        env_file = ".env"
+        extra = "ignore"  # Ignore extra environment variables
+
+class ConfigManager:
+    """Manages application configuration and model settings."""
+    
+    def __init__(self):
+        self.settings = AppSettings()
+        self.models: Dict[str, ModelConfig] = {}
+        self._ensure_config_dir()
+        self._load_models()
+    
+    def _ensure_config_dir(self):
+        """Ensure configuration directory exists."""
+        self.settings.config_dir.mkdir(exist_ok=True)
+    
+    def _load_models(self):
+        """Load model configurations from file."""
+        if self.settings.models_file.exists():
+            try:
+                with open(self.settings.models_file, 'r') as f:
+                    models_data = json.load(f)
+                    self.models = {
+                        name: ModelConfig(**config)
+                        for name, config in models_data.items()
+                    }
+            except Exception as e:
+                print(f"Error loading models config: {e}")
+                self.models = {}
+        else:
+            # Create default models
+            self._create_default_models()
+    
+    def _create_default_models(self):
+        """Create default model configurations."""
+        self.models = {
+            "gpt-3.5-turbo": ModelConfig(
+                name="gpt-3.5-turbo",
+                provider="openai",
+                model_id="gpt-3.5-turbo",
+                max_tokens=2048,
+                temperature=0.7
+            ),
+            "gpt-4": ModelConfig(
+                name="gpt-4",
+                provider="openai", 
+                model_id="gpt-4",
+                max_tokens=2048,
+                temperature=0.7
+            ),
+            "claude-3-sonnet": ModelConfig(
+                name="claude-3-sonnet",
+                provider="anthropic",
+                model_id="claude-3-sonnet-20240229",
+                max_tokens=2048,
+                temperature=0.7
+            ),
+            "llama3.1": ModelConfig(
+                name="llama3.1",
+                provider="ollama",
+                model_id="llama3.1:latest",
+                base_url="http://localhost:11434",
+                max_tokens=2048,
+                temperature=0.7
+            ),
+            "codestral": ModelConfig(
+                name="codestral",
+                provider="ollama",
+                model_id="codestral:latest",
+                base_url="http://localhost:11434",
+                max_tokens=2048,
+                temperature=0.7
+            )
+        }
+        self.save_models()
+    
+    def save_models(self):
+        """Save model configurations to file."""
+        try:
+            models_data = {
+                name: config.model_dump()
+                for name, config in self.models.items()
+            }
+            with open(self.settings.models_file, 'w') as f:
+                json.dump(models_data, f, indent=2)
+        except Exception as e:
+            print(f"Error saving models config: {e}")
+    
+    def add_model(self, config: ModelConfig):
+        """Add a new model configuration."""
+        self.models[config.name] = config
+        self.save_models()
+    
+    def remove_model(self, name: str) -> bool:
+        """Remove a model configuration."""
+        if name in self.models:
+            del self.models[name]
+            self.save_models()
+            return True
+        return False
+    
+    def get_model(self, name: str) -> Optional[ModelConfig]:
+        """Get a model configuration by name."""
+        return self.models.get(name)
+    
+    def list_models(self) -> List[str]:
+        """List all available model names."""
+        return list(self.models.keys())
+    
+    def set_api_key(self, model_name: str, api_key: str) -> bool:
+        """Set API key for a model."""
+        if model_name in self.models:
+            self.models[model_name].api_key = api_key
+            self.save_models()
+            return True
+        return False
+    
+    def get_ollama_models(self) -> List[str]:
+        """Get list of available Ollama models."""
+        ollama_models = []
+        for name, config in self.models.items():
+            if config.provider == "ollama":
+                ollama_models.append(name)
+        return ollama_models
+    
+    def get_api_models(self) -> List[str]:
+        """Get list of models that require API keys."""
+        api_models = []
+        for name, config in self.models.items():
+            if config.provider in ["openai", "anthropic", "huggingface"]:
+                api_models.append(name)
+        return api_models
+
+# Global config manager instance
+config_manager = ConfigManager()

drone/drone_chat_interface.py

@@ -0,0 +1,543 @@
+"""
+Interactive drone chat interface - similar to Claude Code environment.
+"""
+
+import os
+import sys
+import time
+import threading
+from typing import List, Dict, Any, Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.markdown import Markdown
+from rich.layout import Layout
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.table import Table
+from rich.align import Align
+from prompt_toolkit import prompt
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.styles import Style
+from prompt_toolkit.shortcuts import confirm
+import re
+
+from .config import ModelConfig
+from .llm_interface import LLMInterface
+from .drone_tools import DroneToolsManager
+
+class DroneChatInterface:
+    """Interactive chat interface for drone control with AI."""
+    
+    def __init__(self, model_config: ModelConfig, connection_string: Optional[str] = None):
+        self.console = Console()
+        self.model_config = model_config
+        self.connection_string = connection_string or "udp:127.0.0.1:14550"
+        
+        # Initialize components
+        self.llm = LLMInterface(model_config)
+        self.drone_tools = DroneToolsManager(self.connection_string)
+        
+        # Chat state
+        self.chat_history: List[Dict[str, str]] = []
+        self.session_active = True
+        
+        # Setup prompt components
+        self.history = InMemoryHistory()
+        self.completer = WordCompleter([
+            'connect', 'takeoff', 'land', 'fly', 'goto', 'mission', 'status',
+            'battery', 'location', 'return', 'home', 'help', 'quit', 'exit',
+            'emergency', 'stop', 'altitude', 'waypoint', 'navigate'
+        ])
+        
+        self.style = Style.from_dict({
+            'prompt': '#00ff00 bold',
+            'input': '#ffffff',
+            'completion-menu.completion': 'bg:#333333 #ffffff',
+            'completion-menu.completion.current': 'bg:#00ff00 #000000 bold',
+        })
+        
+        # Status tracking
+        self.last_status_update = time.time()
+        self.status_thread = None
+        self.status_running = False
+    
+    def start(self):
+        """Start the interactive chat session."""
+        self._show_welcome()
+        self._start_status_monitor()
+        
+        try:
+            while self.session_active:
+                try:
+                    # Get user input
+                    user_input = self._get_user_input()
+                    
+                    if not user_input.strip():
+                        continue
+                    
+                    # Handle special commands
+                    if self._handle_special_commands(user_input):
+                        continue
+                    
+                    # Process the message
+                    self._process_message(user_input)
+                    
+                except KeyboardInterrupt:
+                    self._handle_exit()
+                    break
+                except EOFError:
+                    self._handle_exit()
+                    break
+                    
+        finally:
+            self._cleanup()
+    
+    def _show_welcome(self):
+        """Show welcome message and status."""
+        welcome_panel = Panel(
+            f"""[bold green]🚁 DEEPDRONE CHAT INTERFACE[/bold green]
+
+[bold]AI Model:[/bold] {self.model_config.name} ({self.model_config.provider})
+[bold]Model ID:[/bold] {self.model_config.model_id}
+[bold]Drone Connection:[/bold] {self.connection_string}
+[bold]Status:[/bold] Ready for commands
+
+[bold cyan]🎯 Available Commands:[/bold cyan]
+• Natural language: "Connect to drone and take off to 30 meters"
+• Status commands: "Show battery status", "What's my location?"
+• Mission commands: "Fly in a square pattern", "Return home"
+• Help: Type 'help' for more information
+• Exit: Type 'quit' or 'exit' to end session
+
+[dim]Type your commands below. The AI will interpret and execute drone operations.[/dim]""",
+            title="[bold green]DeepDrone Control Center[/bold green]",
+            border_style="bright_green",
+            padding=(1, 2)
+        )
+        
+        self.console.print(welcome_panel)
+        self.console.print()
+    
+    def _get_user_input(self) -> str:
+        """Get user input."""
+        try:
+            # Use simple input() for better compatibility
+            return input("🚁 DeepDrone> ")
+        except (KeyboardInterrupt, EOFError):
+            return '/quit'
+    
+    def _handle_special_commands(self, command: str) -> bool:
+        """Handle special commands. Returns True if handled."""
+        cmd = command.strip().lower()
+        
+        if cmd in ['/quit', '/exit', 'quit', 'exit']:
+            self.session_active = False
+            return True
+        
+        elif cmd in ['/help', 'help']:
+            self._show_help()
+            return True
+        
+        elif cmd in ['/status', 'status']:
+            self._show_detailed_status()
+            return True
+        
+        elif cmd in ['/clear', 'clear']:
+            self.console.clear()
+            self._show_welcome()
+            return True
+        
+        elif cmd.startswith('/connect'):
+            parts = cmd.split()
+            if len(parts) > 1:
+                self.connection_string = parts[1]
+                self._connect_drone_direct()
+            else:
+                self.console.print("[red]Usage: /connect <connection_string>[/red]")
+            return True
+        
+        elif cmd in ['/disconnect', 'disconnect']:
+            self._disconnect_drone_direct()
+            return True
+        
+        elif cmd in ['/emergency', 'emergency']:
+            self._emergency_stop()
+            return True
+        
+        elif cmd in ['/ollama', 'ollama']:
+            self._show_ollama_status()
+            return True
+        
+        return False
+    
+    def _process_message(self, user_message: str):
+        """Process user message with AI and execute drone commands."""
+        # Add to history
+        self.chat_history.append({"role": "user", "content": user_message})
+        
+        # Show user message
+        self.console.print(Panel(
+            user_message,
+            title="[bold blue]You[/bold blue]",
+            border_style="blue",
+            padding=(0, 1)
+        ))
+        
+        # Generate AI response
+        with Live(
+            Spinner("dots", text="[green]🤖 AI is analyzing your request...[/green]"),
+            console=self.console,
+            transient=True
+        ) as live:
+            
+            try:
+                # Create system prompt for drone operations
+                system_prompt = self._create_drone_system_prompt()
+                
+                # Prepare messages for AI
+                messages = [{"role": "system", "content": system_prompt}]
+                messages.extend(self.chat_history[-10:])  # Last 10 messages for context
+                
+                # Get AI response
+                ai_response = self.llm.chat(messages)
+                
+                live.stop()
+                
+                # Process the response for drone commands
+                self._process_ai_response(ai_response)
+                
+                # Add to history
+                self.chat_history.append({"role": "assistant", "content": ai_response})
+                
+            except Exception as e:
+                live.stop()
+                self.console.print(f"[red]❌ Error processing request: {e}[/red]")
+    
+    def _create_drone_system_prompt(self) -> str:
+        """Create system prompt for drone operations."""
+        return f"""You are DeepDrone AI, an advanced drone control assistant. You can control real drones through Python code.
+
+Current drone status:
+- Connected: {'Yes' if self.drone_tools.is_connected() else 'No'}
+- Connection: {self.connection_string}
+- Mission active: {'Yes' if self.drone_tools.mission_in_progress else 'No'}
+
+Available drone functions (use these in Python code blocks):
+- connect_drone(connection_string): Connect to drone
+- takeoff(altitude): Take off to specified altitude in meters
+- land(): Land the drone
+- return_home(): Return to launch point
+- fly_to(lat, lon, alt): Fly to GPS coordinates
+- get_location(): Get current GPS position
+- get_battery(): Get battery status
+- execute_mission(waypoints): Execute mission with waypoints list
+- disconnect_drone(): Disconnect from drone
+
+When user asks for drone operations:
+1. Explain what you'll do
+2. Provide Python code in ```python code blocks
+3. The code will be executed automatically
+4. Provide status updates
+
+Example response:
+"I'll connect to the drone and take off to 30 meters altitude.
+
+```python
+# Connect to the drone
+connect_drone('{self.connection_string}')
+
+# Take off to 30 meters
+takeoff(30)
+
+# Get status
+location = get_location()
+battery = get_battery()
+print(f"Location: {{location}}")
+print(f"Battery: {{battery}}")
+```
+
+The drone should now be airborne at 30 meters altitude."
+
+Always prioritize safety and explain each operation clearly."""
+    
+    def _process_ai_response(self, response: str):
+        """Process AI response and execute any drone commands."""
+        # Show AI response
+        if any(marker in response for marker in ['**', '*', '```', '#', '-', '1.']):
+            content = Markdown(response)
+        else:
+            content = Text(response)
+        
+        self.console.print(Panel(
+            content,
+            title="[bold green]🤖 DeepDrone AI[/bold green]",
+            border_style="green",
+            padding=(0, 1)
+        ))
+        
+        # Extract and execute Python code blocks
+        code_blocks = self._extract_code_blocks(response)
+        if code_blocks:
+            self.console.print(Panel(
+                "[yellow]🔧 Executing drone operations...[/yellow]",
+                border_style="yellow"
+            ))
+            
+            for i, code in enumerate(code_blocks, 1):
+                self.console.print(f"[dim]Executing code block {i}...[/dim]")
+                try:
+                    result = self._execute_drone_code(code)
+                    if result:
+                        self.console.print(Panel(
+                            f"[green]✅ Execution Result:[/green]\n{result}",
+                            border_style="green"
+                        ))
+                except Exception as e:
+                    self.console.print(Panel(
+                        f"[red]❌ Execution Error:[/red]\n{str(e)}",
+                        border_style="red"
+                    ))
+    
+    def _extract_code_blocks(self, text: str) -> List[str]:
+        """Extract Python code blocks from markdown text."""
+        pattern = r'```(?:python)?\n(.*?)\n```'
+        matches = re.findall(pattern, text, re.DOTALL)
+        return [match.strip() for match in matches if match.strip()]
+    
+    def _execute_drone_code(self, code: str) -> str:
+        """Execute drone code safely."""
+        # Create safe execution environment
+        safe_globals = {
+            '__builtins__': {
+                'print': print,
+                'len': len,
+                'str': str,
+                'int': int,
+                'float': float,
+                'dict': dict,
+                'list': list,
+                'range': range,
+            },
+            'connect_drone': self.drone_tools.connect_drone,
+            'disconnect_drone': self.drone_tools.disconnect_drone,
+            'takeoff': self.drone_tools.takeoff,
+            'land': self.drone_tools.land,
+            'return_home': self.drone_tools.return_home,
+            'fly_to': self.drone_tools.fly_to,
+            'get_location': self.drone_tools.get_location,
+            'get_battery': self.drone_tools.get_battery,
+            'execute_mission': self.drone_tools.execute_mission,
+            'time': time,
+        }
+        
+        # Capture output
+        output_lines = []
+        
+        def capture_print(*args, **kwargs):
+            output_lines.append(' '.join(str(arg) for arg in args))
+        
+        safe_globals['print'] = capture_print
+        
+        # Execute code
+        exec(code, safe_globals)
+        
+        return '\n'.join(output_lines) if output_lines else "Code executed successfully"
+    
+    def _show_help(self):
+        """Show help information."""
+        help_text = """[bold cyan]🚁 DeepDrone Help[/bold cyan]
+
+[bold]Natural Language Commands:[/bold]
+• "Connect to the drone simulator"
+• "Take off to 30 meters altitude"
+• "Fly to coordinates 37.7749, -122.4194"
+• "Show me the current battery status"
+• "Execute a square flight pattern"
+• "Return home and land safely"
+
+[bold]Direct Commands:[/bold]
+• [cyan]/status[/cyan] - Show detailed system status
+• [cyan]/connect <connection>[/cyan] - Connect to specific drone
+• [cyan]/disconnect[/cyan] - Disconnect from drone
+• [cyan]/emergency[/cyan] - Emergency stop
+• [cyan]/ollama[/cyan] - Show Ollama status and models
+• [cyan]/clear[/cyan] - Clear screen
+• [cyan]/help[/cyan] - Show this help
+• [cyan]/quit[/cyan] - Exit DeepDrone
+
+[bold]Example Session:[/bold]
+[dim]🚁 DeepDrone> Connect to simulator and take off to 20 meters
+🤖 AI: I'll connect to the simulator and take off to 20 meters...
+🚁 DeepDrone> Fly in a circle with 50 meter radius
+🤖 AI: I'll create a circular flight pattern...[/dim]
+
+[bold]Tips:[/bold]
+• Use arrow keys to navigate command history
+• Tab completion available for common commands
+• AI understands natural language - be conversational!
+• Always prioritize safety in flight operations"""
+        
+        self.console.print(Panel(
+            help_text,
+            title="[bold]DeepDrone Help[/bold]",
+            border_style="cyan",
+            padding=(1, 2)
+        ))
+    
+    def _show_detailed_status(self):
+        """Show detailed system and drone status."""
+        status = self.drone_tools.get_status()
+        
+        # Create status table
+        table = Table(title="System Status", show_header=True, header_style="bold magenta")
+        table.add_column("Component", style="cyan", width=20)
+        table.add_column("Status", style="white")
+        table.add_column("Details", style="yellow")
+        
+        # AI Model status
+        table.add_row("AI Model", "✅ Online", f"{self.model_config.name} ({self.model_config.provider})")
+        
+        # Drone connection
+        conn_status = "✅ Connected" if status["connected"] else "❌ Disconnected"
+        table.add_row("Drone Connection", conn_status, self.connection_string)
+        
+        # Mission status
+        mission_status = "🚁 Active" if status["mission_in_progress"] else "⏸️ Standby"
+        table.add_row("Mission", mission_status, status.get("phase", "N/A"))
+        
+        # Current status
+        table.add_row("System Status", status["status"], "")
+        
+        if status["connected"]:
+            location = status.get("location", {})
+            battery = status.get("battery", {})
+            
+            if not location.get("error"):
+                lat = location.get("latitude", "N/A")
+                lon = location.get("longitude", "N/A")
+                alt = location.get("altitude", "N/A")
+                table.add_row("Location", "📍 GPS Lock", f"Lat: {lat}, Lon: {lon}, Alt: {alt}m")
+            
+            if not battery.get("error"):
+                voltage = battery.get("voltage", "N/A")
+                level = battery.get("level", "N/A")
+                table.add_row("Battery", "🔋 Monitoring", f"Voltage: {voltage}V, Level: {level}%")
+        
+        self.console.print(table)
+        
+        # Show recent log entries
+        if status.get("log_entries"):
+            self.console.print("\n[bold]Recent Activity:[/bold]")
+            for entry in status["log_entries"][-5:]:
+                self.console.print(f"[dim]{entry}[/dim]")
+    
+    def _connect_drone_direct(self):
+        """Connect to drone directly."""
+        with Live(
+            Spinner("dots", text=f"Connecting to {self.connection_string}..."),
+            console=self.console,
+            transient=True
+        ) as live:
+            
+            success = self.drone_tools.connect_drone(self.connection_string)
+            live.stop()
+            
+            if success:
+                self.console.print(f"[green]✅ Connected to drone at {self.connection_string}[/green]")
+            else:
+                self.console.print(f"[red]❌ Failed to connect to {self.connection_string}[/red]")
+    
+    def _disconnect_drone_direct(self):
+        """Disconnect from drone directly."""
+        if self.drone_tools.is_connected():
+            self.drone_tools.disconnect_drone()
+            self.console.print("[yellow]📡 Disconnected from drone[/yellow]")
+        else:
+            self.console.print("[yellow]No active drone connection[/yellow]")
+    
+    def _emergency_stop(self):
+        """Emergency stop operation."""
+        if self.drone_tools.is_connected():
+            self.console.print("[red]🚨 EMERGENCY STOP INITIATED[/red]")
+            self.drone_tools.emergency_stop()
+        else:
+            self.console.print("[yellow]No active drone connection for emergency stop[/yellow]")
+    
+    def _start_status_monitor(self):
+        """Start background status monitoring."""
+        self.status_running = True
+        self.status_thread = threading.Thread(target=self._status_monitor_loop, daemon=True)
+        self.status_thread.start()
+    
+    def _status_monitor_loop(self):
+        """Background status monitoring loop."""
+        while self.status_running and self.session_active:
+            try:
+                time.sleep(5)  # Update every 5 seconds
+                # Could update status bar here if needed
+            except Exception:
+                break
+    
+    def _handle_exit(self):
+        """Handle session exit."""
+        self.console.print("\n[yellow]🚁 Shutting down DeepDrone...[/yellow]")
+        
+        if self.drone_tools.is_connected():
+            from rich.prompt import Confirm
+            if Confirm.ask("Disconnect from drone before exit?", default=True):
+                self.drone_tools.disconnect_drone()
+        
+        self.session_active = False
+    
+    def _show_ollama_status(self):
+        """Show Ollama status and available models."""
+        try:
+            import ollama
+            
+            # Check connection
+            try:
+                models_response = ollama.list()
+                available_models = models_response.models if hasattr(models_response, 'models') else []
+                
+                self.console.print("[bold green]✅ Ollama Status: Connected[/bold green]\n")
+                
+                if available_models:
+                    self.console.print(f"[bold]📚 Available Models ({len(available_models)}):[/bold]")
+                    for model in available_models:
+                        name = model.model
+                        size = model.size if hasattr(model, 'size') else 0
+                        size_gb = size / (1024**3) if size else 0
+                        modified = str(model.modified_at)[:19] if hasattr(model, 'modified_at') else 'Unknown'
+                        
+                        self.console.print(f"  • [green]{name}[/green] ([blue]{size_gb:.1f} GB[/blue]) - {modified}")
+                else:
+                    self.console.print("[yellow]📭 No models installed[/yellow]")
+                    self.console.print("\n💡 Install a model with:")
+                    self.console.print("   [cyan]ollama pull llama3.1[/cyan]")
+                    self.console.print("   [cyan]ollama pull codestral[/cyan]")
+                    self.console.print("   [cyan]ollama pull qwen2.5-coder[/cyan]")
+                
+                self.console.print(f"\n[dim]Current model: {self.model_config.model_id}[/dim]")
+                
+            except Exception as e:
+                self.console.print("[red]❌ Ollama Status: Not connected[/red]")
+                self.console.print(f"[red]Error: {e}[/red]\n")
+                self.console.print("💡 Make sure Ollama is running:")
+                self.console.print("   [cyan]ollama serve[/cyan]\n")
+                self.console.print("📥 Download Ollama from:")
+                self.console.print("   [cyan]https://ollama.com/download[/cyan]")
+        
+        except ImportError:
+            self.console.print("[red]❌ Ollama package not installed[/red]")
+            self.console.print("Install with: [cyan]pip install ollama[/cyan]")
+    
+    def _cleanup(self):
+        """Cleanup resources."""
+        self.status_running = False
+        if self.drone_tools.is_connected():
+            self.drone_tools.disconnect_drone()
+        
+        self.console.print("[green]🚁 DeepDrone session ended. Fly safe![/green]")

drone/drone_tools.py

@@ -0,0 +1,342 @@
+"""
+Drone tools manager for terminal interface.
+Adapts the existing drone control functionality for the terminal application.
+"""
+
+import time
+import logging
+from typing import Dict, List, Optional, Any
+from .drone_control import DroneController
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DroneToolsManager:
+    """Manages drone operations for the terminal interface."""
+    
+    def __init__(self, connection_string: Optional[str] = None):
+        self.controller = DroneController(connection_string)
+        self.connected = False
+        self.mission_in_progress = False
+        
+        # Status tracking
+        self.status = "STANDBY"
+        self.phase = ""
+        self.log_entries = []
+    
+    def connect_drone(self, connection_string: str, timeout: int = 30) -> bool:
+        """Connect to a drone."""
+        try:
+            self._update_status("CONNECTING", f"Connecting to {connection_string}")
+            
+            success = self.controller.connect_to_drone(connection_string, timeout)
+            if success:
+                self.connected = True
+                self._update_status("CONNECTED", "Successfully connected to drone")
+                
+                # Get initial status
+                location = self.get_location()
+                battery = self.get_battery()
+                
+                logger.info(f"Connected to drone. Location: {location}, Battery: {battery}")
+                return True
+            else:
+                self._update_status("ERROR", "Failed to connect to drone")
+                return False
+                
+        except Exception as e:
+            self._update_status("ERROR", f"Connection error: {str(e)}")
+            logger.error(f"Connection error: {e}")
+            return False
+    
+    def disconnect_drone(self):
+        """Disconnect from the drone."""
+        try:
+            self._update_status("DISCONNECTING", "Disconnecting from drone")
+            self.controller.disconnect()
+            self.connected = False
+            self.mission_in_progress = False
+            self._update_status("STANDBY", "Disconnected from drone")
+            logger.info("Disconnected from drone")
+        except Exception as e:
+            logger.error(f"Disconnect error: {e}")
+    
+    def takeoff(self, altitude: float) -> bool:
+        """Take off to specified altitude."""
+        if not self._ensure_connected():
+            return False
+        
+        try:
+            self._update_status("TAKING OFF", f"Taking off to {altitude} meters")
+            self.mission_in_progress = True
+            
+            success = self.controller.arm_and_takeoff(altitude)
+            if success:
+                self._update_status("AIRBORNE", f"Reached altitude of {altitude} meters")
+                return True
+            else:
+                self._update_status("ERROR", "Takeoff failed")
+                self.mission_in_progress = False
+                return False
+                
+        except Exception as e:
+            self._update_status("ERROR", f"Takeoff error: {str(e)}")
+            self.mission_in_progress = False
+            logger.error(f"Takeoff error: {e}")
+            return False
+    
+    def land(self) -> bool:
+        """Land the drone."""
+        if not self._ensure_connected():
+            return False
+        
+        try:
+            self._update_status("LANDING", "Landing drone")
+            
+            success = self.controller.land()
+            if success:
+                self._update_status("LANDED", "Drone has landed")
+                self.mission_in_progress = False
+                return True
+            else:
+                self._update_status("ERROR", "Landing failed")
+                return False
+                
+        except Exception as e:
+            self._update_status("ERROR", f"Landing error: {str(e)}")
+            logger.error(f"Landing error: {e}")
+            return False
+    
+    def return_home(self) -> bool:
+        """Return to launch/home location."""
+        if not self._ensure_connected():
+            return False
+        
+        try:
+            self._update_status("RETURNING", "Returning to launch point")
+            
+            success = self.controller.return_to_launch()
+            if success:
+                self._update_status("RETURNING", "Drone is returning to launch point")
+                return True
+            else:
+                self._update_status("ERROR", "Return to home failed")
+                return False
+                
+        except Exception as e:
+            self._update_status("ERROR", f"Return error: {str(e)}")
+            logger.error(f"Return error: {e}")
+            return False
+    
+    def fly_to(self, latitude: float, longitude: float, altitude: float) -> bool:
+        """Fly to specific GPS coordinates."""
+        if not self._ensure_connected():
+            return False
+        
+        try:
+            self._update_status(
+                "NAVIGATING", 
+                f"Flying to lat:{latitude:.4f}, lon:{longitude:.4f}, alt:{altitude}m"
+            )
+            
+            success = self.controller.goto_location(latitude, longitude, altitude)
+            if success:
+                return True
+            else:
+                self._update_status("ERROR", "Navigation failed")
+                return False
+                
+        except Exception as e:
+            self._update_status("ERROR", f"Navigation error: {str(e)}")
+            logger.error(f"Navigation error: {e}")
+            return False
+    
+    def get_location(self) -> Dict[str, Any]:
+        """Get current GPS location."""
+        if not self._ensure_connected():
+            return {"error": "Not connected to drone"}
+        
+        try:
+            return self.controller.get_current_location()
+        except Exception as e:
+            logger.error(f"Location error: {e}")
+            return {"error": str(e)}
+    
+    def get_battery(self) -> Dict[str, Any]:
+        """Get battery status."""
+        if not self._ensure_connected():
+            return {"error": "Not connected to drone"}
+        
+        try:
+            return self.controller.get_battery_status()
+        except Exception as e:
+            logger.error(f"Battery error: {e}")
+            return {"error": str(e)}
+    
+    def execute_mission(self, waypoints: List[Dict[str, float]]) -> bool:
+        """Execute a mission with multiple waypoints."""
+        if not self._ensure_connected():
+            return False
+        
+        if not waypoints:
+            logger.error("No waypoints provided")
+            return False
+        
+        try:
+            self._update_status("MISSION", f"Starting mission with {len(waypoints)} waypoints")
+            self.mission_in_progress = True
+            
+            # Upload mission
+            upload_success = self.controller.upload_mission(waypoints)
+            if not upload_success:
+                self._update_status("ERROR", "Failed to upload mission")
+                self.mission_in_progress = False
+                return False
+            
+            # Execute mission
+            execute_success = self.controller.execute_mission()
+            if execute_success:
+                self._update_status("EXECUTING", "Mission execution started")
+                
+                # Simulate mission progress updates
+                for i, wp in enumerate(waypoints, 1):
+                    self._update_status(
+                        "EXECUTING",
+                        f"Waypoint {i}/{len(waypoints)}: {wp['lat']:.4f}, {wp['lon']:.4f}"
+                    )
+                    time.sleep(1)  # Brief pause between waypoints
+                
+                self._update_status("MISSION COMPLETE", "All waypoints reached")
+                return True
+            else:
+                self._update_status("ERROR", "Failed to start mission execution")
+                self.mission_in_progress = False
+                return False
+                
+        except Exception as e:
+            self._update_status("ERROR", f"Mission error: {str(e)}")
+            self.mission_in_progress = False
+            logger.error(f"Mission error: {e}")
+            return False
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get current drone and system status."""
+        status_info = {
+            "connected": self.connected,
+            "mission_in_progress": self.mission_in_progress,
+            "status": self.status,
+            "phase": self.phase,
+            "log_entries": self.log_entries[-5:],  # Last 5 entries
+        }
+        
+        if self.connected:
+            try:
+                status_info["location"] = self.get_location()
+                status_info["battery"] = self.get_battery()
+                
+                if hasattr(self.controller, 'vehicle') and self.controller.vehicle:
+                    status_info["mode"] = str(self.controller.vehicle.mode.name)
+                    status_info["armed"] = self.controller.vehicle.armed
+                    status_info["system_status"] = str(self.controller.vehicle.system_status.state)
+                    
+            except Exception as e:
+                status_info["telemetry_error"] = str(e)
+        
+        return status_info
+    
+    def is_connected(self) -> bool:
+        """Check if connected to drone."""
+        return self.connected
+    
+    def emergency_stop(self):
+        """Emergency stop - immediately land or RTL."""
+        if not self.connected:
+            return
+        
+        try:
+            self._update_status("EMERGENCY", "Emergency stop initiated")
+            
+            # Try RTL first, then land
+            if not self.return_home():
+                self.land()
+                
+            self.mission_in_progress = False
+            
+        except Exception as e:
+            logger.error(f"Emergency stop error: {e}")
+    
+    def set_airspeed(self, speed: float) -> bool:
+        """Set target airspeed."""
+        if not self._ensure_connected():
+            return False
+        
+        try:
+            return self.controller.set_airspeed(speed)
+        except Exception as e:
+            logger.error(f"Airspeed error: {e}")
+            return False
+    
+    def get_telemetry(self) -> Dict[str, Any]:
+        """Get comprehensive telemetry data."""
+        if not self._ensure_connected():
+            return {"error": "Not connected to drone"}
+        
+        try:
+            telemetry = {}
+            
+            # Basic info
+            telemetry["location"] = self.get_location()
+            telemetry["battery"] = self.get_battery()
+            
+            # Vehicle-specific data if available
+            if hasattr(self.controller, 'vehicle') and self.controller.vehicle:
+                vehicle = self.controller.vehicle
+                
+                telemetry.update({
+                    "mode": str(vehicle.mode.name),
+                    "armed": vehicle.armed,
+                    "system_status": str(vehicle.system_status.state),
+                    "airspeed": vehicle.airspeed,
+                    "groundspeed": vehicle.groundspeed,
+                    "heading": vehicle.heading,
+                })
+                
+                # GPS info
+                if vehicle.gps_0:
+                    telemetry["gps"] = {
+                        "fix_type": vehicle.gps_0.fix_type,
+                        "satellites_visible": vehicle.gps_0.satellites_visible,
+                        "eph": vehicle.gps_0.eph,
+                        "epv": vehicle.gps_0.epv,
+                    }
+            
+            return telemetry
+            
+        except Exception as e:
+            logger.error(f"Telemetry error: {e}")
+            return {"error": str(e)}
+    
+    def _ensure_connected(self) -> bool:
+        """Ensure drone is connected."""
+        if not self.connected:
+            logger.error("Not connected to drone")
+            return False
+        return True
+    
+    def _update_status(self, status: str, phase: str = ""):
+        """Update system status and log entry."""
+        self.status = status
+        self.phase = phase
+        
+        # Create log entry
+        timestamp = time.strftime("%H:%M:%S")
+        log_entry = f"[{timestamp}] {status}: {phase}" if phase else f"[{timestamp}] {status}"
+        
+        self.log_entries.append(log_entry)
+        
+        # Keep only last 50 entries
+        if len(self.log_entries) > 50:
+            self.log_entries = self.log_entries[-50:]
+        
+        logger.info(log_entry)

drone/interactive_setup.py

@@ -0,0 +1,414 @@
+"""
+Interactive setup and chat interface for DeepDrone.
+"""
+
+import os
+import sys
+import asyncio
+from typing import Dict, Optional, Tuple, List
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.align import Align
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+from rich.live import Live
+from rich.layout import Layout
+from rich.spinner import Spinner
+from prompt_toolkit import prompt
+from prompt_toolkit.shortcuts import radiolist_dialog, input_dialog, message_dialog
+from prompt_toolkit.styles import Style
+import getpass
+
+from .config import ModelConfig
+from .drone_chat_interface import DroneChatInterface
+
+console = Console()
+
+# Provider configurations
+PROVIDERS = {
+    "OpenAI": {
+        "name": "openai",
+        "models": ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"],
+        "api_key_url": "https://platform.openai.com/api-keys",
+        "description": "GPT models from OpenAI"
+    },
+    "Anthropic": {
+        "name": "anthropic",
+        "models": ["claude-3-5-sonnet-20241022", "claude-3-sonnet-20240229", "claude-3-haiku-20240307"],
+        "api_key_url": "https://console.anthropic.com/",
+        "description": "Claude models from Anthropic"
+    },
+    "Google": {
+        "name": "vertex_ai",
+        "models": ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro"],
+        "api_key_url": "https://console.cloud.google.com/",
+        "description": "Gemini models from Google"
+    },
+    "Meta": {
+        "name": "openai",  # Using OpenAI format for Llama models via providers
+        "models": ["meta-llama/Meta-Llama-3.1-70B-Instruct", "meta-llama/Meta-Llama-3.1-8B-Instruct"],
+        "api_key_url": "https://together.ai/ or https://replicate.com/",
+        "description": "Llama models from Meta (via Together.ai/Replicate)"
+    },
+    "Mistral": {
+        "name": "mistral",
+        "models": ["mistral-large-latest", "mistral-medium-latest", "mistral-small-latest"],
+        "api_key_url": "https://console.mistral.ai/",
+        "description": "Mistral AI models"
+    },
+    "Ollama": {
+        "name": "ollama",
+        "models": ["llama3.1:latest", "codestral:latest", "qwen2.5-coder:latest", "phi3:latest"],
+        "api_key_url": "https://ollama.ai/ (No API key needed - runs locally)",
+        "description": "Local models via Ollama (no API key required)"
+    }
+}
+
+def show_welcome_banner():
+    """Display the welcome banner."""
+    banner = """
+╔══════════════════════════════════════════════════════════╗
+║                                                          ║
+║           🚁 DEEPDRONE AI CONTROL SYSTEM 🚁              ║
+║                                                          ║
+║        Advanced Drone Control with AI Integration        ║
+║                                                          ║
+╚══════════════════════════════════════════════════════════╝
+    """
+    
+    console.print(Panel(
+        Align.center(Text(banner.strip(), style="bold green")),
+        border_style="bright_green",
+        padding=(1, 2)
+    ))
+
+def select_provider() -> Optional[Tuple[str, Dict]]:
+    """Interactive provider selection."""
+    console.print("\n[bold cyan]📡 Select AI Provider[/bold cyan]\n")
+    
+    # Create provider table for display
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("№", style="bright_green", width=3)
+    table.add_column("Provider", style="cyan", width=12)
+    table.add_column("Description", style="white")
+    table.add_column("Example Models", style="yellow")
+    
+    provider_list = list(PROVIDERS.items())
+    
+    for i, (name, config) in enumerate(provider_list, 1):
+        example_models = ", ".join(config["models"][:2])
+        if len(config["models"]) > 2:
+            example_models += "..."
+        table.add_row(str(i), name, config["description"], example_models)
+    
+    console.print(table)
+    console.print()
+    
+    try:
+        from rich.prompt import IntPrompt
+        
+        choice = IntPrompt.ask(
+            "Select provider by number",
+            choices=[str(i) for i in range(1, len(provider_list) + 1)],
+            default=1
+        )
+        
+        provider_name, provider_config = provider_list[choice - 1]
+        return provider_name, provider_config
+        
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Selection cancelled[/yellow]")
+        return None
+
+def get_available_ollama_models() -> List[str]:
+    """Get list of locally available Ollama models."""
+    try:
+        import ollama
+        models = ollama.list()
+        # The models are returned as Model objects with a 'model' attribute
+        return [model.model for model in models.models] if hasattr(models, 'models') else []
+    except ImportError:
+        return []
+    except Exception as e:
+        # For debugging, you can uncomment the next line
+        # print(f"Error getting Ollama models: {e}")
+        return []
+
+def install_ollama_model(model_name: str) -> bool:
+    """Install an Ollama model."""
+    try:
+        import ollama
+        console.print(f"[yellow]📥 Installing {model_name}... This may take a few minutes.[/yellow]")
+        
+        with Live(
+            Spinner("dots", text=f"Installing {model_name}..."),
+            console=console,
+            transient=True
+        ) as live:
+            ollama.pull(model_name)
+            live.stop()
+        
+        console.print(f"[green]✅ Successfully installed {model_name}[/green]")
+        return True
+    except ImportError:
+        console.print("[red]❌ Ollama package not installed[/red]")
+        return False
+    except Exception as e:
+        console.print(f"[red]❌ Failed to install {model_name}: {e}[/red]")
+        return False
+
+def get_model_name(provider_name: str, provider_config: Dict) -> Optional[str]:
+    """Get model name from user."""
+    console.print(f"\n[bold cyan]🤖 Select Model for {provider_name}[/bold cyan]\n")
+    
+    # Special handling for Ollama
+    if provider_name.lower() == "ollama":
+        # Check if Ollama is running and get local models
+        local_models = get_available_ollama_models()
+        
+        if local_models:
+            console.print("[bold green]✅ Local Ollama models found:[/bold green]")
+            for i, model in enumerate(local_models, 1):
+                console.print(f"  {i}. [green]{model}[/green]")
+            
+            console.print("\n[bold]Popular models (if not installed locally):[/bold]")
+            start_idx = len(local_models) + 1
+            for i, model in enumerate(provider_config["models"], start_idx):
+                console.print(f"  {i}. [blue]{model}[/blue] [dim](will be downloaded)[/dim]")
+            
+            all_options = local_models + provider_config["models"]
+            
+        else:
+            console.print("[yellow]⚠️  No local Ollama models found or Ollama not running[/yellow]")
+            console.print("Make sure Ollama is running: [cyan]ollama serve[/cyan]\n")
+            console.print("[bold]Popular models (will be downloaded):[/bold]")
+            all_options = provider_config["models"]
+            for i, model in enumerate(all_options, 1):
+                console.print(f"  {i}. [blue]{model}[/blue] [dim](will be downloaded)[/dim]")
+        
+        console.print(f"\n[dim]Download from: {provider_config['api_key_url']}[/dim]\n")
+        
+        try:
+            from rich.prompt import Prompt
+            
+            result = Prompt.ask(
+                "Enter model name or number from list above",
+                default="1"
+            )
+            
+            if result:
+                # Check if user entered a number (selecting from list)
+                try:
+                    choice_num = int(result.strip())
+                    if 1 <= choice_num <= len(all_options):
+                        selected_model = all_options[choice_num - 1]
+                        
+                        # Check if model needs to be installed
+                        if selected_model not in local_models:
+                            console.print(f"[yellow]Model '{selected_model}' not found locally.[/yellow]")
+                            from rich.prompt import Confirm
+                            if Confirm.ask(f"Would you like to install {selected_model}?", default=True):
+                                if install_ollama_model(selected_model):
+                                    return selected_model
+                                else:
+                                    return None
+                            else:
+                                console.print("[yellow]Model installation cancelled[/yellow]")
+                                return None
+                        
+                        return selected_model
+                except ValueError:
+                    pass
+                
+                # User entered a custom model name
+                model_name = result.strip()
+                if model_name not in local_models:
+                    console.print(f"[yellow]Model '{model_name}' not found locally.[/yellow]")
+                    from rich.prompt import Confirm
+                    if Confirm.ask(f"Would you like to install {model_name}?", default=True):
+                        if install_ollama_model(model_name):
+                            return model_name
+                        else:
+                            return None
+                    else:
+                        console.print("[yellow]Model installation cancelled[/yellow]")
+                        return None
+                
+                return model_name
+            
+            return None
+            
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Input cancelled[/yellow]")
+            return None
+    
+    else:
+        # Standard handling for other providers
+        console.print("[bold]Popular models for this provider:[/bold]")
+        for i, model in enumerate(provider_config["models"], 1):
+            console.print(f"  {i}. [green]{model}[/green]")
+        
+        console.print(f"\n[dim]Get API key from: {provider_config['api_key_url']}[/dim]\n")
+        
+        try:
+            from rich.prompt import Prompt
+            
+            result = Prompt.ask(
+                "Enter model name or number from list above",
+                default="1"
+            )
+            
+            if result:
+                # Check if user entered a number (selecting from list)
+                try:
+                    choice_num = int(result.strip())
+                    if 1 <= choice_num <= len(provider_config["models"]):
+                        return provider_config["models"][choice_num - 1]
+                except ValueError:
+                    pass
+                
+                # Return the entered model name
+                return result.strip()
+            
+            return None
+            
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Input cancelled[/yellow]")
+            return None
+
+def get_api_key(provider_name: str, model_name: str) -> Optional[str]:
+    """Get API key from user."""
+    console.print(f"\n[bold cyan]🔑 API Key for {provider_name}[/bold cyan]\n")
+    console.print(f"Model: [green]{model_name}[/green]")
+    console.print(f"Provider: [blue]{provider_name}[/blue]\n")
+    
+    # Ollama doesn't need an API key
+    if provider_name.lower() == "ollama":
+        console.print("[green]✅ Ollama runs locally - no API key required![/green]")
+        console.print("[dim]Make sure Ollama is running: ollama serve[/dim]\n")
+        return "local"  # Return a placeholder value
+    
+    try:
+        # Use getpass for secure password input (works in all environments)
+        api_key = getpass.getpass("Enter your API key (hidden): ")
+        
+        if api_key and api_key.strip():
+            return api_key.strip()
+        
+        console.print("[yellow]No API key provided[/yellow]")
+        return None
+        
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Input cancelled[/yellow]")
+        return None
+
+def test_model_connection(model_config: ModelConfig) -> bool:
+    """Test if the model configuration works."""
+    console.print(f"\n[yellow]🔍 Testing connection to {model_config.name}...[/yellow]")
+    
+    try:
+        from .llm_interface import LLMInterface
+        
+        with Live(
+            Spinner("dots", text="Testing API connection..."),
+            console=console,
+            transient=True
+        ) as live:
+            llm = LLMInterface(model_config)
+            result = llm.test_connection()
+            
+            live.stop()
+            
+            if result["success"]:
+                console.print("[green]✅ Connection successful![/green]")
+                console.print(f"[dim]Response: {result['response'][:100]}...[/dim]\n")
+                return True
+            else:
+                console.print(f"[red]❌ Connection failed: {result['error']}[/red]\n")
+                return False
+                
+    except Exception as e:
+        console.print(f"[red]❌ Error testing connection: {e}[/red]\n")
+        return False
+
+def start_interactive_session():
+    """Start the interactive setup and chat session."""
+    try:
+        # Show welcome banner
+        show_welcome_banner()
+        
+        # Step 1: Select provider
+        console.print("[bold]Step 1: Choose your AI provider[/bold]\n")
+        provider_result = select_provider()
+        if not provider_result:
+            console.print("[yellow]Setup cancelled. Goodbye![/yellow]")
+            return
+        
+        provider_name, provider_config = provider_result
+        
+        # Step 2: Get model name
+        console.print(f"[bold]Step 2: Select model for {provider_name}[/bold]")
+        model_name = get_model_name(provider_name, provider_config)
+        if not model_name:
+            console.print("[yellow]Setup cancelled. Goodbye![/yellow]")
+            return
+        
+        # Step 3: Get API key
+        console.print("[bold]Step 3: Enter API key[/bold]")
+        api_key = get_api_key(provider_name, model_name)
+        if not api_key:
+            console.print("[yellow]Setup cancelled. Goodbye![/yellow]")
+            return
+        
+        # Create model configuration
+        base_url = None
+        if provider_name.lower() == "ollama":
+            base_url = "http://localhost:11434"
+        
+        model_config = ModelConfig(
+            name=f"{provider_name.lower()}-session",
+            provider=provider_config["name"],
+            model_id=model_name,
+            api_key=api_key,
+            base_url=base_url,
+            max_tokens=2048,
+            temperature=0.7
+        )
+        
+        # Step 4: Test connection
+        console.print("[bold]Step 4: Testing connection[/bold]")
+        if not test_model_connection(model_config):
+            if not Confirm.ask("Connection test failed. Continue anyway?"):
+                console.print("[yellow]Setup cancelled. Goodbye![/yellow]")
+                return
+        
+        # Step 5: Show simulator information
+        console.print("[bold yellow]🚁 Drone Connection Setup[/bold yellow]\n")
+        console.print("To control a drone, you'll need a connection. You can:")
+        console.print("  1. [green]Use Simulator[/green]: Run [cyan]python simulate_drone.py[/cyan] in another terminal")
+        console.print("  2. [blue]Real Drone[/blue]: Connect via USB, TCP, or UDP")
+        console.print("  3. [dim]SITL[/dim]: Use ArduPilot Software-in-the-Loop\n")
+        
+        console.print("💡 [bold]Quick Start with Simulator:[/bold]")
+        console.print("   • Open a new terminal and run: [cyan]python simulate_drone.py[/cyan]")
+        console.print("   • It will show you the connection string (e.g., udp:127.0.0.1:14550)")
+        console.print("   • Use that connection string in the chat interface\n")
+        
+        # Step 6: Start chat
+        console.print("[bold green]🚀 Starting DeepDrone chat session...[/bold green]\n")
+        
+        # Small delay
+        import time
+        time.sleep(1)
+        
+        # Start the chat interface
+        chat_interface = DroneChatInterface(model_config)
+        chat_interface.start()
+        
+    except KeyboardInterrupt:
+        console.print("\n[yellow]🚁 DeepDrone session interrupted. Goodbye![/yellow]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"[red]❌ Error in interactive session: {e}[/red]")
+        sys.exit(1)

drone/llm_interface.py

@@ -0,0 +1,227 @@
+"""
+LLM Interface for DeepDrone supporting LiteLLM and Ollama.
+"""
+
+import os
+from typing import List, Dict, Any, Optional
+import json
+import logging
+
+from .config import ModelConfig
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class LLMInterface:
+    """Interface for interacting with various LLM providers."""
+    
+    def __init__(self, model_config: ModelConfig):
+        self.model_config = model_config
+        self._setup_client()
+    
+    def _setup_client(self):
+        """Set up the appropriate client based on model provider."""
+        if self.model_config.provider == "ollama":
+            self._setup_ollama()
+        else:
+            self._setup_litellm()
+    
+    def _setup_ollama(self):
+        """Set up Ollama client."""
+        try:
+            import ollama
+            self.client = ollama
+            self.client_type = "ollama"
+            
+            # Test connection
+            try:
+                models = self.client.list()
+                available_models = models.models if hasattr(models, 'models') else []
+                logger.info(f"Connected to Ollama. Available models: {len(available_models)}")
+                
+                # Check if the requested model is available
+                model_names = [model.model for model in available_models]
+                if self.model_config.model_id not in model_names:
+                    logger.warning(f"Model '{self.model_config.model_id}' not found locally. Available models: {model_names}")
+                    
+            except Exception as e:
+                logger.warning(f"Could not connect to Ollama: {e}")
+                logger.info("Make sure Ollama is running: ollama serve")
+                
+        except ImportError:
+            raise ImportError("Ollama package not installed. Install with: pip install ollama")
+    
+    def _setup_litellm(self):
+        """Set up LiteLLM client."""
+        try:
+            import litellm
+            
+            # Set API key in environment if provided (skip for local/placeholder keys)
+            if self.model_config.api_key and self.model_config.api_key != "local":
+                if self.model_config.provider == "openai":
+                    os.environ["OPENAI_API_KEY"] = self.model_config.api_key
+                elif self.model_config.provider == "anthropic":
+                    os.environ["ANTHROPIC_API_KEY"] = self.model_config.api_key
+                elif self.model_config.provider == "huggingface":
+                    os.environ["HUGGINGFACE_API_KEY"] = self.model_config.api_key
+                elif self.model_config.provider == "mistral":
+                    os.environ["MISTRAL_API_KEY"] = self.model_config.api_key
+                elif self.model_config.provider == "vertex_ai":
+                    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.model_config.api_key
+            
+            # Set base URL if provided
+            if self.model_config.base_url:
+                litellm.api_base = self.model_config.base_url
+            
+            self.client = litellm
+            self.client_type = "litellm"
+            
+            logger.info(f"Set up LiteLLM for {self.model_config.provider}")
+            
+        except ImportError:
+            raise ImportError("LiteLLM package not installed. Install with: pip install litellm")
+    
+    def chat(self, messages: List[Dict[str, str]]) -> str:
+        """Send chat messages and get response."""
+        try:
+            if self.client_type == "ollama":
+                return self._chat_ollama(messages)
+            else:
+                return self._chat_litellm(messages)
+        except Exception as e:
+            logger.error(f"Chat error: {e}")
+            return f"Error communicating with {self.model_config.provider}: {str(e)}"
+    
+    def _chat_ollama(self, messages: List[Dict[str, str]]) -> str:
+        """Chat using Ollama."""
+        try:
+            # Convert messages to Ollama format
+            prompt = self._messages_to_prompt(messages)
+            
+            response = self.client.generate(
+                model=self.model_config.model_id,
+                prompt=prompt,
+                options={
+                    'temperature': self.model_config.temperature,
+                    'num_predict': self.model_config.max_tokens,
+                }
+            )
+            
+            return response['response']
+            
+        except Exception as e:
+            error_str = str(e).lower()
+            
+            if "model not found" in error_str or "model does not exist" in error_str:
+                available_models = []
+                try:
+                    models = self.client.list()
+                    available_models = [m.model for m in models.models] if hasattr(models, 'models') else []
+                except:
+                    pass
+                
+                error_msg = f"❌ Model '{self.model_config.model_id}' not found in Ollama.\n\n"
+                
+                if available_models:
+                    error_msg += f"📋 Available local models:\n"
+                    for model in available_models:
+                        error_msg += f"  • {model}\n"
+                    error_msg += f"\n💡 To install {self.model_config.model_id}, run:\n"
+                    error_msg += f"   ollama pull {self.model_config.model_id}\n"
+                else:
+                    error_msg += "📭 No models found locally.\n\n"
+                    error_msg += f"💡 To install {self.model_config.model_id}, run:\n"
+                    error_msg += f"   ollama pull {self.model_config.model_id}\n\n"
+                    error_msg += "🎯 Popular models to try:\n"
+                    error_msg += "   • ollama pull llama3.1\n"
+                    error_msg += "   • ollama pull codestral\n"
+                    error_msg += "   • ollama pull qwen2.5-coder\n"
+                
+                return error_msg
+            
+            elif "connection" in error_str or "refused" in error_str:
+                return "❌ Cannot connect to Ollama.\n\n💡 Make sure Ollama is running:\n   ollama serve\n\n📥 Download Ollama from: https://ollama.com/download"
+            
+            return f"❌ Ollama error: {str(e)}"
+    
+    def _chat_litellm(self, messages: List[Dict[str, str]]) -> str:
+        """Chat using LiteLLM."""
+        try:
+            response = self.client.completion(
+                model=self.model_config.model_id,
+                messages=messages,
+                max_tokens=self.model_config.max_tokens,
+                temperature=self.model_config.temperature,
+            )
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            if "api key" in str(e).lower():
+                return f"API key error for {self.model_config.provider}. Please set your API key with: deepdrone models set-key {self.model_config.name}"
+            elif "quota" in str(e).lower() or "billing" in str(e).lower():
+                return f"Billing/quota error for {self.model_config.provider}. Please check your account."
+            elif "model" in str(e).lower() and "not found" in str(e).lower():
+                return f"Model '{self.model_config.model_id}' not found for {self.model_config.provider}."
+            
+            raise e
+    
+    def _messages_to_prompt(self, messages: List[Dict[str, str]]) -> str:
+        """Convert messages to a single prompt for models that don't support chat format."""
+        prompt_parts = []
+        
+        for message in messages:
+            role = message["role"]
+            content = message["content"]
+            
+            if role == "system":
+                prompt_parts.append(f"System: {content}")
+            elif role == "user":
+                prompt_parts.append(f"Human: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"Assistant: {content}")
+        
+        prompt_parts.append("Assistant: ")
+        
+        return "\n\n".join(prompt_parts)
+    
+    def test_connection(self) -> Dict[str, Any]:
+        """Test connection to the LLM service."""
+        try:
+            test_messages = [
+                {"role": "user", "content": "Hello, please respond with 'Connection test successful'"}
+            ]
+            
+            response = self.chat(test_messages)
+            
+            return {
+                "success": True,
+                "response": response,
+                "provider": self.model_config.provider,
+                "model": self.model_config.model_id
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "provider": self.model_config.provider,
+                "model": self.model_config.model_id
+            }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the current model."""
+        info = {
+            "name": self.model_config.name,
+            "provider": self.model_config.provider,
+            "model_id": self.model_config.model_id,
+            "max_tokens": self.model_config.max_tokens,
+            "temperature": self.model_config.temperature,
+            "client_type": self.client_type,
+        }
+        
+        if self.model_config.base_url:
+            info["base_url"] = self.model_config.base_url
+        
+        return info

drone/terminal_chat.py

@@ -0,0 +1,496 @@
+"""
+Terminal-based chat interface for DeepDrone with LiteLLM and Ollama support.
+"""
+
+import asyncio
+from typing import List, Dict, Any, Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.markdown import Markdown
+from rich.live import Live
+from rich.spinner import Spinner
+from prompt_toolkit import prompt
+from prompt_toolkit.shortcuts import message_dialog
+from prompt_toolkit.styles import Style
+import json
+import time
+
+from .config import ModelConfig
+from .llm_interface import LLMInterface
+from .drone_tools import DroneToolsManager
+
+class TerminalDroneChat:
+    """Terminal-based chat interface for drone control."""
+    
+    def __init__(self, model_config: ModelConfig, connection_string: Optional[str] = None):
+        self.console = Console()
+        self.model_config = model_config
+        self.connection_string = connection_string
+        self.chat_history: List[Dict[str, str]] = []
+        
+        # Initialize LLM interface
+        self.llm = LLMInterface(model_config)
+        
+        # Initialize drone tools
+        self.drone_tools = DroneToolsManager(connection_string)
+        
+        # Chat settings
+        self.show_thinking = True
+        self.max_history = 50
+        
+        # Style for prompt
+        self.prompt_style = Style.from_dict({
+            'prompt': '#00ff00 bold',
+            'input': '#ffffff',
+        })
+    
+    def start(self):
+        """Start the interactive chat session."""
+        self._show_welcome()
+        
+        try:
+            while True:
+                user_input = self._get_user_input()
+                
+                if not user_input.strip():
+                    continue
+                
+                # Handle special commands
+                if user_input.startswith('/'):
+                    if self._handle_command(user_input):
+                        continue
+                    else:
+                        break
+                
+                # Process user message
+                self._process_message(user_input)
+                
+        except KeyboardInterrupt:
+            self._show_goodbye()
+        except EOFError:
+            self._show_goodbye()
+    
+    def _show_welcome(self):
+        """Show welcome message and model info."""
+        welcome_text = f"""
+[bold green]🚁 DEEPDRONE TERMINAL ACTIVE[/bold green]
+
+[bold]Model:[/bold] {self.model_config.name} ({self.model_config.provider})
+[bold]Connection:[/bold] {self.connection_string or 'Not connected'}
+[bold]Status:[/bold] Ready for commands
+
+[dim]Type your commands or questions. Use /help for available commands.[/dim]
+[dim]Type /quit to exit.[/dim]
+        """
+        
+        self.console.print(Panel(
+            welcome_text.strip(),
+            border_style="bright_green",
+            padding=(1, 2)
+        ))
+    
+    def _show_goodbye(self):
+        """Show goodbye message."""
+        self.console.print("\n[yellow]🚁 DeepDrone session ended. Fly safe![/yellow]")
+        
+        # Disconnect from drone if connected
+        if self.drone_tools.is_connected():
+            self.console.print("[dim]Disconnecting from drone...[/dim]")
+            self.drone_tools.disconnect()
+    
+    def _get_user_input(self) -> str:
+        """Get user input with custom prompt."""
+        try:
+            return prompt(
+                [('class:prompt', '🚁 DeepDrone> ')],
+                style=self.prompt_style
+            )
+        except (KeyboardInterrupt, EOFError):
+            return '/quit'
+    
+    def _handle_command(self, command: str) -> bool:
+        """Handle special commands. Returns True to continue, False to quit."""
+        cmd_parts = command[1:].split()
+        if not cmd_parts:
+            return True
+        
+        cmd = cmd_parts[0].lower()
+        
+        if cmd in ['quit', 'exit', 'q']:
+            return False
+        
+        elif cmd == 'help':
+            self._show_help()
+        
+        elif cmd == 'clear':
+            self.console.clear()
+            self._show_welcome()
+        
+        elif cmd == 'history':
+            self._show_history()
+        
+        elif cmd == 'status':
+            self._show_status()
+        
+        elif cmd == 'connect':
+            if len(cmd_parts) > 1:
+                self._connect_drone(cmd_parts[1])
+            else:
+                self.console.print("[red]Usage: /connect <connection_string>[/red]")
+        
+        elif cmd == 'disconnect':
+            self._disconnect_drone()
+        
+        elif cmd == 'models':
+            self._show_model_info()
+        
+        else:
+            self.console.print(f"[red]Unknown command: {command}[/red]")
+            self.console.print("Type /help for available commands")
+        
+        return True
+    
+    def _process_message(self, user_message: str):
+        """Process user message and generate response."""
+        # Add user message to history
+        self.chat_history.append({"role": "user", "content": user_message})
+        
+        # Show user message
+        self.console.print(Panel(
+            user_message,
+            title="[bold blue]You[/bold blue]",
+            border_style="blue",
+            padding=(0, 1)
+        ))
+        
+        # Check if this requires drone tools
+        requires_tools = self._message_requires_tools(user_message)
+        
+        # Generate response
+        with Live(
+            Spinner("dots", text="[green]DeepDrone is thinking...[/green]"),
+            console=self.console,
+            transient=True
+        ) as live:
+            
+            try:
+                if requires_tools:
+                    response = self._process_with_tools(user_message, live)
+                else:
+                    response = self._process_simple_chat(user_message)
+                
+                live.stop()
+                
+                # Show response
+                self._show_response(response)
+                
+                # Add to history
+                self.chat_history.append({"role": "assistant", "content": response})
+                
+                # Trim history if too long
+                if len(self.chat_history) > self.max_history:
+                    self.chat_history = self.chat_history[-self.max_history:]
+                
+            except Exception as e:
+                live.stop()
+                self.console.print(f"[red]Error: {e}[/red]")
+    
+    def _message_requires_tools(self, message: str) -> bool:
+        """Check if message requires drone tools."""
+        tool_keywords = [
+            'connect', 'takeoff', 'land', 'fly', 'goto', 'mission',
+            'battery', 'location', 'status', 'arm', 'disarm', 'rtl',
+            'return', 'home', 'altitude', 'waypoint', 'navigate'
+        ]
+        
+        message_lower = message.lower()
+        return any(keyword in message_lower for keyword in tool_keywords)
+    
+    def _process_with_tools(self, message: str, live: Live) -> str:
+        """Process message that may require drone tools."""
+        # Update status
+        live.update(Spinner("dots", text="[green]Analyzing command and planning actions...[/green]"))
+        
+        # Create system prompt with tool information
+        system_prompt = self._create_system_prompt_with_tools()
+        
+        # Prepare messages
+        messages = [{"role": "system", "content": system_prompt}]
+        messages.extend(self.chat_history[-10:])  # Last 10 messages for context
+        messages.append({"role": "user", "content": message})
+        
+        # Get LLM response
+        response = self.llm.chat(messages)
+        
+        # Check if response contains tool calls
+        if self._response_has_tool_calls(response):
+            live.update(Spinner("dots", text="[yellow]Executing drone operations...[/yellow]"))
+            response = self._execute_tool_calls(response)
+        
+        return response
+    
+    def _process_simple_chat(self, message: str) -> str:
+        """Process simple chat message without tools."""
+        system_prompt = """You are DeepDrone, an AI assistant specialized in drone operations and flight control.
+        
+You help users with:
+- Drone flight planning and mission design
+- Understanding drone systems and components
+- Troubleshooting flight issues
+- Safety protocols and regulations
+- Data analysis from drone flights
+
+Be concise, helpful, and focus on drone-related topics. If asked about your identity, 
+clearly state that you are DeepDrone, a specialized drone AI assistant."""
+        
+        messages = [{"role": "system", "content": system_prompt}]
+        messages.extend(self.chat_history[-10:])
+        messages.append({"role": "user", "content": message})
+        
+        return self.llm.chat(messages)
+    
+    def _create_system_prompt_with_tools(self) -> str:
+        """Create system prompt with tool information."""
+        return """You are DeepDrone, an AI assistant that can control real drones through Python code.
+
+Available drone control functions:
+- connect_drone(connection_string): Connect to drone
+- disconnect_drone(): Disconnect from drone
+- takeoff(altitude): Take off to specified altitude in meters
+- land(): Land the drone
+- return_home(): Return to launch point
+- fly_to(lat, lon, alt): Fly to GPS coordinates
+- get_location(): Get current GPS position
+- get_battery(): Get battery status
+- execute_mission(waypoints): Execute mission with list of waypoints
+
+When user requests drone operations, write Python code using these functions.
+Always explain what you're doing and provide status updates.
+
+Example:
+```python
+# Connect to drone simulator
+connect_drone('udp:127.0.0.1:14550')
+
+# Take off to 30 meters
+takeoff(30)
+
+# Fly to a specific location
+fly_to(37.7749, -122.4194, 30)
+
+# Return home
+return_home()
+
+# Disconnect
+disconnect_drone()
+```
+
+Be safety-conscious and explain each operation."""
+    
+    def _response_has_tool_calls(self, response: str) -> bool:
+        """Check if response contains Python code blocks."""
+        return "```python" in response or "```" in response
+    
+    def _execute_tool_calls(self, response: str) -> str:
+        """Execute tool calls found in response."""
+        # Extract Python code blocks
+        code_blocks = self._extract_code_blocks(response)
+        
+        results = []
+        for code in code_blocks:
+            try:
+                result = self._execute_code_block(code)
+                results.append(f"✅ Executed: {result}")
+            except Exception as e:
+                results.append(f"❌ Error: {e}")
+        
+        # Append execution results to response
+        if results:
+            response += "\n\n**Execution Results:**\n" + "\n".join(results)
+        
+        return response
+    
+    def _extract_code_blocks(self, text: str) -> List[str]:
+        """Extract Python code blocks from markdown text."""
+        code_blocks = []
+        lines = text.split('\n')
+        in_code_block = False
+        current_block = []
+        
+        for line in lines:
+            if line.strip().startswith('```python') or line.strip().startswith('```'):
+                if in_code_block:
+                    # End of code block
+                    if current_block:
+                        code_blocks.append('\n'.join(current_block))
+                        current_block = []
+                    in_code_block = False
+                else:
+                    # Start of code block
+                    in_code_block = True
+            elif in_code_block:
+                current_block.append(line)
+        
+        return code_blocks
+    
+    def _execute_code_block(self, code: str) -> str:
+        """Execute a code block using drone tools."""
+        # Create a safe execution environment
+        safe_globals = {
+            'connect_drone': self.drone_tools.connect_drone,
+            'disconnect_drone': self.drone_tools.disconnect_drone,
+            'takeoff': self.drone_tools.takeoff,
+            'land': self.drone_tools.land,
+            'return_home': self.drone_tools.return_home,
+            'fly_to': self.drone_tools.fly_to,
+            'get_location': self.drone_tools.get_location,
+            'get_battery': self.drone_tools.get_battery,
+            'execute_mission': self.drone_tools.execute_mission,
+        }
+        
+        # Capture output
+        output = []
+        
+        def capture_print(*args, **kwargs):
+            output.append(' '.join(str(arg) for arg in args))
+        
+        safe_globals['print'] = capture_print
+        
+        # Execute code
+        exec(code, safe_globals)
+        
+        return '\n'.join(output) if output else "Command executed successfully"
+    
+    def _show_response(self, response: str):
+        """Show AI response with formatting."""
+        # Parse as markdown if it contains markdown elements
+        if any(marker in response for marker in ['**', '*', '```', '#', '-', '1.']):
+            content = Markdown(response)
+        else:
+            content = Text(response)
+        
+        self.console.print(Panel(
+            content,
+            title="[bold green]🚁 DeepDrone[/bold green]",
+            border_style="green",
+            padding=(0, 1)
+        ))
+    
+    def _show_help(self):
+        """Show help message."""
+        help_text = """
+[bold]Available Commands:[/bold]
+
+[bold cyan]/help[/bold cyan] - Show this help message
+[bold cyan]/quit[/bold cyan] - Exit the application
+[bold cyan]/clear[/bold cyan] - Clear the screen
+[bold cyan]/history[/bold cyan] - Show chat history
+[bold cyan]/status[/bold cyan] - Show system status
+[bold cyan]/connect <connection>[/bold cyan] - Connect to drone
+[bold cyan]/disconnect[/bold cyan] - Disconnect from drone
+[bold cyan]/models[/bold cyan] - Show current model info
+
+[bold]Drone Commands (natural language):[/bold]
+- "Connect to simulator at udp:127.0.0.1:14550"
+- "Take off to 30 meters"
+- "Fly to coordinates 37.7749, -122.4194 at 50 meters"
+- "Show current location and battery status"
+- "Execute a square flight pattern"
+- "Return home and land"
+
+[bold]Example Conversation:[/bold]
+[dim]You: Connect to the drone simulator
+DeepDrone: I'll connect to the simulator for you...
+You: Take off to 20 meters and fly in a circle
+DeepDrone: Taking off to 20 meters and executing circular pattern...[/dim]
+        """
+        
+        self.console.print(Panel(
+            help_text.strip(),
+            title="[bold]DeepDrone Help[/bold]",
+            border_style="cyan"
+        ))
+    
+    def _show_history(self):
+        """Show chat history."""
+        if not self.chat_history:
+            self.console.print("[yellow]No chat history available[/yellow]")
+            return
+        
+        self.console.print("[bold]Chat History:[/bold]\n")
+        
+        for i, msg in enumerate(self.chat_history[-10:], 1):  # Last 10 messages
+            role_color = "blue" if msg["role"] == "user" else "green"
+            role_name = "You" if msg["role"] == "user" else "DeepDrone"
+            
+            self.console.print(f"[{role_color}]{i}. {role_name}:[/{role_color}] {msg['content'][:100]}...")
+    
+    def _show_status(self):
+        """Show system status."""
+        drone_status = "Connected" if self.drone_tools.is_connected() else "Disconnected"
+        drone_color = "green" if self.drone_tools.is_connected() else "red"
+        
+        status_text = f"""
+[bold]Model:[/bold] {self.model_config.name} ({self.model_config.provider})
+[bold]Drone Status:[/bold] [{drone_color}]{drone_status}[/{drone_color}]
+[bold]Connection:[/bold] {self.connection_string or 'None'}
+[bold]Chat History:[/bold] {len(self.chat_history)} messages
+        """
+        
+        if self.drone_tools.is_connected():
+            try:
+                location = self.drone_tools.get_location()
+                battery = self.drone_tools.get_battery()
+                status_text += f"""
+[bold]Location:[/bold] {location}
+[bold]Battery:[/bold] {battery}
+                """
+            except Exception as e:
+                status_text += f"\n[yellow]Could not get drone telemetry: {e}[/yellow]"
+        
+        self.console.print(Panel(
+            status_text.strip(),
+            title="[bold]System Status[/bold]",
+            border_style="yellow"
+        ))
+    
+    def _connect_drone(self, connection_string: str):
+        """Connect to drone."""
+        self.console.print(f"[yellow]Connecting to drone at {connection_string}...[/yellow]")
+        
+        try:
+            if self.drone_tools.connect_drone(connection_string):
+                self.connection_string = connection_string
+                self.console.print("[green]✅ Connected to drone successfully[/green]")
+            else:
+                self.console.print("[red]❌ Failed to connect to drone[/red]")
+        except Exception as e:
+            self.console.print(f"[red]❌ Connection error: {e}[/red]")
+    
+    def _disconnect_drone(self):
+        """Disconnect from drone."""
+        if self.drone_tools.is_connected():
+            self.drone_tools.disconnect_drone()
+            self.console.print("[yellow]Disconnected from drone[/yellow]")
+        else:
+            self.console.print("[yellow]No drone connection to disconnect[/yellow]")
+    
+    def _show_model_info(self):
+        """Show current model information."""
+        info_text = f"""
+[bold]Name:[/bold] {self.model_config.name}
+[bold]Provider:[/bold] {self.model_config.provider}
+[bold]Model ID:[/bold] {self.model_config.model_id}
+[bold]Max Tokens:[/bold] {self.model_config.max_tokens}
+[bold]Temperature:[/bold] {self.model_config.temperature}
+        """
+        
+        if self.model_config.base_url:
+            info_text += f"\n[bold]Base URL:[/bold] {self.model_config.base_url}"
+        
+        self.console.print(Panel(
+            info_text.strip(),
+            title="[bold]Current Model[/bold]",
+            border_style="magenta"
+        ))

eeprom.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdba0627b42b0ddda657d4b38e46469a0b19a87dae8daa00c2da6f5f2db26bd3
+size 16384

main.py

@@ -1,218 +1,43 @@
-import streamlit as st
-import os
-from dotenv import load_dotenv
-from drone import drone_chat
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Add dark theme CSS right at the beginning
-st.markdown(
-    """
-    <style>
-    /* Dark theme for the entire app, applied immediately */
-    .stApp, body, [data-testid="stAppViewContainer"], .main, .block-container, [data-testid="stHeader"] {
-        background-color: #000000 !important;
-        color: #00ff00 !important;
-    }
-    
-    /* Dark styling for all inputs */
-    [data-testid="stTextInput"] > div, .stTextInput > div {
-        background-color: #1E1E1E !important;
-        color: #00ff00 !important;
-        border: 1px solid #00ff00 !important;
-    }
-    
-    [data-testid="stTextInput"] input, .stTextInput input {
-        color: #00ff00 !important;
-        background-color: #1E1E1E !important;
-    }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
+#!/usr/bin/env python3
+"""
+DeepDrone Terminal Application - AI-Powered Drone Control System
 
-# Page config is set in drone_chat.py at module level
+A terminal-based application for controlling drones using various AI models
+including OpenAI, Anthropic, Hugging Face, and local Ollama models.
+"""
 
-# Remove duplicate page config since it's now in drone_chat.py at module level
-# We'll just import the module and call its main function
-
-def show_auth_screen():
-    """Display the authentication screen with DeepDrone information"""
-    
-    # Military-style header
-    st.markdown("<h1 class='glow-text' style='text-align: center; color: #00ff00; font-family: \"Courier New\", monospace; margin-top: 0; margin-bottom: 10px;'>DEEPDRONE COMMAND CENTER</h1>", unsafe_allow_html=True)
-    st.markdown("<p class='subheader glow-text' style='text-align: center; margin-bottom: 5px;'>SECURE TACTICAL OPERATIONS INTERFACE</p>", unsafe_allow_html=True)
+import sys
+import os
+from pathlib import Path
 
-    # Create a centered container for the auth form
-    st.markdown("<div class='auth-container'>", unsafe_allow_html=True)
-    
-    st.markdown("<div style='text-align: center'>", unsafe_allow_html=True)
-    st.markdown("<h2 style='color: #00ff00; font-family: \"Courier New\", monospace; text-shadow: 0 0 5px #00ff00;'>SYSTEM AUTHENTICATION REQUIRED</h2>", unsafe_allow_html=True)
-    
-    # System status information in a more compact layout
-    cols = st.columns(2)
-    with cols[0]:
-        st.markdown("""
-        <div style='font-family: "Courier New", monospace; color: #00dd00;'>
-        <b>SYSTEM STATUS:</b> STANDBY<br>
-        <b>DATABASE:</b> CONNECTED<br>
-        <b>SECURITY:</b> ENABLED
-        </div>
-        """, unsafe_allow_html=True)
-    
-    with cols[1]:
-        st.markdown("""
-        <div style='font-family: "Courier New", monospace; color: #00dd00;'>
-        <b>PROTOCOL:</b> HF-AUTH-1<br>
-        <b>ENCRYPTION:</b> AES-256<br>
-        <b>AI MODULE:</b> OFFLINE
-        </div>
-        """, unsafe_allow_html=True)
-    
-    # Compact information about DeepDrone
-    st.markdown("""
-    <div style='font-family: "Courier New", monospace; color: #00ff00; text-align: left; margin: 15px 0;'>
-    <p><b>DEEPDRONE</b> is an advanced command and control system for drone operations:</p>
-    
-    <ul style='color: #00ff00; margin: 8px 0; padding-left: 20px;'>
-        <li>Real-time <b>flight data analysis</b> and visualization</li>
-        <li>Comprehensive <b>sensor monitoring</b> with anomaly detection</li>
-        <li>AI-powered <b>mission planning</b> and execution</li>
-        <li>Predictive <b>maintenance scheduling</b> and diagnostics</li>
-    </ul>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    st.markdown("<hr style='border: 1px solid #00ff00; margin: 10px 0;'>", unsafe_allow_html=True)
-    
-    # Token input with custom styling
-    st.markdown("<h3 style='color: #00ff00; font-family: \"Courier New\", monospace; text-shadow: 0 0 5px #00ff00;'>ENTER HUGGING FACE AUTHENTICATION TOKEN FOR THE LLM TO RUN:</h3>", unsafe_allow_html=True)
-    
-    # Create a container with dark background for the input
-    st.markdown("<div style='background-color: #0A0A0A; padding: 10px; border-radius: 5px;'>", unsafe_allow_html=True)
-    api_key = st.text_input("HF Token", type="password", placeholder="Enter Hugging Face API token...", label_visibility="collapsed")
-    st.markdown("</div>", unsafe_allow_html=True)
-    
-    # Submit button with custom styling
-    if st.button("AUTHORIZE ACCESS"):
-        if api_key:
-            os.environ["HF_TOKEN"] = api_key
-            st.markdown("<div style='color: #00ff00; background-color: rgba(0, 128, 0, 0.2); padding: 10px; border: 1px solid #00ff00; border-radius: 5px;'>AUTHENTICATION SUCCESSFUL - INITIALIZING SYSTEM</div>", unsafe_allow_html=True)
-            st.session_state['authenticated'] = True
-            st.rerun()
-    
-    st.markdown("</div>", unsafe_allow_html=True)  # Close text-align center div
-    st.markdown("</div>", unsafe_allow_html=True)  # Close auth-container div
+# Add the current directory to Python path for imports
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
 
 def main():
-    # Add CSS styles
-    st.markdown(
-        """
-        <style>
-        /* Dark theme for the entire app */
-        .stApp, body, [data-testid="stAppViewContainer"] {
-            background-color: #000000 !important;
-            color: #00ff00 !important;
-        }
-        
-        /* Make sure all containers are dark */
-        [data-testid="stVerticalBlock"], [data-testid="stHorizontalBlock"], 
-        [data-testid="stForm"], [data-testid="column"], .stBlock, 
-        [data-testid="stMarkdownContainer"] {
-            background-color: #000000 !important;
-        }
-        
-        /* Dark inputs */
-        [data-testid="stTextInput"] > div {
-            background-color: #1E1E1E !important;
-            color: #00ff00 !important;
-            border: 1px solid #00ff00 !important;
-        }
-        
-        [data-testid="stTextInput"] input {
-            color: #00ff00 !important;
-            background-color: #1E1E1E !important;
-        }
-        
-        /* Dark buttons */
-        .stButton > button {
-            background-color: #0A0A0A !important;
-            color: #00ff00 !important;
-            border: 1px solid #00ff00 !important;
-            border-radius: 2px !important;
-            font-family: "Courier New", monospace !important;
-        }
-        
-        .stButton > button:hover {
-            background-color: #00ff00 !important;
-            color: #000000 !important;
-        }
-        
-        /* Success message styling */
-        .element-container [data-testid="stAlert"] {
-            background-color: rgba(0, 128, 0, 0.2) !important;
-            color: #00ff00 !important;
-            border: 1px solid #00ff00 !important;
-        }
-        
-        /* Header styling */
-        h1, h2, h3, h4, h5, h6, p, span, div, label {
-            color: #00ff00 !important;
-        }
-        
-        /* Centered container for HF token */
-        .auth-container {
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            height: auto;
-            min-height: 400px;
-            max-width: 90vh;
-            width: 70%;
-            margin: 20px auto;
-            padding: 30px;
-            border: 1px solid #00ff00;
-            border-radius: 10px;
-            background-color: #0A0A0A !important;
-            overflow-y: auto;
-        }
-        
-        /* Hide Streamlit's default footer */
-        footer, header {
-            visibility: hidden !important;
-            display: none !important;
-        }
-        
-        /* Remove white background from all components */
-        .block-container, .main {
-            background-color: #000000 !important;
-        }
-        
-        /* Add a slight glow effect to green text */
-        .glow-text {
-            text-shadow: 0 0 5px #00ff00 !important;
-        }
-        
-        /* Custom select styling */
-        [data-testid="stSelectbox"] {
-            background-color: #1E1E1E !important;
-            color: #00ff00 !important;
-            border: 1px solid #00ff00 !important;
-        }
-        </style>
-        """,
-        unsafe_allow_html=True
-    )
-    
-    # Check if user is authenticated
-    if not os.environ.get("HF_TOKEN") and not st.session_state.get('authenticated', False):
-        show_auth_screen()
-        return
-    
-    # Run the drone chat application
-    drone_chat.main()
+    """Main entry point for the DeepDrone terminal application."""
+    try:
+        # Load environment variables if .env file exists
+        env_file = current_dir / ".env"
+        if env_file.exists():
+            from dotenv import load_dotenv
+            load_dotenv(env_file)
+        
+        # If no arguments provided, start interactive mode
+        if len(sys.argv) == 1:
+            from drone.interactive_setup import start_interactive_session
+            start_interactive_session()
+        else:
+            # Run the Typer CLI application for other commands
+            from drone.cli import app
+            app()
+        
+    except KeyboardInterrupt:
+        print("\n🚁 DeepDrone session interrupted. Goodbye!")
+        sys.exit(0)
+    except Exception as e:
+        print(f"❌ Error starting DeepDrone: {e}")
+        sys.exit(1)
 
 if __name__ == "__main__":
     main() 

mav.parm

@@ -0,0 +1,1349 @@
+ACRO_BAL_PITCH   1.000000
+ACRO_BAL_ROLL    1.000000
+ACRO_OPTIONS     0
+ACRO_RP_EXPO     0.300000
+ACRO_RP_RATE     360.000000
+ACRO_RP_RATE_TC  0.000000
+ACRO_THR_MID     0.000000
+ACRO_TRAINER     2
+ACRO_Y_EXPO      0.000000
+ACRO_Y_RATE      202.500000
+ACRO_Y_RATE_TC   0.000000
+ADSB_TYPE        0
+AHRS_COMP_BETA   0.100000
+AHRS_EKF_TYPE    3
+AHRS_GPS_GAIN    1.000000
+AHRS_GPS_MINSATS 6
+AHRS_GPS_USE     1
+AHRS_OPTIONS     0
+AHRS_ORIENTATION 0
+AHRS_RP_P        0.200000
+AHRS_TRIM_X      0.000000
+AHRS_TRIM_Y      0.000000
+AHRS_TRIM_Z      0.000000
+AHRS_WIND_MAX    0
+AHRS_YAW_P       0.200000
+ANGLE_MAX        3000
+ARMING_ACCTHRESH 0.750000
+ARMING_CHECK     1
+ARMING_MAGTHRESH 100
+ARMING_MIS_ITEMS 0
+ARMING_NEED_LOC  0
+ARMING_OPTIONS   0
+ARMING_RUDDER    2
+ARSPD_ENABLE     0
+ATC_ACCEL_P_MAX  110000.000000
+ATC_ACCEL_R_MAX  110000.000000
+ATC_ACCEL_Y_MAX  27000.000000
+ATC_ANGLE_BOOST  1
+ATC_ANG_LIM_TC   1.000000
+ATC_ANG_PIT_P    4.500000
+ATC_ANG_RLL_P    4.500000
+ATC_ANG_YAW_P    4.500000
+ATC_INPUT_TC     0.150000
+ATC_LAND_P_MULT  1.000000
+ATC_LAND_R_MULT  1.000000
+ATC_LAND_Y_MULT  1.000000
+ATC_RATE_FF_ENAB 1
+ATC_RATE_P_MAX   0.000000
+ATC_RATE_R_MAX   0.000000
+ATC_RATE_Y_MAX   0.000000
+ATC_RAT_PIT_D    0.003600
+ATC_RAT_PIT_D_FF 0.000000
+ATC_RAT_PIT_FF   0.000000
+ATC_RAT_PIT_FLTD 20.000000
+ATC_RAT_PIT_FLTE 0.000000
+ATC_RAT_PIT_FLTT 20.000000
+ATC_RAT_PIT_I    0.135000
+ATC_RAT_PIT_IMAX 0.500000
+ATC_RAT_PIT_NEF  0
+ATC_RAT_PIT_NTF  0
+ATC_RAT_PIT_P    0.135000
+ATC_RAT_PIT_PDMX 0.000000
+ATC_RAT_PIT_SMAX 0.000000
+ATC_RAT_RLL_D    0.003600
+ATC_RAT_RLL_D_FF 0.000000
+ATC_RAT_RLL_FF   0.000000
+ATC_RAT_RLL_FLTD 20.000000
+ATC_RAT_RLL_FLTE 0.000000
+ATC_RAT_RLL_FLTT 20.000000
+ATC_RAT_RLL_I    0.135000
+ATC_RAT_RLL_IMAX 0.500000
+ATC_RAT_RLL_NEF  0
+ATC_RAT_RLL_NTF  0
+ATC_RAT_RLL_P    0.135000
+ATC_RAT_RLL_PDMX 0.000000
+ATC_RAT_RLL_SMAX 0.000000
+ATC_RAT_YAW_D    0.000000
+ATC_RAT_YAW_D_FF 0.000000
+ATC_RAT_YAW_FF   0.000000
+ATC_RAT_YAW_FLTD 20.000000
+ATC_RAT_YAW_FLTE 2.500000
+ATC_RAT_YAW_FLTT 20.000000
+ATC_RAT_YAW_I    0.020000
+ATC_RAT_YAW_IMAX 0.500000
+ATC_RAT_YAW_NEF  0
+ATC_RAT_YAW_NTF  0
+ATC_RAT_YAW_P    0.300000
+ATC_RAT_YAW_PDMX 0.000000
+ATC_RAT_YAW_SMAX 0.000000
+ATC_SLEW_YAW     6000.000000
+ATC_THR_G_BOOST  0.000000
+ATC_THR_MIX_MAN  0.100000
+ATC_THR_MIX_MAX  0.500000
+ATC_THR_MIX_MIN  0.100000
+AUTOTUNE_AGGR    0.075000
+AUTOTUNE_AXES    7
+AUTOTUNE_MIN_D   0.000500
+AUTO_OPTIONS     0
+AVD_ENABLE       0
+AVOID_ACCEL_MAX  3.000000
+AVOID_ALT_MIN    0.000000
+AVOID_ANGLE_MAX  1000
+AVOID_BACKUP_DZ  0.100000
+AVOID_BACKUP_SPD 0.750000
+AVOID_BACKZ_SPD  0.750000
+AVOID_BEHAVE     0
+AVOID_DIST_MAX   5.000000
+AVOID_ENABLE     3
+AVOID_MARGIN     2.000000
+BARO1_DEVID      65540
+BARO1_GND_PRESS  94502.828125
+BARO1_WCF_ENABLE 0
+BARO2_DEVID      65796
+BARO2_GND_PRESS  94504.796875
+BARO2_WCF_ENABLE 0
+BARO3_DEVID      0
+BARO3_GND_PRESS  0.000000
+BARO3_WCF_ENABLE 0
+BARO_ALTERR_MAX  2000.000000
+BARO_ALT_OFFSET  0.000000
+BARO_EXT_BUS     -1
+BARO_FIELD_ELV   0.000000
+BARO_FLTR_RNG    0
+BARO_GND_TEMP    0.000000
+BARO_OPTIONS     0
+BARO_PRIMARY     0
+BARO_PROBE_EXT   0
+BATT2_MONITOR    0
+BATT3_MONITOR    0
+BATT4_MONITOR    0
+BATT5_MONITOR    0
+BATT6_MONITOR    0
+BATT7_MONITOR    0
+BATT8_MONITOR    0
+BATT9_MONITOR    0
+BATT_AMP_OFFSET  0.000000
+BATT_AMP_PERVLT  17.000000
+BATT_ARM_MAH     0
+BATT_ARM_VOLT    0.000000
+BATT_CAPACITY    3300
+BATT_CRT_MAH     0.000000
+BATT_CRT_VOLT    0.000000
+BATT_CURR_PIN    12
+BATT_FS_CRT_ACT  0
+BATT_FS_LOW_ACT  0
+BATT_FS_VOLTSRC  0
+BATT_LOW_MAH     0.000000
+BATT_LOW_TIMER   10
+BATT_LOW_VOLT    10.500000
+BATT_MONITOR     4
+BATT_OPTIONS     0
+BATT_SERIAL_NUM  -1
+BATT_VLT_OFFSET  0.000000
+BATT_VOLT_MULT   10.100000
+BATT_VOLT_PIN    13
+BCN_TYPE         0
+BRD_BOOT_DELAY   0
+BRD_OPTIONS      0
+BRD_RTC_TYPES    1
+BRD_RTC_TZ_MIN   0
+BRD_SAFETYOPTION 3
+BRD_SAFETY_DEFLT 0
+BRD_SAFETY_MASK  16368
+BRD_SD_FENCE     0
+BRD_SD_MISSION   0
+BRD_SERIAL_NUM   0
+BRD_VBUS_MIN     4.300000
+BRD_VSERVO_MIN   0.000000
+BTN_ENABLE       0
+CAM1_TYPE        0
+CAM2_TYPE        0
+CAM_AUTO_ONLY    0
+CAM_MAX_ROLL     0
+CAN_D1_PROTOCOL  1
+CAN_D1_PROTOCOL2 0
+CAN_D2_PROTOCOL  1
+CAN_D2_PROTOCOL2 0
+CAN_LOGLEVEL     0
+CAN_P1_DRIVER    0
+CAN_P2_DRIVER    0
+CC_TYPE          0
+CHUTE_ENABLED    0
+CIRCLE_OPTIONS   1
+CIRCLE_RADIUS    1000.000000
+CIRCLE_RATE      20.000000
+COMPASS_AUTODEC  1
+COMPASS_AUTO_ROT 2
+COMPASS_CAL_FIT  16.000000
+COMPASS_DEC      0.000000
+COMPASS_DEV_ID   97539
+COMPASS_DEV_ID2  131874
+COMPASS_DEV_ID3  263178
+COMPASS_DEV_ID4  97283
+COMPASS_DEV_ID5  97795
+COMPASS_DEV_ID6  98051
+COMPASS_DEV_ID7  0
+COMPASS_DEV_ID8  0
+COMPASS_DIA2_X   1.000000
+COMPASS_DIA2_Y   1.000000
+COMPASS_DIA2_Z   1.000000
+COMPASS_DIA3_X   1.000000
+COMPASS_DIA3_Y   1.000000
+COMPASS_DIA3_Z   1.000000
+COMPASS_DIA_X    1.000000
+COMPASS_DIA_Y    1.000000
+COMPASS_DIA_Z    1.000000
+COMPASS_DISBLMSK 0
+COMPASS_ENABLE   1
+COMPASS_EXTERN2  0
+COMPASS_EXTERN3  0
+COMPASS_EXTERNAL 1
+COMPASS_FLTR_RNG 0
+COMPASS_LEARN    0
+COMPASS_MOT2_X   0.000000
+COMPASS_MOT2_Y   0.000000
+COMPASS_MOT2_Z   0.000000
+COMPASS_MOT3_X   0.000000
+COMPASS_MOT3_Y   0.000000
+COMPASS_MOT3_Z   0.000000
+COMPASS_MOTCT    0
+COMPASS_MOT_X    0.000000
+COMPASS_MOT_Y    0.000000
+COMPASS_MOT_Z    0.000000
+COMPASS_ODI2_X   0.000000
+COMPASS_ODI2_Y   0.000000
+COMPASS_ODI2_Z   0.000000
+COMPASS_ODI3_X   0.000000
+COMPASS_ODI3_Y   0.000000
+COMPASS_ODI3_Z   0.000000
+COMPASS_ODI_X    0.000000
+COMPASS_ODI_Y    0.000000
+COMPASS_ODI_Z    0.000000
+COMPASS_OFFS_MAX 1800
+COMPASS_OFS2_X   5.000000
+COMPASS_OFS2_Y   13.000000
+COMPASS_OFS2_Z   -18.000000
+COMPASS_OFS3_X   5.000000
+COMPASS_OFS3_Y   13.000000
+COMPASS_OFS3_Z   -18.000000
+COMPASS_OFS_X    5.000000
+COMPASS_OFS_Y    13.000000
+COMPASS_OFS_Z    -18.000000
+COMPASS_OPTIONS  0
+COMPASS_ORIENT   0
+COMPASS_ORIENT2  0
+COMPASS_ORIENT3  0
+COMPASS_PMOT_EN  0
+COMPASS_PRIO1_ID 97539
+COMPASS_PRIO2_ID 131874
+COMPASS_PRIO3_ID 263178
+COMPASS_SCALE    1.000000
+COMPASS_SCALE2   1.000000
+COMPASS_SCALE3   1.000000
+COMPASS_USE      1
+COMPASS_USE2     1
+COMPASS_USE3     1
+CUST_ROT_ENABLE  0
+DEV_OPTIONS      0
+DID_ENABLE       0
+DISARM_DELAY     10
+EAHRS_TYPE       0
+EFI_TYPE         0
+EK2_ENABLE       0
+EK3_ABIAS_P_NSE  0.020000
+EK3_ACC_BIAS_LIM 1.000000
+EK3_ACC_P_NSE    0.350000
+EK3_AFFINITY     0
+EK3_ALT_M_NSE    2.000000
+EK3_BCN_DELAY    50
+EK3_BCN_I_GTE    500
+EK3_BCN_M_NSE    1.000000
+EK3_BETA_MASK    0
+EK3_CHECK_SCALE  100
+EK3_DRAG_BCOEF_X 0.000000
+EK3_DRAG_BCOEF_Y 0.000000
+EK3_DRAG_MCOEF   0.000000
+EK3_DRAG_M_NSE   0.500000
+EK3_EAS_I_GATE   400
+EK3_EAS_M_NSE    1.400000
+EK3_ENABLE       1
+EK3_ERR_THRESH   0.200000
+EK3_FLOW_DELAY   10
+EK3_FLOW_I_GATE  300
+EK3_FLOW_M_NSE   0.250000
+EK3_FLOW_USE     1
+EK3_GBIAS_P_NSE  0.001000
+EK3_GLITCH_RAD   25
+EK3_GND_EFF_DZ   4.000000
+EK3_GPS_CHECK    31
+EK3_GPS_VACC_MAX 0.000000
+EK3_GSF_RST_MAX  2
+EK3_GSF_RUN_MASK 3
+EK3_GSF_USE_MASK 3
+EK3_GYRO_P_NSE   0.015000
+EK3_HGT_DELAY    60
+EK3_HGT_I_GATE   500
+EK3_HRT_FILT     2.000000
+EK3_IMU_MASK     3
+EK3_LOG_LEVEL    0
+EK3_MAGB_P_NSE   0.000100
+EK3_MAGE_P_NSE   0.001000
+EK3_MAG_CAL      3
+EK3_MAG_EF_LIM   50
+EK3_MAG_I_GATE   300
+EK3_MAG_MASK     0
+EK3_MAG_M_NSE    0.050000
+EK3_MAX_FLOW     2.500000
+EK3_NOAID_M_NSE  10.000000
+EK3_OGNM_TEST_SF 2.000000
+EK3_OGN_HGT_MASK 0
+EK3_OPTIONS      0
+EK3_POSNE_M_NSE  0.500000
+EK3_POS_I_GATE   500
+EK3_PRIMARY      0
+EK3_RNG_I_GATE   500
+EK3_RNG_M_NSE    0.500000
+EK3_RNG_USE_HGT  -1
+EK3_RNG_USE_SPD  2.000000
+EK3_SRC1_POSXY   3
+EK3_SRC1_POSZ    1
+EK3_SRC1_VELXY   3
+EK3_SRC1_VELZ    3
+EK3_SRC1_YAW     1
+EK3_SRC2_POSXY   0
+EK3_SRC2_POSZ    1
+EK3_SRC2_VELXY   0
+EK3_SRC2_VELZ    0
+EK3_SRC2_YAW     0
+EK3_SRC3_POSXY   0
+EK3_SRC3_POSZ    1
+EK3_SRC3_VELXY   0
+EK3_SRC3_VELZ    0
+EK3_SRC3_YAW     0
+EK3_SRC_OPTIONS  1
+EK3_TAU_OUTPUT   25
+EK3_TERR_GRAD    0.100000
+EK3_VELD_M_NSE   0.500000
+EK3_VELNE_M_NSE  0.300000
+EK3_VEL_I_GATE   500
+EK3_VIS_VERR_MAX 0.900000
+EK3_VIS_VERR_MIN 0.100000
+EK3_WENC_VERR    0.100000
+EK3_WIND_PSCALE  1.000000
+EK3_WIND_P_NSE   0.200000
+EK3_YAW_I_GATE   300
+EK3_YAW_M_NSE    0.500000
+ESC_CALIBRATION  0
+ESC_TLM_MAV_OFS  0
+FENCE_ACTION     1
+FENCE_ALT_MAX    100.000000
+FENCE_ALT_MIN    -10.000000
+FENCE_AUTOENABLE 0
+FENCE_ENABLE     0
+FENCE_MARGIN     2.000000
+FENCE_NTF_FREQ   1.000000
+FENCE_OPTIONS    0
+FENCE_RADIUS     150.000000
+FENCE_TOTAL      0
+FENCE_TYPE       7
+FFT_ENABLE       0
+FHLD_BRAKE_RATE  8
+FHLD_FILT_HZ     5.000000
+FHLD_FLOW_MAX    0.600000
+FHLD_QUAL_MIN    10
+FHLD_XY_FILT_HZ  5.000000
+FHLD_XY_I        0.300000
+FHLD_XY_IMAX     3000.000000
+FHLD_XY_P        0.200000
+FILT1_TYPE       0
+FILT2_TYPE       0
+FILT3_TYPE       0
+FILT4_TYPE       0
+FILT5_TYPE       0
+FILT6_TYPE       0
+FILT7_TYPE       0
+FILT8_TYPE       0
+FLIGHT_OPTIONS   0
+FLOW_TYPE        0
+FLTMODE1         7
+FLTMODE2         9
+FLTMODE3         6
+FLTMODE4         3
+FLTMODE5         5
+FLTMODE6         0
+FLTMODE_CH       5
+FLTMODE_GCSBLOCK 0
+FOLL_ENABLE      0
+FORMAT_VERSION   120
+FRAME_CLASS      1
+FRAME_TYPE       0
+FRSKY_DNLINK1_ID 20
+FRSKY_DNLINK2_ID 7
+FRSKY_DNLINK_ID  27
+FRSKY_OPTIONS    0
+FRSKY_UPLINK_ID  13
+FSTRATE_DIV      1
+FSTRATE_ENABLE   0
+FS_CRASH_CHECK   1
+FS_DR_ENABLE     2
+FS_DR_TIMEOUT    30
+FS_EKF_ACTION    1
+FS_EKF_FILT      5.000000
+FS_EKF_THRESH    0.800000
+FS_GCS_ENABLE    0
+FS_GCS_TIMEOUT   5.000000
+FS_OPTIONS       16
+FS_THR_ENABLE    1
+FS_THR_VALUE     975
+FS_VIBE_ENABLE   1
+GCS_PID_MASK     0
+GEN_TYPE         0
+GND_EFFECT_COMP  1
+GPS1_CAN_NODEID  0
+GPS1_CAN_OVRIDE  0
+GPS1_COM_PORT    1
+GPS1_DELAY_MS    0
+GPS1_GNSS_MODE   0
+GPS1_MB_TYPE     0
+GPS1_POS_X       0.000000
+GPS1_POS_Y       0.000000
+GPS1_POS_Z       0.000000
+GPS1_RATE_MS     200
+GPS1_TYPE        1
+GPS2_TYPE        0
+GPS_AUTO_CONFIG  1
+GPS_AUTO_SWITCH  1
+GPS_BLEND_MASK   5
+GPS_DRV_OPTIONS  0
+GPS_HDOP_GOOD    140
+GPS_INJECT_TO    127
+GPS_MIN_ELEV     -100
+GPS_NAVFILTER    8
+GPS_PRIMARY      0
+GPS_RAW_DATA     0
+GPS_SAVE_CFG     2
+GPS_SBAS_MODE    2
+GPS_SBP_LOGMASK  -256
+GRIP_ENABLE      0
+GUID_OPTIONS     0
+GUID_TIMEOUT     3.000000
+INITIAL_MODE     0
+INS_ACC1_CALTEMP -300.000000
+INS_ACC2OFFS_X   0.001000
+INS_ACC2OFFS_Y   0.001000
+INS_ACC2OFFS_Z   0.001000
+INS_ACC2SCAL_X   1.001000
+INS_ACC2SCAL_Y   1.001000
+INS_ACC2SCAL_Z   1.001000
+INS_ACC2_CALTEMP -300.000000
+INS_ACC2_ID      0
+INS_ACC3OFFS_X   0.000000
+INS_ACC3OFFS_Y   0.000000
+INS_ACC3OFFS_Z   0.000000
+INS_ACC3SCAL_X   1.000000
+INS_ACC3SCAL_Y   1.000000
+INS_ACC3SCAL_Z   1.000000
+INS_ACC3_CALTEMP -300.000000
+INS_ACC3_ID      0
+INS_ACCEL_FILTER 20
+INS_ACCOFFS_X    0.001000
+INS_ACCOFFS_Y    0.001000
+INS_ACCOFFS_Z    0.001000
+INS_ACCSCAL_X    1.001000
+INS_ACCSCAL_Y    1.001000
+INS_ACCSCAL_Z    1.001000
+INS_ACC_BODYFIX  2
+INS_ACC_ID       0
+INS_ENABLE_MASK  127
+INS_FAST_SAMPLE  1
+INS_GYR1_CALTEMP -300.000000
+INS_GYR2OFFS_X   0.000000
+INS_GYR2OFFS_Y   0.000000
+INS_GYR2OFFS_Z   0.000000
+INS_GYR2_CALTEMP -300.000000
+INS_GYR2_ID      0
+INS_GYR3OFFS_X   0.000000
+INS_GYR3OFFS_Y   0.000000
+INS_GYR3OFFS_Z   0.000000
+INS_GYR3_CALTEMP -300.000000
+INS_GYR3_ID      0
+INS_GYROFFS_X    0.000000
+INS_GYROFFS_Y    0.000000
+INS_GYROFFS_Z    0.000000
+INS_GYRO_FILTER  20
+INS_GYRO_RATE    0
+INS_GYR_CAL      1
+INS_GYR_ID       0
+INS_HNTC2_ENABLE 0
+INS_HNTCH_ENABLE 0
+INS_LOG_BAT_CNT  1024
+INS_LOG_BAT_LGCT 32
+INS_LOG_BAT_LGIN 20
+INS_LOG_BAT_MASK 0
+INS_LOG_BAT_OPT  0
+INS_POS1_X       0.000000
+INS_POS1_Y       0.000000
+INS_POS1_Z       0.000000
+INS_POS2_X       0.000000
+INS_POS2_Y       0.000000
+INS_POS2_Z       0.000000
+INS_POS3_X       0.000000
+INS_POS3_Y       0.000000
+INS_POS3_Z       0.000000
+INS_RAW_LOG_OPT  0
+INS_STILL_THRESH 2.500000
+INS_TCAL1_ENABLE 0
+INS_TCAL2_ENABLE 0
+INS_TCAL3_ENABLE 0
+INS_TCAL_OPTIONS 0
+INS_TRIM_OPTION  1
+INS_USE          1
+INS_USE2         1
+INS_USE3         1
+KDE_NPOLE        14
+LAND_ALT_LOW     1000
+LAND_REPOSITION  1
+LAND_SPEED       50
+LAND_SPEED_HIGH  0
+LGR_ENABLE       0
+LOG_BACKEND_TYPE 1
+LOG_BITMASK      180222
+LOG_BLK_RATEMAX  0.000000
+LOG_DARM_RATEMAX 0.000000
+LOG_DISARMED     0
+LOG_FILE_BUFSIZE 200
+LOG_FILE_DSRMROT 0
+LOG_FILE_MB_FREE 500
+LOG_FILE_RATEMAX 0.000000
+LOG_FILE_TIMEOUT 5
+LOG_MAV_BUFSIZE  8
+LOG_MAV_RATEMAX  0.000000
+LOG_MAX_FILES    500
+LOG_REPLAY       0
+LOIT_ACC_MAX     500.000000
+LOIT_ANG_MAX     0.000000
+LOIT_BRK_ACCEL   250.000000
+LOIT_BRK_DELAY   1.000000
+LOIT_BRK_JERK    500.000000
+LOIT_SPEED       1250.000000
+MAV1_ADSB        0
+MAV1_EXTRA1      0
+MAV1_EXTRA2      0
+MAV1_EXTRA3      0
+MAV1_EXT_STAT    0
+MAV1_PARAMS      0
+MAV1_POSITION    0
+MAV1_RAW_CTRL    0
+MAV1_RAW_SENS    0
+MAV1_RC_CHAN     0
+MAV2_ADSB        0
+MAV2_EXTRA1      0
+MAV2_EXTRA2      0
+MAV2_EXTRA3      0
+MAV2_EXT_STAT    0
+MAV2_PARAMS      0
+MAV2_POSITION    0
+MAV2_RAW_CTRL    0
+MAV2_RAW_SENS    0
+MAV2_RC_CHAN     0
+MAV3_ADSB        0
+MAV3_EXTRA1      0
+MAV3_EXTRA2      0
+MAV3_EXTRA3      0
+MAV3_EXT_STAT    0
+MAV3_PARAMS      0
+MAV3_POSITION    0
+MAV3_RAW_CTRL    0
+MAV3_RAW_SENS    0
+MAV3_RC_CHAN     0
+MAV_GCS_SYSID    255
+MAV_OPTIONS      0
+MAV_SYSID        1
+MAV_TELEM_DELAY  0
+MIS_OPTIONS      0
+MIS_RESTART      0
+MIS_TOTAL        0
+MNT1_TYPE        0
+MNT2_TYPE        0
+MOT_BAT_CURR_MAX 0.000000
+MOT_BAT_CURR_TC  5.000000
+MOT_BAT_IDX      0
+MOT_BAT_VOLT_MAX 12.800000
+MOT_BAT_VOLT_MIN 9.600000
+MOT_BOOST_SCALE  0.000000
+MOT_HOVER_LEARN  2
+MOT_OPTIONS      0
+MOT_PWM_MAX      2000
+MOT_PWM_MIN      1000
+MOT_PWM_TYPE     0
+MOT_SAFE_DISARM  0
+MOT_SAFE_TIME    1.000000
+MOT_SLEW_DN_TIME 0.000000
+MOT_SLEW_UP_TIME 0.000000
+MOT_SPIN_ARM     0.100000
+MOT_SPIN_MAX     0.950000
+MOT_SPIN_MIN     0.150000
+MOT_SPOOL_TIME   0.500000
+MOT_SPOOL_TIM_DN 0.000000
+MOT_THST_EXPO    0.650000
+MOT_THST_HOVER   0.390000
+MOT_YAW_HEADROOM 200
+MSP_OPTIONS      0
+MSP_OSD_NCELLS   0
+NET_ENABLE       0
+NET_P1_TYPE      0
+NET_P2_TYPE      0
+NET_P3_TYPE      0
+NET_P4_TYPE      0
+NMEA_MSG_EN      3
+NMEA_RATE_MS     100
+NTF_BUZZ_ON_LVL  1
+NTF_BUZZ_PIN     -1
+NTF_BUZZ_TYPES   5
+NTF_BUZZ_VOLUME  100
+NTF_DISPLAY_TYPE 0
+NTF_LED_BRIGHT   3
+NTF_LED_LEN      1
+NTF_LED_OVERRIDE 0
+NTF_LED_TYPES    123079
+OA_TYPE          0
+OSD_TYPE         0
+PHLD_BRAKE_ANGLE 3000
+PHLD_BRAKE_RATE  8
+PILOT_ACCEL_Z    250
+PILOT_SPEED_DN   0
+PILOT_SPEED_UP   250
+PILOT_THR_BHV    0
+PILOT_THR_FILT   0.000000
+PILOT_TKOFF_ALT  0.000000
+PILOT_Y_EXPO     0.000000
+PILOT_Y_RATE     202.500000
+PILOT_Y_RATE_TC  0.000000
+PLDP_DELAY       0.000000
+PLDP_RNG_MAX     0.000000
+PLDP_SPEED_DN    0.000000
+PLDP_THRESH      0.900000
+PLND_ENABLED     0
+PRX1_TYPE        0
+PRX2_TYPE        0
+PRX3_TYPE        0
+PRX4_TYPE        0
+PRX5_TYPE        0
+PRX_ALT_MIN      1.000000
+PRX_FILT         0.250000
+PRX_IGN_GND      0
+PRX_LOG_RAW      0
+PSC_ACCZ_D       0.000000
+PSC_ACCZ_D_FF    0.000000
+PSC_ACCZ_FF      0.000000
+PSC_ACCZ_FLTD    0.000000
+PSC_ACCZ_FLTE    20.000000
+PSC_ACCZ_FLTT    0.000000
+PSC_ACCZ_I       1.000000
+PSC_ACCZ_IMAX    800.000000
+PSC_ACCZ_NEF     0
+PSC_ACCZ_NTF     0
+PSC_ACCZ_P       0.500000
+PSC_ACCZ_PDMX    0.000000
+PSC_ACCZ_SMAX    0.000000
+PSC_ANGLE_MAX    0.000000
+PSC_JERK_XY      5.000000
+PSC_JERK_Z       5.000000
+PSC_POSXY_P      1.000000
+PSC_POSZ_P       1.000000
+PSC_VELXY_D      0.500000
+PSC_VELXY_FF     0.000000
+PSC_VELXY_FLTD   5.000000
+PSC_VELXY_FLTE   5.000000
+PSC_VELXY_I      1.000000
+PSC_VELXY_IMAX   1000.000000
+PSC_VELXY_P      2.000000
+PSC_VELZ_D       0.000000
+PSC_VELZ_FF      0.000000
+PSC_VELZ_FLTD    5.000000
+PSC_VELZ_FLTE    5.000000
+PSC_VELZ_I       0.000000
+PSC_VELZ_IMAX    1000.000000
+PSC_VELZ_P       5.000000
+RALLY_INCL_HOME  1
+RALLY_LIMIT_KM   0.300000
+RALLY_TOTAL      0
+RC10_DZ          0
+RC10_MAX         1900
+RC10_MIN         1100
+RC10_OPTION      0
+RC10_REVERSED    0
+RC10_TRIM        1500
+RC11_DZ          0
+RC11_MAX         1900
+RC11_MIN         1100
+RC11_OPTION      0
+RC11_REVERSED    0
+RC11_TRIM        1500
+RC12_DZ          0
+RC12_MAX         1900
+RC12_MIN         1100
+RC12_OPTION      0
+RC12_REVERSED    0
+RC12_TRIM        1500
+RC13_DZ          0
+RC13_MAX         1900
+RC13_MIN         1100
+RC13_OPTION      0
+RC13_REVERSED    0
+RC13_TRIM        1500
+RC14_DZ          0
+RC14_MAX         1900
+RC14_MIN         1100
+RC14_OPTION      0
+RC14_REVERSED    0
+RC14_TRIM        1500
+RC15_DZ          0
+RC15_MAX         1900
+RC15_MIN         1100
+RC15_OPTION      0
+RC15_REVERSED    0
+RC15_TRIM        1500
+RC16_DZ          0
+RC16_MAX         1900
+RC16_MIN         1100
+RC16_OPTION      0
+RC16_REVERSED    0
+RC16_TRIM        1500
+RC1_DZ           20
+RC1_MAX          2000
+RC1_MIN          1000
+RC1_OPTION       0
+RC1_REVERSED     0
+RC1_TRIM         1500
+RC2_DZ           20
+RC2_MAX          2000
+RC2_MIN          1000
+RC2_OPTION       0
+RC2_REVERSED     0
+RC2_TRIM         1500
+RC3_DZ           30
+RC3_MAX          2000
+RC3_MIN          1000
+RC3_OPTION       0
+RC3_REVERSED     0
+RC3_TRIM         1500
+RC4_DZ           20
+RC4_MAX          2000
+RC4_MIN          1000
+RC4_OPTION       0
+RC4_REVERSED     0
+RC4_TRIM         1500
+RC5_DZ           0
+RC5_MAX          2000
+RC5_MIN          1000
+RC5_OPTION       0
+RC5_REVERSED     0
+RC5_TRIM         1500
+RC6_DZ           0
+RC6_MAX          2000
+RC6_MIN          1000
+RC6_OPTION       0
+RC6_REVERSED     0
+RC6_TRIM         1500
+RC7_DZ           0
+RC7_MAX          2000
+RC7_MIN          1000
+RC7_OPTION       7
+RC7_REVERSED     0
+RC7_TRIM         1500
+RC8_DZ           0
+RC8_MAX          2000
+RC8_MIN          1000
+RC8_OPTION       0
+RC8_REVERSED     0
+RC8_TRIM         1500
+RC9_DZ           0
+RC9_MAX          1900
+RC9_MIN          1100
+RC9_OPTION       0
+RC9_REVERSED     0
+RC9_TRIM         1500
+RCMAP_PITCH      2
+RCMAP_ROLL       1
+RCMAP_THROTTLE   3
+RCMAP_YAW        4
+RC_FS_TIMEOUT    1.000000
+RC_OPTIONS       32
+RC_OVERRIDE_TIME 3.000000
+RC_PROTOCOLS     1
+RC_SPEED         490
+RELAY1_DEFAULT   0
+RELAY1_FUNCTION  1
+RELAY1_INVERTED  0
+RELAY1_PIN       13
+RELAY2_FUNCTION  0
+RELAY3_FUNCTION  0
+RELAY4_FUNCTION  0
+RELAY5_FUNCTION  0
+RELAY6_FUNCTION  0
+RNGFND1_TYPE     0
+RNGFND2_TYPE     0
+RNGFND3_TYPE     0
+RNGFND4_TYPE     0
+RNGFND5_TYPE     0
+RNGFND6_TYPE     0
+RNGFND7_TYPE     0
+RNGFND8_TYPE     0
+RNGFND9_TYPE     0
+RNGFNDA_TYPE     0
+RNGFND_FILT      0.500000
+RPM1_TYPE        0
+RPM2_TYPE        0
+RSSI_TYPE        0
+RTL_ALT          1500
+RTL_ALT_FINAL    0
+RTL_ALT_TYPE     0
+RTL_CLIMB_MIN    0
+RTL_CONE_SLOPE   3.000000
+RTL_LOIT_TIME    5000
+RTL_OPTIONS      0
+RTL_SPEED        0
+SCHED_DEBUG      0
+SCHED_LOOP_RATE  400
+SCHED_OPTIONS    0
+SCR_ENABLE       0
+SERIAL0_BAUD     115
+SERIAL0_PROTOCOL 2
+SERIAL1_BAUD     57
+SERIAL1_OPTIONS  0
+SERIAL1_PROTOCOL 2
+SERIAL2_BAUD     57
+SERIAL2_OPTIONS  0
+SERIAL2_PROTOCOL 2
+SERIAL3_BAUD     230
+SERIAL3_OPTIONS  0
+SERIAL3_PROTOCOL 5
+SERIAL4_BAUD     230
+SERIAL4_OPTIONS  0
+SERIAL4_PROTOCOL 5
+SERIAL5_BAUD     57
+SERIAL5_OPTIONS  0
+SERIAL5_PROTOCOL -1
+SERIAL6_BAUD     57
+SERIAL6_OPTIONS  0
+SERIAL6_PROTOCOL -1
+SERIAL7_BAUD     57
+SERIAL7_OPTIONS  0
+SERIAL7_PROTOCOL -1
+SERIAL_PASS1     0
+SERIAL_PASS2     -1
+SERIAL_PASSTIMO  15
+SERVO10_FUNCTION 0
+SERVO10_MAX      1900
+SERVO10_MIN      1100
+SERVO10_REVERSED 0
+SERVO10_TRIM     1500
+SERVO11_FUNCTION 0
+SERVO11_MAX      1900
+SERVO11_MIN      1100
+SERVO11_REVERSED 0
+SERVO11_TRIM     1500
+SERVO12_FUNCTION 0
+SERVO12_MAX      1900
+SERVO12_MIN      1100
+SERVO12_REVERSED 0
+SERVO12_TRIM     1500
+SERVO13_FUNCTION 0
+SERVO13_MAX      1900
+SERVO13_MIN      1100
+SERVO13_REVERSED 0
+SERVO13_TRIM     1500
+SERVO14_FUNCTION 0
+SERVO14_MAX      1900
+SERVO14_MIN      1100
+SERVO14_REVERSED 0
+SERVO14_TRIM     1500
+SERVO15_FUNCTION 0
+SERVO15_MAX      1900
+SERVO15_MIN      1100
+SERVO15_REVERSED 0
+SERVO15_TRIM     1500
+SERVO16_FUNCTION 0
+SERVO16_MAX      1900
+SERVO16_MIN      1100
+SERVO16_REVERSED 0
+SERVO16_TRIM     1500
+SERVO1_FUNCTION  33
+SERVO1_MAX       1900
+SERVO1_MIN       1100
+SERVO1_REVERSED  0
+SERVO1_TRIM      1500
+SERVO2_FUNCTION  34
+SERVO2_MAX       1900
+SERVO2_MIN       1100
+SERVO2_REVERSED  0
+SERVO2_TRIM      1500
+SERVO3_FUNCTION  35
+SERVO3_MAX       1900
+SERVO3_MIN       1100
+SERVO3_REVERSED  0
+SERVO3_TRIM      1500
+SERVO4_FUNCTION  36
+SERVO4_MAX       1900
+SERVO4_MIN       1100
+SERVO4_REVERSED  0
+SERVO4_TRIM      1500
+SERVO5_FUNCTION  0
+SERVO5_MAX       1900
+SERVO5_MIN       1100
+SERVO5_REVERSED  0
+SERVO5_TRIM      1500
+SERVO6_FUNCTION  0
+SERVO6_MAX       1900
+SERVO6_MIN       1100
+SERVO6_REVERSED  0
+SERVO6_TRIM      1500
+SERVO7_FUNCTION  0
+SERVO7_MAX       1900
+SERVO7_MIN       1100
+SERVO7_REVERSED  0
+SERVO7_TRIM      1500
+SERVO8_FUNCTION  0
+SERVO8_MAX       1900
+SERVO8_MIN       1100
+SERVO8_REVERSED  0
+SERVO8_TRIM      1500
+SERVO9_FUNCTION  0
+SERVO9_MAX       1900
+SERVO9_MIN       1100
+SERVO9_REVERSED  0
+SERVO9_TRIM      1500
+SERVO_32_ENABLE  0
+SERVO_DSHOT_ESC  0
+SERVO_DSHOT_RATE 0
+SERVO_FTW_MASK   0
+SERVO_FTW_POLES  14
+SERVO_FTW_RVMASK 0
+SERVO_GPIO_MASK  0
+SERVO_RATE       50
+SERVO_RC_FS_MSK  0
+SERVO_ROB_POSMAX 4095
+SERVO_ROB_POSMIN 0
+SERVO_SBUS_RATE  50
+SERVO_VOLZ_MASK  0
+SERVO_VOLZ_RANGE 200
+SID_AXIS         0
+SIMPLE           0
+SIM_ACC1_BIAS_X  0.000000
+SIM_ACC1_BIAS_Y  0.000000
+SIM_ACC1_BIAS_Z  0.000000
+SIM_ACC1_RND     0.000000
+SIM_ACC1_SCAL_X  0.000000
+SIM_ACC1_SCAL_Y  0.000000
+SIM_ACC1_SCAL_Z  0.000000
+SIM_ACC2_BIAS_X  0.000000
+SIM_ACC2_BIAS_Y  0.000000
+SIM_ACC2_BIAS_Z  0.000000
+SIM_ACC2_RND     0.000000
+SIM_ACC2_SCAL_X  0.000000
+SIM_ACC2_SCAL_Y  0.000000
+SIM_ACC2_SCAL_Z  0.000000
+SIM_ACC3_BIAS_X  0.000000
+SIM_ACC3_BIAS_Y  0.000000
+SIM_ACC3_BIAS_Z  0.000000
+SIM_ACC3_RND     0.000000
+SIM_ACC3_SCAL_X  0.000000
+SIM_ACC3_SCAL_Y  0.000000
+SIM_ACC3_SCAL_Z  0.000000
+SIM_ACCEL1_FAIL  0.000000
+SIM_ACCEL2_FAIL  0.000000
+SIM_ACCEL3_FAIL  0.000000
+SIM_ACC_FAIL_MSK 0
+SIM_ACC_FILE_RW  0
+SIM_ACC_TRIM_X   0.000000
+SIM_ACC_TRIM_Y   0.000000
+SIM_ACC_TRIM_Z   0.000000
+SIM_ADSB_ALT     1000.000000
+SIM_ADSB_COUNT   -1
+SIM_ADSB_RADIUS  10000.000000
+SIM_ADSB_TX      0
+SIM_ADSB_TYPES   1
+SIM_ARSPD2_FAIL  0.000000
+SIM_ARSPD2_FAILP 0.000000
+SIM_ARSPD2_OFS   2013.000000
+SIM_ARSPD2_PITOT 0.000000
+SIM_ARSPD2_RATIO 1.990000
+SIM_ARSPD2_RND   2.000000
+SIM_ARSPD2_SIGN  0
+SIM_ARSPD_FAIL   0.000000
+SIM_ARSPD_FAILP  0.000000
+SIM_ARSPD_OFS    2013.000000
+SIM_ARSPD_PITOT  0.000000
+SIM_ARSPD_RATIO  1.990000
+SIM_ARSPD_RND    2.000000
+SIM_ARSPD_SIGN   0
+SIM_BAR2_DELAY   0
+SIM_BAR2_DISABLE 0
+SIM_BAR2_DRIFT   0.000000
+SIM_BAR2_FREEZE  0
+SIM_BAR2_GLITCH  0.000000
+SIM_BAR2_RND     0.200000
+SIM_BAR2_WCF_BAK 0.000000
+SIM_BAR2_WCF_DN  0.000000
+SIM_BAR2_WCF_FWD 0.000000
+SIM_BAR2_WCF_LFT 0.000000
+SIM_BAR2_WCF_RGT 0.000000
+SIM_BAR2_WCF_UP  0.000000
+SIM_BAR3_DELAY   0
+SIM_BAR3_DISABLE 0
+SIM_BAR3_DRIFT   0.000000
+SIM_BAR3_FREEZE  0
+SIM_BAR3_GLITCH  0.000000
+SIM_BAR3_RND     0.200000
+SIM_BAR3_WCF_BAK 0.000000
+SIM_BAR3_WCF_DN  0.000000
+SIM_BAR3_WCF_FWD 0.000000
+SIM_BAR3_WCF_LFT 0.000000
+SIM_BAR3_WCF_RGT 0.000000
+SIM_BAR3_WCF_UP  0.000000
+SIM_BARO_COUNT   2
+SIM_BARO_DELAY   0
+SIM_BARO_DISABLE 0
+SIM_BARO_DRIFT   0.000000
+SIM_BARO_FREEZE  0
+SIM_BARO_GLITCH  0.000000
+SIM_BARO_RND     0.000000
+SIM_BARO_WCF_BAK 0.000000
+SIM_BARO_WCF_DN  0.000000
+SIM_BARO_WCF_FWD 0.000000
+SIM_BARO_WCF_LFT 0.000000
+SIM_BARO_WCF_RGT 0.000000
+SIM_BARO_WCF_UP  0.000000
+SIM_BATT_CAP_AH  0.000000
+SIM_BATT_VOLTAGE 12.600000
+SIM_BAUDLIMIT_EN 0
+SIM_CAN_SRV_MSK  0
+SIM_CAN_TYPE1    1
+SIM_CAN_TYPE2    1
+SIM_CLAMP_CH     0
+SIM_DRIFT_SPEED  0.050000
+SIM_DRIFT_TIME   5.000000
+SIM_EFI_TYPE     0
+SIM_ENGINE_FAIL  0
+SIM_ENGINE_MUL   0.000000
+SIM_ESC_ARM_RPM  0.000000
+SIM_ESC_TELEM    1
+SIM_FLOAT_EXCEPT 1
+SIM_FLOW_DELAY   0
+SIM_FLOW_ENABLE  0
+SIM_FLOW_POS_X   0.000000
+SIM_FLOW_POS_Y   0.000000
+SIM_FLOW_POS_Z   0.000000
+SIM_FLOW_RATE    10
+SIM_FLOW_RND     0.050000
+SIM_FTOWESC_ENA  0
+SIM_FTOWESC_POW  4095
+SIM_GND_BEHAV    -1
+SIM_GPS1_ACC     0.300000
+SIM_GPS1_ALT_OFS 0
+SIM_GPS1_BYTELOS 0.000000
+SIM_GPS1_DRFTALT 0.000000
+SIM_GPS1_ENABLE  1
+SIM_GPS1_GLTCH_X 0.000000
+SIM_GPS1_GLTCH_Y 0.000000
+SIM_GPS1_GLTCH_Z 0.000000
+SIM_GPS1_HDG     0
+SIM_GPS1_HZ      5
+SIM_GPS1_JAM     0
+SIM_GPS1_LAG_MS  100
+SIM_GPS1_LCKTIME 0
+SIM_GPS1_NOISE   0.000000
+SIM_GPS1_NUMSATS 10
+SIM_GPS1_POS_X   0.000000
+SIM_GPS1_POS_Y   0.000000
+SIM_GPS1_POS_Z   0.000000
+SIM_GPS1_TYPE    1
+SIM_GPS1_VERR_X  0.000000
+SIM_GPS1_VERR_Y  0.000000
+SIM_GPS1_VERR_Z  0.000000
+SIM_GPS2_ENABLE  0
+SIM_GPS3_ENABLE  0
+SIM_GPS4_ENABLE  0
+SIM_GPS_LOG_NUM  0
+SIM_GRPE_ENABLE  0
+SIM_GRPE_PIN     -1
+SIM_GRPS_ENABLE  0
+SIM_GRPS_GRAB    2000
+SIM_GRPS_PIN     -1
+SIM_GRPS_RELEASE 1000
+SIM_GRPS_REVERSE 0
+SIM_GYR1_BIAS_X  0.000000
+SIM_GYR1_BIAS_Y  0.000000
+SIM_GYR1_BIAS_Z  0.000000
+SIM_GYR1_RND     0.000000
+SIM_GYR1_SCALE_X 0.000000
+SIM_GYR1_SCALE_Y 0.000000
+SIM_GYR1_SCALE_Z 0.000000
+SIM_GYR2_BIAS_X  0.000000
+SIM_GYR2_BIAS_Y  0.000000
+SIM_GYR2_BIAS_Z  0.000000
+SIM_GYR2_RND     0.000000
+SIM_GYR2_SCALE_X 0.000000
+SIM_GYR2_SCALE_Y 0.000000
+SIM_GYR2_SCALE_Z 0.000000
+SIM_GYR3_BIAS_X  0.000000
+SIM_GYR3_BIAS_Y  0.000000
+SIM_GYR3_BIAS_Z  0.000000
+SIM_GYR3_RND     0.000000
+SIM_GYR3_SCALE_X 0.000000
+SIM_GYR3_SCALE_Y 0.000000
+SIM_GYR3_SCALE_Z 0.000000
+SIM_GYR_FAIL_MSK 0
+SIM_GYR_FILE_RW  0
+SIM_IE24_ENABLE  0
+SIM_IE24_ERROR   0
+SIM_IE24_STATE   -1
+SIM_IMUT1_ENABLE 0
+SIM_IMUT2_ENABLE 0
+SIM_IMUT3_ENABLE 0
+SIM_IMUT_END     45.000000
+SIM_IMUT_FIXED   0.000000
+SIM_IMUT_START   25.000000
+SIM_IMUT_TCONST  300.000000
+SIM_IMU_COUNT    2
+SIM_IMU_ORIENT   0
+SIM_IMU_POS_X    0.000000
+SIM_IMU_POS_Y    0.000000
+SIM_IMU_POS_Z    0.000000
+SIM_INIT_ALT_OFS 0.000000
+SIM_INIT_LAT_OFS 0.000000
+SIM_INIT_LON_OFS 0.000000
+SIM_INS_THR_MIN  0.100000
+SIM_JSON_MASTER  0
+SIM_LED_LAYOUT   0
+SIM_LOOP_DELAY   0
+SIM_MAG1_DEVID   97539
+SIM_MAG1_DIA_X   0.000000
+SIM_MAG1_DIA_Y   0.000000
+SIM_MAG1_DIA_Z   0.000000
+SIM_MAG1_FAIL    0
+SIM_MAG1_ODI_X   0.000000
+SIM_MAG1_ODI_Y   0.000000
+SIM_MAG1_ODI_Z   0.000000
+SIM_MAG1_OFS_X   5.000000
+SIM_MAG1_OFS_Y   13.000000
+SIM_MAG1_OFS_Z   -18.000000
+SIM_MAG1_ORIENT  0
+SIM_MAG1_SCALING 1.000000
+SIM_MAG2_DEVID   131874
+SIM_MAG2_DIA_X   0.000000
+SIM_MAG2_DIA_Y   0.000000
+SIM_MAG2_DIA_Z   0.000000
+SIM_MAG2_FAIL    0
+SIM_MAG2_ODI_X   0.000000
+SIM_MAG2_ODI_Y   0.000000
+SIM_MAG2_ODI_Z   0.000000
+SIM_MAG2_OFS_X   5.000000
+SIM_MAG2_OFS_Y   13.000000
+SIM_MAG2_OFS_Z   -18.000000
+SIM_MAG2_ORIENT  0
+SIM_MAG2_SCALING 1.000000
+SIM_MAG3_DEVID   263178
+SIM_MAG3_DIA_X   0.000000
+SIM_MAG3_DIA_Y   0.000000
+SIM_MAG3_DIA_Z   0.000000
+SIM_MAG3_FAIL    0
+SIM_MAG3_ODI_X   0.000000
+SIM_MAG3_ODI_Y   0.000000
+SIM_MAG3_ODI_Z   0.000000
+SIM_MAG3_OFS_X   5.000000
+SIM_MAG3_OFS_Y   13.000000
+SIM_MAG3_OFS_Z   -18.000000
+SIM_MAG3_ORIENT  0
+SIM_MAG3_SCALING 1.000000
+SIM_MAG4_DEVID   97283
+SIM_MAG5_DEVID   97795
+SIM_MAG6_DEVID   98051
+SIM_MAG7_DEVID   0
+SIM_MAG8_DEVID   0
+SIM_MAG_ALY_HGT  1.000000
+SIM_MAG_ALY_X    0.000000
+SIM_MAG_ALY_Y    0.000000
+SIM_MAG_ALY_Z    0.000000
+SIM_MAG_DELAY    0
+SIM_MAG_MOT_X    0.000000
+SIM_MAG_MOT_Y    0.000000
+SIM_MAG_MOT_Z    0.000000
+SIM_MAG_RND      0.000000
+SIM_MAG_SAVE_IDS 1
+SIM_ODOM_ENABLE  0
+SIM_OH_MASK      0
+SIM_OH_RELAY_MSK -1
+SIM_OPOS_ALT     584.000000
+SIM_OPOS_HDG     353.000000
+SIM_OPOS_LAT     -35.363262
+SIM_OPOS_LNG     149.165237
+SIM_PARA_ENABLE  0
+SIM_PARA_PIN     -1
+SIM_PIN_MASK     0
+SIM_PLD_ALT_LMT  15.000000
+SIM_PLD_DIST_LMT 10.000000
+SIM_PLD_ENABLE   0
+SIM_PLD_HEIGHT   0.000000
+SIM_PLD_LAT      0.000000
+SIM_PLD_LON      0.000000
+SIM_PLD_OPTIONS  0
+SIM_PLD_ORIENT   24
+SIM_PLD_RATE     100
+SIM_PLD_SHIP     0
+SIM_PLD_TYPE     0
+SIM_PLD_YAW      0
+SIM_RATE_HZ      1200
+SIM_RC_CHANCOUNT 16
+SIM_RC_FAIL      0
+SIM_RICH_CTRL    -1
+SIM_RICH_ENABLE  0
+SIM_SERVO_DELAY  0.000000
+SIM_SERVO_FILTER 0.000000
+SIM_SERVO_SPEED  0.140000
+SIM_SHIP_DSIZE   10.000000
+SIM_SHIP_ENABLE  0
+SIM_SHIP_OFS_X   0.000000
+SIM_SHIP_OFS_Y   0.000000
+SIM_SHIP_OFS_Z   0.000000
+SIM_SHIP_PSIZE   1000.000000
+SIM_SHIP_SPEED   3.000000
+SIM_SHIP_SYSID   17
+SIM_SHOVE_TIME   0
+SIM_SHOVE_X      0.000000
+SIM_SHOVE_Y      0.000000
+SIM_SHOVE_Z      0.000000
+SIM_SLUP_ENABLE  0
+SIM_SONAR_GLITCH 0.000000
+SIM_SONAR_POS_X  0.000000
+SIM_SONAR_POS_Y  0.000000
+SIM_SONAR_POS_Z  0.000000
+SIM_SONAR_RND    0.000000
+SIM_SONAR_ROT    25
+SIM_SONAR_SCALE  12.121200
+SIM_SPEEDUP      1.000000
+SIM_SPR_ENABLE   0
+SIM_SPR_PUMP     -1
+SIM_SPR_SPIN     -1
+SIM_TA_ENABLE    1
+SIM_TEMP_BFACTOR 0.000000
+SIM_TEMP_BRD_OFF 20.000000
+SIM_TEMP_START   25.000000
+SIM_TEMP_TCONST  30.000000
+SIM_TERRAIN      1
+SIM_TETH_ENABLE  0
+SIM_THML_SCENARI 0
+SIM_TIDE_DIR     0.000000
+SIM_TIDE_SPEED   0.000000
+SIM_TIME_JITTER  0
+SIM_TWIST_TIME   0
+SIM_TWIST_X      0.000000
+SIM_TWIST_Y      0.000000
+SIM_TWIST_Z      0.000000
+SIM_UART_LOSS    0.000000
+SIM_VIB_FREQ_X   0.000000
+SIM_VIB_FREQ_Y   0.000000
+SIM_VIB_FREQ_Z   0.000000
+SIM_VIB_MOT_HMNC 1
+SIM_VIB_MOT_MASK 0
+SIM_VIB_MOT_MAX  0.000000
+SIM_VIB_MOT_MULT 1.000000
+SIM_VICON_FAIL   0
+SIM_VICON_GLIT_X 0.000000
+SIM_VICON_GLIT_Y 0.000000
+SIM_VICON_GLIT_Z 0.000000
+SIM_VICON_POS_X  0.000000
+SIM_VICON_POS_Y  0.000000
+SIM_VICON_POS_Z  0.000000
+SIM_VICON_P_SD   0.000000
+SIM_VICON_RATE   50
+SIM_VICON_TMASK  3
+SIM_VICON_VGLI_X 0.000000
+SIM_VICON_VGLI_Y 0.000000
+SIM_VICON_VGLI_Z 0.000000
+SIM_VICON_V_SD   0.000000
+SIM_VICON_YAW    0
+SIM_VICON_YAWERR 0
+SIM_VOLZ_ENA     0
+SIM_VOLZ_FMASK   0
+SIM_VOLZ_MASK    11
+SIM_WAVE_AMP     0.500000
+SIM_WAVE_DIR     0.000000
+SIM_WAVE_ENABLE  0
+SIM_WAVE_LENGTH  10.000000
+SIM_WAVE_SPEED   0.500000
+SIM_WIND_DIR     180.000000
+SIM_WIND_DIR_Z   0.000000
+SIM_WIND_SPD     0.000000
+SIM_WIND_T       0
+SIM_WIND_TC      5.000000
+SIM_WIND_TURB    0.000000
+SIM_WIND_T_ALT   60.000000
+SIM_WIND_T_COEF  0.010000
+SIM_WOW_PIN      -1
+SPRAY_ENABLE     0
+SRTL_ACCURACY    2.000000
+SRTL_OPTIONS     0
+SRTL_POINTS      300
+STAT_BOOTCNT     1
+STAT_FLTTIME     0
+STAT_RESET       1
+STAT_RUNTIME     0
+SUPER_SIMPLE     0
+SURFTRAK_MODE    1
+SURFTRAK_TC      1.000000
+TCAL_ENABLED     0
+TEMP1_TYPE       0
+TEMP2_TYPE       0
+TEMP3_TYPE       0
+TEMP_LOG         0
+TERRAIN_CACHE_SZ 12
+TERRAIN_ENABLE   1
+TERRAIN_MARGIN   0.050000
+TERRAIN_OFS_MAX  30.000000
+TERRAIN_OPTIONS  0
+TERRAIN_SPACING  100
+THROW_ALT_ACSND  3.000000
+THROW_ALT_DCSND  1.000000
+THROW_ALT_MAX    0
+THROW_ALT_MIN    0
+THROW_MOT_START  0
+THROW_NEXTMODE   18
+THROW_TYPE       0
+THR_DZ           100
+TKOFF_RPM_MAX    0
+TKOFF_RPM_MIN    0
+TKOFF_SLEW_TIME  2.000000
+TKOFF_THR_MAX    0.900000
+TUNE             0
+TUNE_MAX         0.000000
+TUNE_MIN         0.000000
+VISO_TYPE        0
+VTX_ENABLE       0
+WINCH_TYPE       0
+WPNAV_ACCEL      250.000000
+WPNAV_ACCEL_C    0.000000
+WPNAV_ACCEL_Z    100.000000
+WPNAV_JERK       1.000000
+WPNAV_RADIUS     200.000000
+WPNAV_RFND_USE   1
+WPNAV_SPEED      1000.000000
+WPNAV_SPEED_DN   150.000000
+WPNAV_SPEED_UP   250.000000
+WPNAV_TER_MARGIN 10.000000
+WP_NAVALT_MIN    0.000000
+WP_YAW_BEHAVIOR  2
+WVANE_ENABLE     0
+ZIGZ_AUTO_ENABLE 0

requirements.txt

@@ -1,11 +1,15 @@
-streamlit
 pandas
 numpy
 matplotlib
 seaborn
-smolagents
 python-dotenv
-transformers
-huggingface-hub
 dronekit
 pymavlink
+litellm
+ollama
+rich
+click
+pydantic
+pydantic-settings
+typer
+prompt-toolkit

setup.py

@@ -1,16 +1,38 @@
 from setuptools import setup, find_packages
 
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh.readlines() if line.strip() and not line.startswith("#")]
+
 setup(
     name="deepdrone",
-    version="0.1.0",
-    description="DeepDrone - AI-powered drone control and mission planning",
+    version="1.0.0",
+    description="DeepDrone - AI-powered drone control terminal application",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
     author="DeepDrone Team",
     packages=find_packages(),
-    install_requires=[
-        "dronekit",
-        "smolagents",
-        "streamlit",
-        "huggingface_hub",
-        "python-dotenv",
+    include_package_data=True,
+    install_requires=requirements,
+    entry_points={
+        "console_scripts": [
+            "deepdrone=main:main",
+        ],
+    },
+    python_requires=">=3.8",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: System :: Hardware :: Hardware Drivers",
     ],
 ) 

simulate_drone.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Drone SITL (Software In The Loop) Simulator
+Starts a virtual drone for testing DeepDrone commands.
+"""
+
+import subprocess
+import sys
+import time
+import socket
+import threading
+from pathlib import Path
+
+def check_mavproxy_installed():
+    """Check if MAVProxy is installed."""
+    try:
+        result = subprocess.run(['mavproxy.py', '--help'], 
+                              capture_output=True, text=True, timeout=5)
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+def check_ardupilot_installed():
+    """Check if ArduPilot SITL is available."""
+    try:
+        result = subprocess.run(['sim_vehicle.py', '--help'], 
+                              capture_output=True, text=True, timeout=5)
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return False
+
+def find_available_port(start_port=14550):
+    """Find an available UDP port starting from start_port."""
+    for port in range(start_port, start_port + 100):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+                s.bind(('127.0.0.1', port))
+                return port
+        except OSError:
+            continue
+    return None
+
+def start_simple_sitl(port=14550):
+    """Start a simple SITL simulation using ArduPilot."""
+    print(f"🚁 Starting ArduPilot SITL on port {port}...")
+    
+    try:
+        # Try to start ArduPilot SITL
+        cmd = [
+            'sim_vehicle.py',
+            '-v', 'ArduCopter',
+            '--out', f'udp:127.0.0.1:{port}',
+            '--map',
+            '--console'
+        ]
+        
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        return process, port
+        
+    except FileNotFoundError:
+        print("❌ ArduPilot SITL not found. Please install ArduPilot.")
+        return None, None
+
+def start_mavproxy_sitl(port=14550):
+    """Start SITL using MAVProxy."""
+    print(f"🚁 Starting MAVProxy SITL on port {port}...")
+    
+    try:
+        cmd = [
+            'mavproxy.py',
+            '--master', 'tcp:127.0.0.1:5760',
+            '--out', f'udp:127.0.0.1:{port}',
+            '--aircraft', 'test'
+        ]
+        
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        return process, port
+        
+    except FileNotFoundError:
+        print("❌ MAVProxy not found.")
+        return None, None
+
+def create_basic_simulator(port=14550):
+    """Create a very basic drone simulator for testing."""
+    print(f"🚁 Starting basic drone simulator on port {port}...")
+    print("⚠️  This is a minimal simulator for testing purposes only.")
+    
+    # Create a simple UDP server that responds to basic MAVLink messages
+    import socket
+    import struct
+    
+    def simulator_thread():
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.bind(('127.0.0.1', port))
+        sock.settimeout(1.0)
+        
+        print(f"✅ Basic simulator listening on 127.0.0.1:{port}")
+        
+        while True:
+            try:
+                data, addr = sock.recvfrom(1024)
+                # Echo back a simple response
+                sock.sendto(data, addr)
+            except socket.timeout:
+                continue
+            except KeyboardInterrupt:
+                break
+        
+        sock.close()
+    
+    thread = threading.Thread(target=simulator_thread, daemon=True)
+    thread.start()
+    
+    return thread, port
+
+def print_connection_info(port):
+    """Print connection information."""
+    connection_string = f"udp:127.0.0.1:{port}"
+    
+    print("\n" + "="*60)
+    print("🚁 DRONE SIMULATOR STARTED")
+    print("="*60)
+    print(f"📡 Connection String: {connection_string}")
+    print(f"🌐 IP Address: 127.0.0.1")
+    print(f"🔌 Port: {port}")
+    print("="*60)
+    print("\n💡 To connect DeepDrone:")
+    print(f"   1. Run: python main.py")
+    print(f"   2. Choose your AI provider")
+    print(f"   3. In chat, say: 'Connect to {connection_string}'")
+    print("\n🎯 Example commands once connected:")
+    print("   • 'Take off to 30 meters'")
+    print("   • 'Fly in a square pattern'")
+    print("   • 'Show battery status'")
+    print("   • 'Return home and land'")
+    print("\n⚠️  Press Ctrl+C to stop the simulator")
+    print("="*60)
+
+def main():
+    """Main function to start the drone simulator."""
+    print("🚁 DeepDrone Simulator Starting...")
+    print("Checking for available drone simulation software...\n")
+    
+    # Find available port
+    port = find_available_port()
+    if not port:
+        print("❌ No available ports found. Please check your network configuration.")
+        return
+    
+    simulator_process = None
+    simulator_thread = None
+    
+    try:
+        # Try ArduPilot SITL first
+        if check_ardupilot_installed():
+            print("✅ ArduPilot SITL found. Starting professional simulation...")
+            simulator_process, port = start_simple_sitl(port)
+            
+            if simulator_process:
+                print_connection_info(port)
+                simulator_process.wait()
+            
+        elif check_mavproxy_installed():
+            print("✅ MAVProxy found. Starting MAVProxy simulation...")
+            simulator_process, port = start_mavproxy_sitl(port)
+            
+            if simulator_process:
+                print_connection_info(port)
+                simulator_process.wait()
+        
+        else:
+            print("⚠️  No professional drone simulation software found.")
+            print("Installing ArduPilot SITL is recommended for full simulation.")
+            print("Falling back to basic simulator for testing...")
+            
+            simulator_thread, port = create_basic_simulator(port)
+            print_connection_info(port)
+            
+            # Keep the basic simulator running
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                pass
+    
+    except KeyboardInterrupt:
+        print("\n🛑 Stopping drone simulator...")
+    
+    finally:
+        if simulator_process:
+            simulator_process.terminate()
+            try:
+                simulator_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                simulator_process.kill()
+        
+        print("✅ Drone simulator stopped.")
+
+def install_instructions():
+    """Print installation instructions for drone simulation software."""
+    print("\n📋 To install professional drone simulation:")
+    print("\n🔧 ArduPilot SITL (Recommended):")
+    print("   git clone https://github.com/ArduPilot/ardupilot.git")
+    print("   cd ardupilot")
+    print("   git submodule update --init --recursive")
+    print("   ./Tools/environment_install/install-prereqs-ubuntu.sh -y")
+    print("   . ~/.profile")
+    print("   ./waf configure --board sitl")
+    print("   ./waf copter")
+    print("   echo 'export PATH=$PATH:$HOME/ardupilot/Tools/autotest' >> ~/.bashrc")
+    print("   source ~/.bashrc")
+    
+    print("\n🔧 MAVProxy (Alternative):")
+    print("   pip install MAVProxy")
+    
+    print("\n💡 For now, you can use the basic simulator for testing.")
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--install-help":
+        install_instructions()
+    else:
+        main()

test_ollama_features.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Test script to demonstrate the improved Ollama features.
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+def demo_ollama_features():
+    """Demo the new Ollama features."""
+    
+    console.print(Panel(
+        "[bold green]🚀 Enhanced Ollama Integration Demo[/bold green]\n\n"
+        "[dim]This shows the improved Ollama handling in DeepDrone[/dim]",
+        border_style="bright_green",
+        padding=(1, 2)
+    ))
+    
+    console.print("\n[bold cyan]✨ New Ollama Features:[/bold cyan]\n")
+    
+    features = [
+        "🔍 **Auto-Detection**: Automatically finds your local Ollama models",
+        "📥 **Smart Installation**: Offers to install missing models automatically", 
+        "🎯 **Popular Suggestions**: Shows recommended models if none are installed",
+        "⚡ **No API Key**: Skips API key entry for local models",
+        "🔧 **Connection Help**: Clear instructions if Ollama isn't running",
+        "📊 **Status Command**: Use '/ollama' in chat to check model status"
+    ]
+    
+    for feature in features:
+        console.print(f"  {feature}")
+    
+    console.print("\n[bold yellow]🎯 Ollama Workflow:[/bold yellow]\n")
+    
+    workflow = [
+        "[bold]1. Select Provider:[/bold] Choose 'Ollama' from the provider list",
+        "[bold]2. Model Detection:[/bold] Shows your local models automatically",
+        "[bold]3. Install Missing:[/bold] Offers to download models you don't have",
+        "[bold]4. No API Key:[/bold] Automatically skips API key entry",
+        "[bold]5. Connection Test:[/bold] Verifies Ollama is working",
+        "[bold]6. Chat Ready:[/bold] Start controlling drones with local AI!"
+    ]
+    
+    for step in workflow:
+        console.print(f"  {step}")
+    
+    console.print("\n[bold green]💡 Example Experience:[/bold green]\n")
+    
+    example = """[cyan]Provider Selection:[/cyan] 6. Ollama
+[cyan]Model Detection:[/cyan] ✅ Found: llama3.1:latest, codestral:latest
+[cyan]User Choice:[/cyan] "phi3" (not installed locally)
+[cyan]Smart Install:[/cyan] "Would you like to install phi3? [Y/n]"
+[cyan]Download:[/cyan] 📥 Installing phi3... ✅ Success!
+[cyan]API Key:[/cyan] ⏭️  Skipped (local model)
+[cyan]Test:[/cyan] ✅ Connection successful!
+[cyan]Chat Ready:[/cyan] 🚁 DeepDrone ready with local AI!"""
+    
+    console.print(Panel(
+        example,
+        title="[bold]Ollama Setup Flow[/bold]",
+        border_style="blue"
+    ))
+    
+    console.print("\n[bold magenta]🔧 Chat Commands:[/bold magenta]\n")
+    
+    commands = [
+        "[cyan]/ollama[/cyan] - Show Ollama status and available models",
+        "[cyan]/status[/cyan] - General system status including AI model",
+        "[cyan]/help[/cyan] - All available commands"
+    ]
+    
+    for cmd in commands:
+        console.print(f"  {cmd}")
+    
+    console.print("\n[bold red]⚠️  Troubleshooting:[/bold red]\n")
+    
+    issues = [
+        "[bold]No models found:[/bold] Run 'ollama pull llama3.1'",
+        "[bold]Connection refused:[/bold] Run 'ollama serve' in terminal",
+        "[bold]Model not found:[/bold] DeepDrone will offer to install it",
+        "[bold]Ollama not installed:[/bold] Download from https://ollama.com"
+    ]
+    
+    for issue in issues:
+        console.print(f"  • {issue}")
+    
+    console.print(f"\n[bold green]🎉 Ready to use local AI for drone control![/bold green]")
+
+if __name__ == "__main__":
+    demo_ollama_features()

tests/__init__.py

@@ -1,8 +0,0 @@
-"""
-Test modules for the DeepDrone project.
-
-This package contains test scripts to verify the functionality of:
-- Drone connection
-- Mission planning and execution
-- Agent interactions
-""" 

tests/test_agent_mission.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test the ability of the DroneAssistant to plan and execute missions
-based on natural language requests.
-
-This script simulates a user asking the agent to create a mission plan and execute it.
-"""
-
-import os
-import time
-import json
-import sys
-from drone.drone_chat import DroneAssistant, generate_mission_plan
-from drone.drone_control import connect_drone, disconnect_drone
-from drone.hf_model import HfApiModel, Message
-from drone import compatibility_fix  # Import for Python 3.10+ compatibility
-
-# Import the simplified model that works with smolagents
-from tests.test_simple_agent import SimplePlaceholderModel, final_answer
-
-# Test cases - different natural language requests for missions
-TEST_CASES = [
-    "Create a mission plan for a survey mission that takes 20 minutes and execute it on the simulator.",
-    "I need to inspect a building. Can you make a plan for a 15-minute inspection mission and fly it?",
-    "Plan a delivery mission to these coordinates and execute it: 37.7749, -122.4194. It should take about 10 minutes.",
-    "Plan and execute a simple square pattern flight around my current position.",
-]
-
-def setup_drone_agent():
-    """Create and initialize a DroneAssistant for testing."""
-    print("Setting up drone agent...")
-    
-    # Check if HF_TOKEN is set in environment variables
-    hf_token = os.environ.get("HF_TOKEN", "")
-    if not hf_token:
-        print("WARNING: No Hugging Face API token found. Using a placeholder model.")
-        # Use our simplified placeholder model instead of the previous complex one
-        model = SimplePlaceholderModel()
-    else:
-        # Use the real model if API token is available
-        model = HfApiModel(
-            max_tokens=2096,
-            temperature=0.7,
-            model_id='Qwen/Qwen2.5-Coder-32B-Instruct'
-        )
-    
-    # Create the drone assistant with the required tools
-    drone_agent = DroneAssistant(
-        tools=[generate_mission_plan],
-        model=model
-    )
-    
-    return drone_agent
-
-def execute_mission_from_plan(mission_plan):
-    """Execute a mission based on the provided plan using DroneKit."""
-    print("\nExecuting mission from plan...")
-    
-    # Parse the mission plan
-    try:
-        if isinstance(mission_plan, str):
-            plan = eval(mission_plan)  # Convert string representation to dict
-        else:
-            plan = mission_plan
-            
-        print(f"Mission type: {plan.get('mission_type')}")
-        print(f"Duration: {plan.get('duration_minutes')} minutes")
-        print(f"Flight pattern: {plan.get('flight_pattern')}")
-        print(f"Recommended altitude: {plan.get('recommended_altitude')}")
-        
-        # Connect to the simulator
-        print("\nConnecting to simulator...")
-        connected = connect_drone('udp:127.0.0.1:14550')
-        
-        if not connected:
-            print("Failed to connect to the simulator. Make sure it's running.")
-            return False
-        
-        print("Connected to simulator!")
-        print("Simulating mission execution...")
-        
-        # Here we would normally execute the actual mission
-        # For testing purposes, we'll just simulate the execution
-        for i in range(5):
-            print(f"Mission progress: {i*20}%")
-            time.sleep(1)
-            
-        print("Mission completed successfully!")
-        disconnect_drone()
-        return True
-    
-    except Exception as e:
-        print(f"Error executing mission: {str(e)}")
-        return False
-
-def run_test_case(drone_agent, test_case):
-    """Run a single test case with the drone agent."""
-    print(f"\n----- TESTING CASE: '{test_case}' -----")
-    
-    # Simulate a user asking the agent
-    print(f"\nUSER: {test_case}")
-    
-    # Get the agent's response
-    response = drone_agent.chat(test_case)
-    print(f"\nAGENT: {response}")
-    
-    # Check if the response contains or implies a mission plan
-    mission_keywords = ["mission plan", "flight plan", "waypoints", "coordinates"]
-    has_mission_plan = any(keyword in response.lower() for keyword in mission_keywords)
-    
-    if not has_mission_plan:
-        print("FAIL: Agent did not create a mission plan.")
-        return False
-    
-    # Extract the mission plan and execute it
-    # For a real implementation, we would need to parse the response more carefully
-    # Here we'll just call the generate_mission_plan function directly
-    
-    if "survey" in test_case.lower():
-        mission_type = "survey"
-    elif "inspect" in test_case.lower():
-        mission_type = "inspection"
-    elif "delivery" in test_case.lower():
-        mission_type = "delivery"
-    else:
-        mission_type = "custom"
-    
-    if "minute" in test_case.lower():
-        # Try to extract the duration
-        import re
-        duration_match = re.search(r'(\d+)\s*minute', test_case)
-        duration = int(duration_match.group(1)) if duration_match else 15
-    else:
-        duration = 15
-    
-    print(f"\nGenerating mission plan for {mission_type} mission with duration {duration} minutes...")
-    mission_plan = generate_mission_plan(mission_type=mission_type, duration_minutes=duration)
-    print(f"\nGenerated plan: {mission_plan}")
-    
-    # Execute the mission plan
-    result = execute_mission_from_plan(mission_plan)
-    
-    if result:
-        print("PASS: Successfully executed the mission plan.")
-        return True
-    else:
-        print("FAIL: Could not execute the mission plan.")
-        return False
-
-def run_all_tests():
-    """Run all test cases and report results."""
-    drone_agent = setup_drone_agent()
-    
-    results = []
-    for test_case in TEST_CASES:
-        result = run_test_case(drone_agent, test_case)
-        results.append(result)
-    
-    # Print summary
-    print("\n----- TEST SUMMARY -----")
-    for i, (test, result) in enumerate(zip(TEST_CASES, results)):
-        status = "PASS" if result else "FAIL"
-        print(f"Test {i+1}: {status} - '{test[:40]}...'")
-    
-    success_rate = sum(results) / len(results) * 100
-    print(f"\nOverall Success Rate: {success_rate:.1f}%")
-    
-    return all(results)
-
-if __name__ == "__main__":
-    print("Testing DroneAssistant's ability to plan and execute missions...")
-    success = run_all_tests()
-    
-    if success:
-        print("\nAll tests passed! The agent can successfully plan and execute missions.")
-        exit(0)
-    else:
-        print("\nSome tests failed. The agent needs improvement.")
-        exit(1) 

tests/test_connection.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""
-Basic connection test for DroneKit to ArduPilot SITL
-"""
-
-import time
-import sys
-from dronekit import connect, APIException
-
-# Connect to the Vehicle using a different port to avoid conflicts
-print("Connecting to vehicle on udp:127.0.0.1:14550...")
-try:
-    vehicle = connect('udp:127.0.0.1:14550', wait_ready=True, timeout=60)
-except APIException as e:
-    print(f"Connection failed: {e}")
-    sys.exit(1)
-except Exception as e:
-    print(f"Error: {e}")
-    sys.exit(1)
-
-# Get some vehicle attributes (state)
-print("Connection successful!")
-print("Get some vehicle attribute values:")
-print(f" GPS: {vehicle.gps_0}")
-print(f" Battery: {vehicle.battery}")
-print(f" Last Heartbeat: {vehicle.last_heartbeat}")
-print(f" Is Armable?: {vehicle.is_armable}")
-print(f" System status: {vehicle.system_status.state}")
-print(f" Mode: {vehicle.mode.name}")
-
-# Close vehicle object
-vehicle.close()
-print("Test complete.") 

tests/test_mission.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-"""
-DroneKit-Python Mission Test Script
-
-This script demonstrates how to connect to the ArduPilot SITL simulator,
-create a simple mission (square pattern), and execute it.
-"""
-
-import time
-import math
-import sys
-import argparse
-from drone import compatibility_fix  # Import the compatibility fix for Python 3.10+
-from drone.drone_control import DroneController
-from dronekit import connect, VehicleMode, LocationGlobalRelative
-
-def get_args():
-    """Parse command line arguments."""
-    parser = argparse.ArgumentParser(description='Test mission script for DeepDrone')
-    parser.add_argument('--connect', 
-                        help="Vehicle connection target string. If not specified, SITL automatically started.",
-                        default='udp:127.0.0.1:14550')
-    return parser.parse_args()
-
-def main():
-    # Parse connection string
-    args = get_args()
-    connection_string = args.connect
-    
-    print(f"Connecting to vehicle on: {connection_string}")
-    
-    try:
-        # Connect to the Vehicle
-        print("Connecting to vehicle on %s" % connection_string)
-        vehicle = connect(connection_string, wait_ready=True, timeout=60)
-        
-        # Get some vehicle attributes (state)
-        print("Get some vehicle attribute values:")
-        print(" GPS: %s" % vehicle.gps_0)
-        print(" Battery: %s" % vehicle.battery)
-        print(" Last Heartbeat: %s" % vehicle.last_heartbeat)
-        print(" Is Armable?: %s" % vehicle.is_armable)
-        print(" System status: %s" % vehicle.system_status.state)
-        print(" Mode: %s" % vehicle.mode.name)
-        
-        # Define the home position (current position where script is run)
-        home_position = vehicle.location.global_relative_frame
-        print("Home position: %s" % home_position)
-        
-        # Define a square mission
-        offset = 0.0001  # Approximately 11 meters at the equator
-        
-        # Create a mission with a square pattern
-        print("Creating mission waypoints...")
-        waypoints = [
-            # North
-            LocationGlobalRelative(home_position.lat + offset, home_position.lon, 20),
-            # Northeast
-            LocationGlobalRelative(home_position.lat + offset, home_position.lon + offset, 20),
-            # East
-            LocationGlobalRelative(home_position.lat, home_position.lon + offset, 20),
-            # Return to Launch
-            LocationGlobalRelative(home_position.lat, home_position.lon, 20),
-        ]
-        
-        # Arm the vehicle
-        print("Arming motors")
-        vehicle.mode = VehicleMode("GUIDED")
-        vehicle.armed = True
-        
-        # Wait until armed
-        while not vehicle.armed:
-            print("Waiting for arming...")
-            time.sleep(1)
-        
-        print("Taking off to 20 meters")
-        vehicle.simple_takeoff(20)  # Take off to 20m
-        
-        # Wait until the vehicle reaches a safe height
-        while True:
-            print("Altitude: %s" % vehicle.location.global_relative_frame.alt)
-            # Break and return when we reach target altitude or close to it
-            if vehicle.location.global_relative_frame.alt >= 19:
-                print("Reached target altitude")
-                break
-            time.sleep(1)
-        
-        # Fly through the waypoints
-        for i, waypoint in enumerate(waypoints):
-            print(f"Flying to waypoint {i+1}")
-            vehicle.simple_goto(waypoint)
-            
-            # Start timer for waypoint timeout
-            start_time = time.time()
-            
-            # Wait until we reach the waypoint
-            while True:
-                # Calculate distance to waypoint
-                current = vehicle.location.global_relative_frame
-                distance_to_waypoint = math.sqrt(
-                    (waypoint.lat - current.lat)**2 + 
-                    (waypoint.lon - current.lon)**2) * 1.113195e5
-                
-                print(f"Distance to waypoint: {distance_to_waypoint:.2f} meters")
-                
-                # Break if we're within 3 meters of the waypoint
-                if distance_to_waypoint < 3:
-                    print(f"Reached waypoint {i+1}")
-                    break
-                
-                # Break if we've been flying to this waypoint for more than 60 seconds
-                if time.time() - start_time > 60:
-                    print(f"Timed out reaching waypoint {i+1}, continuing to next waypoint")
-                    break
-                
-                time.sleep(2)
-        
-        # Return to home
-        print("Returning to home")
-        vehicle.mode = VehicleMode("RTL")
-        
-        # Wait for the vehicle to land
-        while vehicle.armed:
-            print("Waiting for landing and disarm...")
-            time.sleep(2)
-        
-        print("Mission complete!")
-        
-        # Close vehicle object
-        vehicle.close()
-        
-    except Exception as e:
-        print(f"Error: {str(e)}")
-
-if __name__ == "__main__":
-    main() 

tests/test_mission_planning.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simplified test script for mission planning and execution.
-This script tests the mission planning and execution functionality directly,
-without using the DroneAssistant or smolagents.
-"""
-
-import time
-import math
-import sys
-import json
-from drone.drone_chat import generate_mission_plan
-from drone.drone_control import connect_drone, disconnect_drone, takeoff, land, return_home
-from drone import compatibility_fix  # Import for Python 3.10+ compatibility
-
-def test_mission_planning():
-    """Test the mission planning functionality."""
-    print("\n----- TESTING MISSION PLANNING -----")
-    
-    # Test different mission types
-    mission_types = ["survey", "inspection", "delivery", "custom"]
-    durations = [10, 15, 20, 5]
-    
-    for mission_type, duration in zip(mission_types, durations):
-        print(f"\nGenerating {mission_type} mission plan for {duration} minutes...")
-        
-        mission_plan = generate_mission_plan(mission_type=mission_type, duration_minutes=duration)
-        
-        # Parse the mission plan
-        if isinstance(mission_plan, str):
-            try:
-                plan = eval(mission_plan)  # Convert string representation to dict
-                print("Successfully parsed mission plan:")
-                print(f"  Mission type: {plan.get('mission_type')}")
-                print(f"  Duration: {plan.get('duration_minutes')} minutes")
-                print(f"  Flight pattern: {plan.get('flight_pattern')}")
-                print(f"  Recommended altitude: {plan.get('recommended_altitude')} meters")
-                print(f"  Waypoint count: {len(plan.get('waypoints', []))}")
-                print("  Mission description:", plan.get('description', '')[:50] + "...")
-            except Exception as e:
-                print(f"Error parsing mission plan: {str(e)}")
-                print("Raw mission plan:", mission_plan)
-        else:
-            print("Mission plan is not a string:", type(mission_plan))
-            print(mission_plan)
-    
-    print("\nMission planning test completed.")
-    return True
-
-def test_mission_execution(mission_type="survey", duration=10):
-    """Test the mission execution functionality using the simulator."""
-    print("\n----- TESTING MISSION EXECUTION -----")
-    
-    # Generate a mission plan
-    print(f"Generating {mission_type} mission plan for {duration} minutes...")
-    mission_plan = generate_mission_plan(mission_type=mission_type, duration_minutes=duration)
-    
-    # Parse the mission plan
-    try:
-        if isinstance(mission_plan, str):
-            plan = eval(mission_plan)  # Convert string representation to dict
-        else:
-            plan = mission_plan
-        
-        print("Mission plan details:")
-        print(f"  Mission type: {plan.get('mission_type')}")
-        print(f"  Duration: {plan.get('duration_minutes')} minutes")
-        print(f"  Flight pattern: {plan.get('flight_pattern')}")
-        print(f"  Recommended altitude: {plan.get('recommended_altitude')} meters")
-        print(f"  Waypoint count: {len(plan.get('waypoints', []))}")
-        
-        # Connect to the simulator
-        print("\nConnecting to simulator...")
-        success = connect_drone('udp:127.0.0.1:14550')
-        
-        if not success:
-            print("Failed to connect to the simulator. Make sure it's running.")
-            return False
-        
-        print("Connected to simulator!")
-        
-        # Execute the mission
-        # For the test, we'll just print the waypoints instead of actually flying
-        print("\nSimulating mission execution...")
-        print(f"Taking off to {plan.get('recommended_altitude')} meters...")
-        time.sleep(2)
-        
-        print("Flying mission waypoints:")
-        waypoints = plan.get('waypoints', [])
-        for i, waypoint in enumerate(waypoints):
-            print(f"  Waypoint {i+1}: {waypoint}")
-            time.sleep(1)
-        
-        print("Returning to home...")
-        time.sleep(2)
-        
-        print("Landing...")
-        time.sleep(2)
-        
-        print("Mission completed successfully!")
-        disconnect_drone()
-        return True
-        
-    except Exception as e:
-        print(f"Error executing mission: {str(e)}")
-        return False
-
-def main():
-    """Run all tests."""
-    print("Testing mission planning and execution...")
-    
-    # Test mission planning
-    planning_success = test_mission_planning()
-    
-    # Test mission execution
-    execution_success = test_mission_execution("survey", 10)
-    
-    # Print test summary
-    print("\n----- TEST SUMMARY -----")
-    print(f"Mission Planning Test: {'PASS' if planning_success else 'FAIL'}")
-    print(f"Mission Execution Test: {'PASS' if execution_success else 'FAIL'}")
-    
-    if planning_success and execution_success:
-        print("\nAll tests passed! The mission planning and execution are working properly.")
-        return 0
-    else:
-        print("\nSome tests failed. Check the output above for details.")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main()) 

tests/test_prompt_examples.md

@@ -1,120 +0,0 @@
-# DeepDrone Test Prompts
-
-This document contains example prompts that can be used to test the DeepDrone agent's ability to understand natural language mission requests, plan missions, and execute them.
-
-## Running the Tests
-
-1. Start the ArduPilot SITL simulator:
-   ```bash
-   cd ~/ardupilot && ./Tools/autotest/sim_vehicle.py -v ArduCopter --console --map
-   ```
-
-2. In a new terminal, run the DeepDrone application:
-   ```bash
-   cd ~/deepdrone && streamlit run main.py
-   ```
-
-3. Use one of the example prompts below in the chat interface to test the agent's capabilities.
-
-## Example Prompts for Testing
-
-### Basic Mission Planning
-
-#### Example 1: Square Pattern Mission
-```
-Plan and execute a simple square pattern flight around my current position with sides of 50 meters at an altitude of 20 meters.
-```
-
-Expected behavior:
-- Agent should generate a square-shaped mission plan
-- Mission should include 4 waypoints forming a square
-- Altitude should be set to 20 meters
-- Agent will connect to the simulator and execute the mission
-
-#### Example 2: Survey Mission
-```
-I need to create a survey mission for a 100x100 meter area. It should take about 15 minutes and cover the area systematically with a camera.
-```
-
-Expected behavior:
-- Agent should generate a survey mission plan with grid pattern
-- Mission plan should specify recommended altitude for survey (40-60 meters)
-- Plan should include information about camera settings and overlap
-- Agent will offer to execute the mission on the simulator
-
-#### Example 3: Inspection Mission
-```
-Create an inspection mission for a tower structure. The mission should orbit around a central point at varying distances and capture detailed images.
-```
-
-Expected behavior:
-- Agent should generate an inspection mission plan with orbital pattern
-- Mission should recommend lower altitude (5-20 meters)
-- Plan should include waypoints at different heights and distances
-- Agent will offer to execute the mission on the simulator
-
-### Specific Execution Instructions
-
-#### Example 4: Delivery Mission with Specific Coordinates
-```
-Plan a delivery mission to these coordinates: 37.7749, -122.4194. Make sure to maintain at least 30 meters altitude en route and avoid populated areas.
-```
-
-Expected behavior:
-- Agent should generate a delivery mission plan with the specified coordinates
-- Mission should set 30+ meters as the flight altitude
-- Plan should mention safety considerations
-- Agent will offer to execute the mission on the simulator
-
-#### Example 5: Custom Mission with Multiple Waypoints
-```
-I need a custom mission with the following waypoints:
-1. Take off to 15 meters
-2. Fly to 50 meters north of home position
-3. Then 50 meters east
-4. Then 50 meters south
-5. Return to home and land
-```
-
-Expected behavior:
-- Agent should generate a custom mission plan with the specified waypoints
-- Plan should include exact coordinates for each waypoint
-- Agent will offer to execute the mission on the simulator
-
-## Troubleshooting
-
-If the agent doesn't respond correctly to any of these prompts, check the following:
-
-1. Make sure the SITL simulator is running properly
-2. Verify that you have set the HF_TOKEN environment variable for the Hugging Face API
-3. Check that the DroneKit connection to the simulator is working
-4. Look for any error messages in the terminal
-
-## Expected Response Format
-
-A typical response from the agent should include:
-
-1. Acknowledgment of the mission request
-2. A detailed mission plan including:
-   - Mission type
-   - Duration
-   - Flight pattern
-   - Altitude recommendations
-   - Waypoint information
-3. Options to execute the mission or modify the plan
-
-Example:
-```
-I'll create a survey mission plan for your 100x100 meter area.
-
-Mission Plan:
-- Type: Survey
-- Duration: 15 minutes
-- Flight pattern: Grid with 70% overlap
-- Recommended altitude: 50 meters
-- Camera settings: 4K resolution, 1 shot every 2 seconds
-
-The plan includes 12 waypoints in a grid pattern to ensure complete coverage of the area.
-
-Would you like me to execute this mission on the simulator?
-``` 

tests/test_simple_agent.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simplified test for the DroneAssistant with proper smolagents format support
-"""
-
-import os
-import sys
-from drone.drone_chat import DroneAssistant, generate_mission_plan
-from drone.hf_model import Message
-
-def final_answer(answer):
-    """Final answer function for smolagents"""
-    print(f"FINAL ANSWER: {answer}")
-    return answer
-
-class SimplePlaceholderModel:
-    """A very simple placeholder model that always returns a properly formatted response"""
-    
-    def __call__(self, messages):
-        """Called when used as a function"""
-        return self.generate(messages)
-    
-    def generate(self, messages, **kwargs):
-        """Generate a response with proper smolagents formatting"""
-        mission_type = "survey"
-        duration = 15
-        
-        # Format the response in the way smolagents expects with proper code formatting
-        response = f"""Thought: I will create a {mission_type} mission plan for {duration} minutes and execute it on the simulator.
-Code:
-```py
-mission_plan = generate_mission_plan(mission_type="{mission_type}", duration_minutes={duration})
-print(f"Generated mission plan: {{mission_plan}}")
-final_answer(f"I've created a {mission_type} mission plan that will take approximately {duration} minutes to execute. The plan includes waypoints for a square pattern around your current position.")
-```<end_code>"""
-        
-        return Message(response)
-
-def test_simple_agent():
-    """Test the drone assistant with a simple model"""
-    print("\n=== Testing Simple Agent ===")
-    
-    # Create placeholder model
-    model = SimplePlaceholderModel()
-    
-    # Create drone assistant
-    assistant = DroneAssistant(
-        tools=[generate_mission_plan],
-        model=model
-    )
-    
-    # Test a simple mission planning request
-    user_message = "Plan a simple square pattern mission around my current position."
-    
-    print(f"\nUser: {user_message}")
-    
-    try:
-        response = assistant.chat(user_message)
-        print(f"\nAgent response: {response}")
-        return True
-    except Exception as e:
-        print(f"\nError: {str(e)}")
-        print(f"Error type: {type(e)}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    success = test_simple_agent()
-    if success:
-        print("\nTest passed!")
-        sys.exit(0)
-    else:
-        print("\nTest failed!")
-        sys.exit(1)