h2ogpte 1.6.42__py3-none-any.whl → 1.6.43__py3-none-any.whl

h2ogpte/__init__.py

@@ -3,7 +3,7 @@ from h2ogpte.h2ogpte import H2OGPTE
 from h2ogpte.h2ogpte_async import H2OGPTEAsync
 from h2ogpte.session_async import SessionAsync
 
-__version__ = "1.6.42"
+__version__ = "1.6.43"
 
 __all__ = [
     "H2OGPTE",

h2ogpte/cli/commands/command_handlers/agent.py

@@ -0,0 +1,41 @@
+from ...core.app import get_app_state
+
+
+async def handle_agent(args: str) -> bool:
+    app = get_app_state()
+
+    if not args or not args.strip():
+        app.ui.show_error("Please provide a message")
+        app.ui.show_info("Example: /agent Help me analyze this code")
+        return True
+
+    message = args.strip()
+
+    if app.rag_manager.connected:
+        usage_stats = await app.rag_manager.send_message(message, use_agent=True)
+
+        if usage_stats:
+            total_input_tokens = sum(
+                u.get("input_tokens", 0) for u in usage_stats.get("usage", [])
+            )
+            total_output_tokens = sum(
+                u.get("output_tokens", 0) for u in usage_stats.get("usage", [])
+            )
+            response_time = usage_stats.get("response_time", "N/A")
+            queued_for = usage_stats.get("queue_time", "N/A")
+            llm = usage_stats.get("llm", "N/A")
+            app.ui.show_info(
+                f"[Agent] Tokens: {total_input_tokens} (in), {total_output_tokens} (out), "
+                f"Response time: {response_time}, "
+                f"Queued for: {queued_for}, "
+                f"LLM: {llm}"
+            )
+
+        await app.update_status_bar()
+    else:
+        app.ui.show_error("Not connected to H2OGPTE. Use /register to connect first.")
+        app.ui.show_info(
+            "Example: /register https://your-h2ogpte-endpoint.com your-api-key"
+        )
+
+    return True

h2ogpte/cli/commands/command_handlers/chat.py

@@ -0,0 +1,37 @@
+from ...core.app import get_app_state
+
+
+async def handle_chat(message: str) -> bool:
+    app = get_app_state()
+
+    if not message or not message.strip():
+        return True
+
+    if app.rag_manager.connected:
+        usage_stats = await app.rag_manager.send_message(message)
+
+        if usage_stats:
+            total_input_tokens = sum(
+                u.get("input_tokens", 0) for u in usage_stats.get("usage", [])
+            )
+            total_output_tokens = sum(
+                u.get("output_tokens", 0) for u in usage_stats.get("usage", [])
+            )
+            response_time = usage_stats.get("response_time", "N/A")
+            queued_for = usage_stats.get("queue_time", "N/A")
+            llm = usage_stats.get("llm", "N/A")
+            app.ui.show_info(
+                f"Tokens: {total_input_tokens} (in), {total_output_tokens} (out), "
+                f"Response time: {response_time}, "
+                f"Queued for: {queued_for}, "
+                f"LLM: {llm}"
+            )
+
+        await app.update_status_bar()
+    else:
+        app.ui.show_error("Not connected to H2OGPTE. Use /register to connect first.")
+        app.ui.show_info(
+            "Example: /register https://your-h2ogpte-endpoint.com your-api-key"
+        )
+
+    return True

h2ogpte/cli/commands/command_handlers/clear.py

@@ -0,0 +1,8 @@
+from ...core.app import get_app_state
+
+
+async def handle_clear(args: str) -> bool:
+    """Clear screen."""
+    app = get_app_state()
+    app.ui.clear_screen()
+    return True

h2ogpte/cli/commands/command_handlers/collection.py

@@ -0,0 +1,67 @@
+from ...core.app import get_app_state
+
+
+async def handle_create_collection(args: str) -> bool:
+    """Create a new collection and switch to it."""
+    app = get_app_state()
+
+    if not app.rag_manager.connected:
+        app.ui.show_error("Not connected to H2OGPTE. Use /register first.")
+        return True
+
+    if not args:
+        collection_name = app.ui.prompt.get_input_with_default(
+            "Enter collection name", "CLI-Collection"
+        )
+    else:
+        collection_name = args.strip()
+
+    if collection_name:
+        app.ui.show_info(f"Creating and switching to collection '{collection_name}'...")
+        success = await app.rag_manager.switch_to_collection(collection_name)
+
+        if success:
+            await app.update_status_bar()
+            app.ui.show_success(f"Collection '{collection_name}' created and activated")
+            app.ui.show_info("Chat session reset - ready for new conversation")
+        else:
+            app.ui.show_error("Failed to create collection")
+    else:
+        app.ui.show_error("Collection name is required")
+
+    return True
+
+
+async def handle_new_chat(args: str) -> bool:
+    """Create a new chat session."""
+    app = get_app_state()
+
+    if not app.rag_manager.connected:
+        app.ui.show_error("Not connected to H2OGPTE. Use /register first.")
+        return True
+
+    # Ensure we have a collection first
+    if not await app.rag_manager.get_collection_name():
+        app.ui.show_info("No active collection. Creating default collection...")
+        success = await app.rag_manager.switch_to_collection("CLI-Collection")
+        if not success:
+            app.ui.show_error("Failed to create collection")
+            return True
+
+    if not args:
+        import datetime
+
+        session_name = f"chat-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+    else:
+        session_name = args.strip()
+
+    app.ui.show_info(f"Creating new chat session '{session_name}'...")
+    success = await app.rag_manager.create_chat_session(session_name)
+
+    if success:
+        await app.update_status_bar()
+        app.ui.show_success(f"Chat session '{session_name}' created and activated")
+    else:
+        app.ui.show_error("Failed to create chat session")
+
+    return True

h2ogpte/cli/commands/command_handlers/config.py

@@ -0,0 +1,113 @@
+from rich.table import Table
+
+from ...core.app import get_app_state
+
+
+async def handle_config(args: str) -> bool:
+    """Configure settings."""
+    app = get_app_state()
+
+    try:
+        categories = ["RAG", "Agent", "UI", "View Current", "Save & Exit"]
+        choice = app.ui.prompt.select_from_list(
+            categories, "Select configuration category:"
+        )
+
+        if choice == "RAG":
+            app.console.print("[cyan]RAG Configuration[/cyan]")
+
+            current_endpoint = app.settings.rag.endpoint or "not set"
+            new_endpoint = app.ui.prompt.get_input(
+                f"RAG Endpoint [{current_endpoint}]: "
+            )
+            if new_endpoint:
+                app.settings.rag.endpoint = new_endpoint
+
+            current_key = "*" * 8 if app.settings.rag.api_key else "not set"
+            new_key = app.ui.prompt.get_input(f"API Key [{current_key}]: ")
+            if new_key:
+                app.settings.rag.api_key = new_key
+
+            current_collection = app.settings.rag.collection_name
+            new_collection = app.ui.prompt.get_input(
+                f"Collection [{current_collection}]: "
+            )
+            if new_collection:
+                app.settings.rag.collection_name = new_collection
+
+        elif choice == "Agent":
+            app.console.print("[cyan]Agent Configuration[/cyan]")
+
+            current_endpoint = app.settings.agent.endpoint or "not set"
+            new_endpoint = app.ui.prompt.get_input(
+                f"Agent Endpoint [{current_endpoint}]: "
+            )
+            if new_endpoint:
+                app.settings.agent.endpoint = new_endpoint
+
+            current_key = "*" * 8 if app.settings.agent.api_key else "not set"
+            new_key = app.ui.prompt.get_input(f"API Key [{current_key}]: ")
+            if new_key:
+                app.settings.agent.api_key = new_key
+
+            current_model = app.settings.agent.model
+            new_model = app.ui.prompt.get_input(f"Model [{current_model}]: ")
+            if new_model:
+                app.settings.agent.model = new_model
+
+        elif choice == "UI":
+            app.console.print("[cyan]UI Configuration[/cyan]")
+
+            current_theme = app.settings.ui.theme
+            new_theme = app.ui.prompt.get_input(f"Theme [{current_theme}]: ")
+            if new_theme:
+                app.settings.ui.theme = new_theme
+
+            app.settings.ui.show_progress = app.ui.prompt.confirm(
+                "Show progress bars", default=app.settings.ui.show_progress
+            )
+
+            app.settings.ui.animation = app.ui.prompt.confirm(
+                "Enable animations", default=app.settings.ui.animation
+            )
+
+        elif choice == "View Current":
+            _show_current_config(app)
+
+        if choice not in ["View Current", "Save & Exit"]:
+            try:
+                app.settings.save()
+                app.ui.show_success("Configuration saved")
+                # Update status bar after config changes
+                app.update_status_bar()
+            except Exception as e:
+                app.ui.show_error(f"Failed to save configuration: {e}")
+
+    except Exception as e:
+        app.ui.show_error(f"Configuration error: {e}")
+
+    return True
+
+
+def _show_current_config(app):
+    """Show current configuration."""
+    table = Table(title="Current Configuration")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="white")
+
+    # RAG settings
+    table.add_row("RAG Endpoint", app.settings.rag.endpoint or "not set")
+    table.add_row("RAG API Key", "*" * 8 if app.settings.rag.api_key else "not set")
+    table.add_row("RAG Collection", app.settings.rag.collection_name)
+
+    # Agent settings
+    table.add_row("Agent Endpoint", app.settings.agent.endpoint or "not set")
+    table.add_row("Agent API Key", "*" * 8 if app.settings.agent.api_key else "not set")
+    table.add_row("Agent Model", app.settings.agent.model)
+
+    # UI settings
+    table.add_row("UI Theme", app.settings.ui.theme)
+    table.add_row("Show Progress", str(app.settings.ui.show_progress))
+    table.add_row("Animations", str(app.settings.ui.animation))
+
+    app.console.print(table)

