Merge pull request #39 from rmusser01/dev

Sync from Dev to Main

Author: rmusser01

.github/workflows/python-app.yml

@@ -26,14 +26,8 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install flake8 pytest
+        pip install pytest
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-    - name: Lint with flake8
-      run: |
-        # stop the build if there are Python syntax errors or undefined names
-        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
     - name: Test with pytest
       run: |
         pytest

CONTRIBUTING.md

@@ -39,7 +39,7 @@ If you have general questions, feel free to reach out on the [tldw_Project Disco
 
 ## Coding Style
 
-*   Please follow [PEP 8](https://www.python.org/dev/peps/pep-0008/) for Python code. (I try)
+*   Please follow [PEP 8](https://www.python.org/dev/peps/pep-0008/) for Python code. (I try. I also try to use pylint but that's a whole rant.)
 *   Use clear and descriptive variable and function names.
 *   Add comments to your code where necessary to explain complex logic. over explained versus mysterious and demure.
 *   Ensure your code is well-formatted. Consider using a tool like Black or Ruff. (Is appreciated, even though I don't use it currently, I may in the future)

Docs/Design/Chat_Page.md

@@ -0,0 +1,56 @@
+# Chat Page Design Document
+
+## Table of Contents
+- [Overview](#overview)
+- [UI Structure](#ui-structure)
+- [Components](#components)
+- [Event Handling](#event-handling)
+- [Data Management](#data-management)
+- [Integration with Backend](#integration-with-backend)
+- [Testing](#testing)
+- [Future Enhancements](#future-enhancements)
+- [Conclusion](#conclusion)
+- [References](#references)
+
+
+Below is LLM generated content, will revisit later to ensure it is accurate and complete.
+
+------------------------------------------------------------
+### Overview
+- **101**
+  - The Chat Page is a central component of the `tldw_chatbook` application, designed to facilitate user interactions with chat functionalities. 
+  - It provides a user-friendly interface for managing conversations, viewing chat history, and interacting with characters.
+- **Goals**
+  - To create an intuitive and responsive chat interface that enhances user experience.
+  - To ensure seamless integration with backend services for real-time chat functionalities.
+  - To support character-specific interactions and manage chat history effectively.
+
+
+------------------------------------
+### UI Structure- 
+- **Layout**
+  - The Chat Page is structured to include a header, main content area, and footer.
+  - The header contains the title and navigation options.
+  - The main content area is divided into sections for chat history, input area, and character management.
+  - The footer includes status indicators and additional controls.
+  - **Responsive Design**
+  - The layout is designed to be responsive, adapting to different screen sizes and orientations.
+  - It uses flexible grid and box layouts to ensure components resize and reposition appropriately.
+  - **Accessibility**
+  - The UI is designed with accessibility in mind, ensuring that all components are navigable via keyboard and screen readers.
+  - Color contrasts and font sizes are chosen to enhance readability for all users.
+  - **Styling**
+  - The Chat Page uses a consistent color scheme and typography that aligns with the overall application design.
+  - Custom CSS styles are applied to enhance the visual appeal and usability of components.
+
+---------------------------------------
+### Components
+- **Chat History**
+  - Displays a list of previous messages in the conversation.
+  - Supports scrolling and lazy loading for large chat histories.
+- **Message Input**
+  - A text input field for users to type their messages.
+  - Includes features like auto-complete, emoji support, and formatting options.
+- **Character Management**
+  - Allows users to select and manage characters associated with the chat.
+  - Includes options to view character details, switch characters, and manage character-specific settings.

Docs/Design/User_Settings.md

@@ -0,0 +1,20 @@
+# User_Settings
+
+
+-----------------
+## Table of Contents
+- [User Settings Overview](#user-settings-overview)
+- [Settings Structure](#settings-structure)
+- [Settings Management](#settings-management)
+- [Settings UI](#settings-ui)
+- [Settings Persistence](#settings-persistence)
+- [Settings Validation](#settings-validation)
+- [Settings Synchronization](#settings-synchronization)
+- [Settings Security](#settings-security)
+
+------------------
+
+Gist is that any item with a `# USER-SETTING` comment is a user setting that can be configured via the Settings tab of the app.
+    - Goal is to allow the user to tweak application behavior and appearance without modifying the code or config files directly.
+
+

requirements.txt

@@ -17,5 +17,6 @@ httpx
 #nltk
 #scikit-learn
 # LLM
-
+vllm
+# transformers
 # Audio

static/PoC-Frontpage.PNG

@@ -19,11 +19,12 @@
 TAB_SEARCH = "search"
 TAB_INGEST = "ingest"
 TAB_TOOLS_SETTINGS = "tools_settings"
-TAB_LLM = "llm"
+TAB_LLM = "llm_management"
 TAB_STATS = "stats"
 TAB_LOGS = "logs"
+TAB_EVALS = "evals"
 ALL_TABS = [TAB_CHAT, TAB_CCP, TAB_NOTES, TAB_MEDIA, TAB_SEARCH, TAB_INGEST,
-            TAB_TOOLS_SETTINGS, TAB_LLM, TAB_LOGS, TAB_STATS]
+            TAB_TOOLS_SETTINGS, TAB_LLM, TAB_LOGS, TAB_STATS, TAB_EVALS]
 
 
 # --- CSS definition ---

tldw_chatbook/Constants.py

@@ -34,6 +34,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional
 
+from textual.containers import Container
 from textual.css.query import QueryError
 from textual.worker import Worker, WorkerState
 from textual.widgets import Input, RichLog, TextArea
@@ -57,9 +58,12 @@
     "handle_vllm_browse_python_button_pressed",
     "handle_vllm_browse_model_button_pressed",
     "handle_start_vllm_server_button_pressed",
+    "handle_stop_vllm_server_button_pressed",
     # ─── Model download ───────────────────────────────────────────────────────
     "handle_browse_models_dir_button_pressed",
     "handle_start_model_download_button_pressed",
+    # ─── Ollama ───────────────────────────────────────────────────────────────
+    "handle_ollama_nav_button_pressed",
 ]
 
 ###############################################################################
@@ -220,6 +224,7 @@ def run_vllm_server_worker(app_instance: "TldwCli", command: List[str]):
 
     logger = getattr(app_instance, "loguru_logger", logging.getLogger(__name__))
     logger.info("vLLM worker begins: %s", " ".join(command))
+    app_instance.vllm_server_process = None  # Clear any old process reference
 
     try:
         process = subprocess.Popen(
@@ -230,6 +235,7 @@ def run_vllm_server_worker(app_instance: "TldwCli", command: List[str]):
             bufsize=1,
             universal_newlines=True,
         )
+        app_instance.vllm_server_process = process  # Store the process
 
         app_instance.call_from_thread(
             app_instance._update_vllm_log, f"vLLM server started (PID: {process.pid})…\n"
@@ -238,15 +244,19 @@ def run_vllm_server_worker(app_instance: "TldwCli", command: List[str]):
         process.wait()
         yield f"vLLM server exited with code: {process.returncode}\n"
     except FileNotFoundError:
+        app_instance.vllm_server_process = None # Clear process on error
         msg = f"ERROR: vLLM interpreter not found: {command[0]}\n"
         logger.error(msg.rstrip())
         app_instance.call_from_thread(app_instance._update_vllm_log, msg)
         yield msg
     except Exception as err:
+        app_instance.vllm_server_process = None # Clear process on error
         msg = f"ERROR in vLLM worker: {err}\n"
         logger.error(msg.rstrip(), exc_info=True)
         app_instance.call_from_thread(app_instance._update_vllm_log, msg)
         yield msg
+    finally:
+        app_instance.vllm_server_process = None # Ensure process is cleared
 
 
 def run_model_download_worker(app_instance: "TldwCli", command: List[str]):
@@ -590,6 +600,48 @@ async def handle_start_vllm_server_button_pressed(app: "TldwCli") -> None:
         app.notify("Error setting up vLLM server start.", severity="error")
 
 
+async def handle_stop_vllm_server_button_pressed(app: "TldwCli") -> None:
+    """Stops the vLLM server process if it's running."""
+    logger = getattr(app, "loguru_logger", logging.getLogger(__name__))
+    logger.info("User requested to stop vLLM server.")
+
+    log_output_widget = app.query_one("#vllm-log-output", RichLog)
+
+    if hasattr(app, "vllm_server_process") and app.vllm_server_process:
+        process = app.vllm_server_process
+        if process.poll() is None:  # Process is running
+            logger.info(f"Stopping vLLM server process (PID: {process.pid}).")
+            log_output_widget.write(f"Stopping vLLM server (PID: {process.pid})...\n")
+            process.terminate()  # or process.kill()
+            try:
+                process.wait(timeout=10)  # Wait for up to 10 seconds
+                logger.info("vLLM server process terminated.")
+                log_output_widget.write("vLLM server stopped.\n")
+                app.notify("vLLM server stopped.")
+            except subprocess.TimeoutExpired:
+                logger.warning("Timeout waiting for vLLM server to terminate. Killing.")
+                log_output_widget.write("vLLM server did not stop gracefully, killing...\n")
+                process.kill()
+                process.wait() # Ensure it's killed
+                log_output_widget.write("vLLM server killed.\n")
+                app.notify("vLLM server killed after timeout.", severity="warning")
+            except Exception as e: # pylint: disable=broad-except
+                logger.error(f"Error during vLLM server termination: {e}", exc_info=True)
+                log_output_widget.write(f"Error stopping vLLM server: {e}\n")
+                app.notify(f"Error stopping vLLM server: {e}", severity="error")
+            finally:
+                app.vllm_server_process = None
+        else:
+            logger.info("vLLM server process was found but is not running.")
+            log_output_widget.write("vLLM server is not currently running.\n")
+            app.notify("vLLM server is not running.", severity="warning")
+            app.vllm_server_process = None # Clear the stale process reference
+    else:
+        logger.info("No vLLM server process found to stop.")
+        log_output_widget.write("vLLM server is not currently running.\n")
+        app.notify("vLLM server is not running.", severity="warning")
+
+
 ###############################################################################
 # ─── Model download UI helpers ──────────────────────────────────────────────
 ###############################################################################
@@ -666,3 +718,41 @@ async def handle_start_model_download_button_pressed(app: "TldwCli") -> None:
     except Exception as err:  # pragma: no cover
         logger.error("Error preparing model download: %s", err, exc_info=True)
         app.notify("Error setting up model download.", severity="error")
+
+
+###############################################################################
+# ─── Ollama UI helpers ──────────────────────────────────────────────────────
+###############################################################################
+
+
+async def handle_ollama_nav_button_pressed(app: "TldwCli") -> None:
+    """Handle the Ollama navigation button press."""
+    logger = getattr(app, "loguru_logger", logging.getLogger(__name__))
+    logger.debug("Ollama nav button pressed.")
+
+    try:
+        content_pane = app.query_one("#llm-content-pane", Container)
+        view_areas = content_pane.query(".llm-view-area")
+
+        for view in view_areas:
+            if view.id:  # Only hide if it has an ID
+                logger.debug(f"Hiding view #{view.id}")
+                view.styles.display = "none"
+            else: # pragma: no cover
+                logger.warning("Found a .llm-view-area without an ID, not hiding it.")
+
+        ollama_view = app.query_one("#llm-view-ollama", Container)
+        logger.debug(f"Showing view #{ollama_view.id}")
+        ollama_view.styles.display = "block"
+        #app.notify("Switched to Ollama view.")
+
+    except QueryError as e: # pragma: no cover
+        logger.error(f"QueryError in handle_ollama_nav_button_pressed: {e}", exc_info=True)
+        app.notify("Error switching to Ollama view: Could not find required UI elements.", severity="error")
+    except Exception as e: # pragma: no cover
+        logger.error(f"Unexpected error in handle_ollama_nav_button_pressed: {e}", exc_info=True)
+        app.notify("An unexpected error occurred while switching to Ollama view.", severity="error")
+
+#
+# End of llm_management_events.py
+########################################################################################################################

tldw_chatbook/Event_Handlers/llm_management_events.py

@@ -13,40 +13,79 @@
 if TYPE_CHECKING:
     from ..app import TldwCli  # pragma: no cover – runtime import only
 
+# Import the specific handler
+from .llm_management_events import handle_ollama_nav_button_pressed
+
 __all__ = [
     "handle_llm_nav_button_pressed",
 ]
 
 async def handle_llm_nav_button_pressed(app: "TldwCli", button_id: str) -> None:
     """
     Handles the navigation button presses in the LLM Management tab.
-    
+    Dispatches to specific handlers if available, otherwise uses a generic approach.
+
     Args:
         app: The TldwCli app instance
         button_id: The ID of the button that was pressed
     """
     logger = getattr(app, "loguru_logger", logging.getLogger(__name__))
     logger.info(f"LLM nav button pressed: {button_id}")
-    
+
     # Map button IDs to view IDs
     view_to_activate = button_id.replace("llm-nav-", "llm-view-")
     logger.debug(f"Activating LLM view: {view_to_activate}")
-    
+
     try:
         # Update app's reactive property to show the selected view
         app.llm_active_view = view_to_activate
-        
+
         # Remove active class from all nav buttons
         nav_pane = app.query_one("#llm-nav-pane")
         for nav_button in nav_pane.query(".llm-nav-button"):
             nav_button.remove_class("-active")
-        
-        # Add active class to the clicked button
+    except QueryError as e:
+        logger.error(f"Could not query #llm-nav-pane or .llm-nav-button: {e}", exc_info=True)
+        # Proceeding because view switching might still work
+
+    # Add active class to the specifically clicked button
+    try:
         clicked_button = app.query_one(f"#{button_id}", Button)
         clicked_button.add_class("-active")
-        
-        logger.info(f"Successfully switched to LLM view: {view_to_activate}")
     except QueryError as e:
-        logger.error(f"UI component not found during LLM view switch: {e}", exc_info=True)
-    except Exception as e:
-        logger.error(f"Unexpected error in handle_llm_nav_button_pressed: {e}", exc_info=True)
+        logger.error(f"Could not query clicked button #{button_id}: {e}", exc_info=True)
+        # Proceeding because view switching might still work
+
+    # Specific handlers
+    if button_id == "llm-nav-ollama":
+        await handle_ollama_nav_button_pressed(app)
+        # The reactive variable app.llm_active_view should also be set if the
+        # specific handler doesn't do it, to keep external state consistent.
+        # However, handle_ollama_nav_button_pressed directly manipulates view display.
+        # For consistency, we might want specific handlers to also update app.llm_active_view.
+        # For now, let's assume specific handlers manage the view entirely.
+        # If watch_llm_active_view is still active, this might cause double view changes or conflicts.
+        # The handle_ollama_nav_button_pressed already sets display properties.
+        # To prevent conflict with the watcher, we might avoid setting app.llm_active_view here for this specific case,
+        # OR ensure the watcher is idempotent / specific handlers also set app.llm_active_view.
+        # For now, let the specific handler do its job. The watcher will run if app.llm_active_view changes.
+        # If handle_ollama_nav_button_pressed doesn't change app.llm_active_view, the watcher won't re-hide other views.
+        # This seems acceptable.
+    # Add other specific handlers here:
+    # elif button_id == "llm-nav-another":
+    #     await handle_another_llm_nav_button_pressed(app)
+    else:
+        # Generic fallback for other LLM navigation buttons
+        view_to_activate = button_id.replace("llm-nav-", "llm-view-")
+        logger.debug(f"Using generic activation for LLM view: {view_to_activate}")
+        try:
+            # Update app's reactive property to show the selected view
+            # This relies on the watcher `watch_llm_active_view` in app.py
+            app.llm_active_view = view_to_activate
+            logger.info(f"Successfully set app.llm_active_view to: {view_to_activate} for generic handling.")
+        except Exception as e: # Catch errors related to setting reactive or if watcher fails
+            logger.error(f"Error in generic LLM view activation for '{view_to_activate}': {e}", exc_info=True)
+
+    # Note: The original code had a single try-except.
+    # Splitting it can help isolate where QueryErrors happen (nav pane vs content pane switching).
+    # The specific handlers (like handle_ollama_nav_button_pressed) have their own try-except.