h2ogpte/cli/commands/command_handlers/disconnect.py

@@ -0,0 +1,36 @@
+from ...core.app import get_app_state
+
+
+async def handle_disconnect(args: str) -> bool:
+    """Disconnect from H2OGPTE and clear saved credentials."""
+    app = get_app_state()
+
+    if not app.rag_manager.connected:
+        app.ui.show_info("Already disconnected from H2OGPTE")
+        return True
+
+    # Confirm disconnection
+    if not app.ui.prompt.confirm(
+        "Disconnect and clear saved credentials?", default=False
+    ):
+        app.ui.show_info("Disconnection cancelled")
+        return True
+
+    # Disconnect from RAG manager
+    await app.rag_manager.close()
+
+    # Clear credentials from settings
+    app.settings.rag.endpoint = ""
+    app.settings.rag.api_key = ""
+    app.settings.rag.collection_name = "default"
+
+    # Save cleared settings
+    app.settings.save()
+
+    # Update status bar
+    await app.update_status_bar()
+
+    app.ui.show_success("Disconnected and credentials cleared")
+    app.ui.show_info("Use /register to connect again")
+
+    return True

h2ogpte/cli/commands/command_handlers/exit.py

@@ -0,0 +1,37 @@
+from rich.panel import Panel
+
+from ...core.app import get_app_state
+
+
+async def handle_exit(args: str) -> bool:
+    """Exit the application."""
+    app = get_app_state()
+
+    # Check if user provided 'y' as an argument for immediate exit
+    if args and args.strip().lower() in ["y", "yes"]:
+        # Exit immediately without confirmation
+        await app.cleanup()
+
+        app.console.print(
+            Panel(
+                "[bold cyan]Thank you for using H2OGPTE CLI![/bold cyan]\n"
+                "[dim]Session saved automatically[/dim]",
+                border_style="cyan",
+            )
+        )
+        return False
+
+    # Otherwise, ask for confirmation
+    if app.ui.prompt.confirm("Are you sure you want to exit?", default=False):
+        # Clean up
+        await app.cleanup()
+
+        app.console.print(
+            Panel(
+                "[bold cyan]Thank you for using H2OGPTE CLI![/bold cyan]\n"
+                "[dim]Session saved automatically[/dim]",
+                border_style="cyan",
+            )
+        )
+        return False
+    return True

h2ogpte/cli/commands/command_handlers/help.py

@@ -0,0 +1,8 @@
+from ...core.app import get_app_state
+
+
+async def handle_help(args: str) -> bool:
+    """Show help information."""
+    app = get_app_state()
+    app.ui.show_help()
+    return True

h2ogpte/cli/commands/command_handlers/history.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+from rich.table import Table
+
+from ...core.app import get_app_state
+
+
+async def handle_history(args: str) -> bool:
+    """Show command history."""
+    app = get_app_state()
+    limit = int(args) if args.isdigit() else 20
+
+    history = app.session.history[-limit:]
+    if not history:
+        app.ui.show_info("No command history")
+        return True
+
+    table = Table(title=f"Command History (last {len(history)} entries)")
+    table.add_column("#", style="dim")
+    table.add_column("Time", style="cyan")
+    table.add_column("Command", style="white")
+    table.add_column("Status", style="white")
+
+    for i, entry in enumerate(history, 1):
+        time_str = datetime.fromisoformat(entry["timestamp"]).strftime("%H:%M:%S")
+        status = "[green]✓[/green]" if entry["success"] else "[red]✗[/red]"
+        table.add_row(str(i), time_str, entry["command"][:50], status)
+
+    app.console.print(table)
+    return True

h2ogpte/cli/commands/command_handlers/rag.py

@@ -0,0 +1,146 @@
+from pathlib import Path
+
+from ...core.app import get_app_state
+
+
+async def handle_register(args: str) -> bool:
+    """Register H2OGPTE system."""
+    app = get_app_state()
+
+    # Parse arguments or prompt for them
+    parts = args.split()
+
+    if len(parts) < 2:
+        # Check if user explicitly wants to clear credentials (special keyword)
+        if args.strip().lower() in ["clear", "disconnect", "reset"]:
+            app.ui.show_info("Clearing credentials...")
+            # Clear existing connection
+            if app.rag_manager.connected:
+                await app.rag_manager.close()
+
+            # Clear credentials
+            app.settings.rag.endpoint = ""
+            app.settings.rag.api_key = ""
+            app.settings.rag.collection_name = "default"
+            app.settings.save()
+
+            # Update status bar
+            await app.update_status_bar()
+
+            app.ui.show_success(
+                "Credentials cleared. Use /register <address> <api_key> to reconnect"
+            )
+            return True
+
+        # Interactive mode with defaults and secure input
+        address = app.ui.prompt.get_input_with_default(
+            "H2OGPTE Address", "https://h2ogpte.genai.h2o.ai"
+        )
+        api_key = app.ui.prompt.get_secret("API Key")
+
+        # If user cancels input, don't proceed
+        if not address or not api_key:
+            app.ui.show_info("Registration cancelled")
+            return True
+    else:
+        address = parts[0]
+        api_key = parts[1]
+
+    # Step 1: Connect and get username only
+    app.ui.show_info("Step 1: Connecting and retrieving user information...")
+
+    # Save to settings with encrypted API key
+    app.settings.rag.endpoint = address
+    app.settings.set_rag_api_key(api_key)
+
+    # Try to connect and get username (without creating collection yet)
+    success = await app.rag_manager.connect_and_get_user(address, api_key)
+
+    if success:
+        # Get username and update status bar
+        username = await app.rag_manager.get_username()
+        if username:
+            app.ui.show_success(f"Connected as user: {username}")
+
+            # Save settings on successful connection
+            app.settings.save()
+
+            # Update status bar with username
+            await app.update_status_bar()
+            app.ui.show_success("Connected successfully! Ready to chat.")
+
+        else:
+            app.ui.show_error("Connected but failed to get username")
+    else:
+        app.ui.show_error("Failed to connect to H2OGPTE")
+
+    return True
+
+
+async def handle_upload(args: str) -> bool:
+    """Upload files to RAG."""
+    app = get_app_state()
+
+    if not args:
+        # Interactive file selection
+        path = app.ui.prompt.get_path("Select file or directory to upload: ")
+        if not path:
+            return True
+    else:
+        path = Path(args.strip())
+
+    if not path.exists():
+        app.ui.show_error(f"Path not found: {path}")
+        return True
+
+    # Collect files
+    if path.is_file():
+        files = [path]
+    else:
+        # Scan directory
+        patterns = app.ui.prompt.get_multiselect(
+            ["*.py", "*.js", "*.txt", "*.md", "*.json", "*"],
+            "Select file patterns to include:",
+        )
+        files = app.file_manager.scan_directory(
+            path, patterns if patterns != ["*"] else None
+        )
+
+    if not files:
+        app.ui.show_warning("No files to upload")
+        return True
+
+    # Display files to upload
+    app.file_manager.display_file_list(files, show_details=False)
+
+    if not app.ui.prompt.confirm(f"Upload {len(files)} file(s)?", default=True):
+        return True
+
+    # Upload files
+    await app.rag_manager.upload_files(files)
+    return True
+
+
+async def handle_analyze(args: str) -> bool:
+    """Analyze directory."""
+    app = get_app_state()
+
+    if not args:
+        path = Path.cwd()
+    else:
+        path = Path(args.strip())
+
+    if not path.exists() or not path.is_dir():
+        app.ui.show_error(f"Invalid directory: {path}")
+        return True
+
+    # Analyze directory
+    analysis = await app.dir_analyzer.analyze(path)
+
+    # Ask if user wants to upload
+    if analysis["total_files"] > 0:
+        if app.ui.prompt.confirm("Upload directory contents to RAG?"):
+            files = app.file_manager.scan_directory(path)
+            await app.rag_manager.upload_files(files)
+
+    return True

h2ogpte/cli/commands/command_handlers/research_agent.py

@@ -0,0 +1,45 @@
+from ...core.app import get_app_state
+
+
+async def handle_research_agent(args: str) -> bool:
+    app = get_app_state()
+
+    if not args or not args.strip():
+        app.ui.show_error("Please provide a research query")
+        app.ui.show_info(
+            "Example: /research What are the latest developments in quantum computing?"
+        )
+        return True
+
+    message = args.strip()
+
+    if app.rag_manager.connected:
+        usage_stats = await app.rag_manager.send_message(
+            message, use_agent=True, agent_type="deep_research"
+        )
+
+        if usage_stats:
+            total_input_tokens = sum(
+                u.get("input_tokens", 0) for u in usage_stats.get("usage", [])
+            )
+            total_output_tokens = sum(
+                u.get("output_tokens", 0) for u in usage_stats.get("usage", [])
+            )
+            response_time = usage_stats.get("response_time", "N/A")
+            queued_for = usage_stats.get("queue_time", "N/A")
+            llm = usage_stats.get("llm", "N/A")
+            app.ui.show_info(
+                f"[Research] Tokens: {total_input_tokens} (in), {total_output_tokens} (out), "
+                f"Response time: {response_time}, "
+                f"Queued for: {queued_for}, "
+                f"LLM: {llm}"
+            )
+
+        await app.update_status_bar()
+    else:
+        app.ui.show_error("Not connected to H2OGPTE. Use /register to connect first.")
+        app.ui.show_info(
+            "Example: /register https://your-h2ogpte-endpoint.com your-api-key"
+        )
+
+    return True

h2ogpte/cli/commands/command_handlers/session.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+import datetime
+
+from ...core.app import get_app_state
+
+
+async def handle_session(args: str) -> bool:
+    """Create a new chat session with optional name."""
+    app = get_app_state()
+
+    if not app.rag_manager.connected:
+        app.ui.show_error("Not connected to H2OGPTE. Use /register first.")
+        return True
+
+    # Ensure we have a collection first
+    if not await app.rag_manager.get_collection_name():
+        app.ui.show_info("No active collection. Creating default collection...")
+        success = await app.rag_manager.switch_to_collection("CLI-Collection")
+        if not success:
+            app.ui.show_error("Failed to create collection")
+            return True
+
+    # Determine session name
+    if not args:
+        session_name = f"chat-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+    else:
+        session_name = args.strip()
+
+    app.ui.show_info(f"Creating new chat session '{session_name}'...")
+
+    # Create the chat session and get the session ID
+    session_id = await app.rag_manager.create_chat_session_with_name(session_name)
+
+    if session_id:
+        await app.update_status_bar()
+        app.ui.show_success(f"Chat session '{session_name}' created and activated")
+    else:
+        app.ui.show_error("Failed to create chat session")
+
+    return True
+
+
+async def handle_save(args: str) -> bool:
+    """Save session."""
+    app = get_app_state()
+
+    if args:
+        path = Path(args)
+    else:
+        path = None
+
+    app.session.save_session(path)
+    return True
+
+
+async def handle_load(args: str) -> bool:
+    """Load session."""
+    app = get_app_state()
+
+    if not args:
+        app.ui.show_error("Please provide a session file path")
+        return True
+
+    path = Path(args)
+    if not path.exists():
+        app.ui.show_error(f"Session file not found: {path}")
+        return True
+
+    try:
+        from ...core.session import Session
+
+        app.session = Session.load_session(path)
+        app.ui.show_success(f"Session loaded from {path}")
+    except Exception as e:
+        app.ui.show_error(f"Failed to load session: {e}")
+
+    return True