Added Interactive Mode

Author: ashes00

README.md

@@ -15,6 +15,9 @@ Designed for developers, researchers, and power users, DeepShell abstracts away
 *   **Multi-LLM Support:**
     *   Seamlessly connect to **Ollama** servers (local or remote).
     *   Integrate with the **Google Gemini API**.
+*   **Conversational Memory:**
+    *   Engage in multi-turn conversations using the new **interactive mode** (`-i`).
+    *   The model remembers the context of the last 10 turns of your conversation.
 *   **Unified & Interactive Configuration:**
     *   A central, user-friendly settings menu (`-s`) guides you through all configuration tasks.
     *   Manages LLM service details, including server addresses (Ollama) and API keys (Gemini).
@@ -222,4 +225,3 @@ ds -v
 ```
 
 Happy Querying!
-

dist/deepshell-v-1.0.4

@@ -320,37 +320,50 @@ def _setup_gemini_service(config_data):
     display_message(f"Gemini service configured with model: {chosen_model_full_name.split('/')[-1]}", "green")
     return config_data
 
-def send_gemini_query(api_key, model_name, user_query, active_service_name_display, api_key_nickname_display, gemini_service_config):
+def send_gemini_query(api_key, model_name, user_query, conversation_history, active_service_name_display, api_key_nickname_display, gemini_service_config):
     """
     Sends the user's query to the Gemini API and prints the response.
     Model name should be the full "models/gemini-pro" style name.
     If Markdown rendering is enabled in the service configuration, the response
     will be formatted using the `rich` library.
+    `conversation_history` is a list of previous user/model messages.
+    Returns the text of the response, or None on failure.
     gemini_service_config is the specific configuration part for Gemini service.
     """
     model_display_name = model_name.split('/')[-1]
     sending_message = (
         f"Using active LLM service: {active_service_name_display} (API Key: '{api_key_nickname_display}'). "
         f"Sending query (Model: {model_display_name})..."
     )
-    # display_message(sending_message, "blue", end='') # Old way
-    display_message(sending_message, "blue") # New way, prints newline by default
-    sys.stdout.flush() # Ensure the message is displayed before animation starts
+    if not conversation_history:
+        display_message(sending_message, "blue")
+        sys.stdout.flush() # Ensure the message is displayed before animation starts
     message_len_for_animation = len(sending_message)
     if not model_name.startswith("models/"):
         model_name_for_api = f"models/{model_name}"
     else:
         model_name_for_api = model_name
 
+    # Transform canonical history to Gemini's format
+    gemini_history = []
+    for message in conversation_history:
+        # Gemini uses 'model' for assistant role
+        role = "model" if message["role"] == "model" else "user"
+        gemini_history.append({
+            "role": role,
+            "parts": [{"text": message["content"]}]
+        })
+    # Add the new user query
+    gemini_history.append({"role": "user", "parts": [{"text": user_query}]})
+
     url = f"{GEMINI_API_BASE_URL}/{model_name_for_api}:generateContent?key={api_key}"
-    payload = {
-        "contents": [{"parts":[{"text": user_query}]}]
-    }
+    payload = {"contents": gemini_history}
 
     stop_event = threading.Event()
     animation_thread = threading.Thread(target=_animate_progress, args=(stop_event, message_len_for_animation))
     animation_thread.daemon = True
-    animation_thread.start()
+    if not conversation_history: # Only animate on first query
+        animation_thread.start()
 
     response_data = None
     error_message_to_display = None 
@@ -370,9 +383,10 @@ def send_gemini_query(api_key, model_name, user_query, active_service_name_displ
         error_message_to_display = "Error: Could not parse JSON response from Gemini API."
     finally:
         stop_event.set()
-        animation_thread.join(timeout=0.5)
-        sys.stdout.write("\r" + " " * message_len_for_animation + "\r")
-        sys.stdout.flush()
+        if not conversation_history: # Only join/clear if started
+            animation_thread.join(timeout=0.5)
+            sys.stdout.write("\r" + " " * message_len_for_animation + "\r")
+            sys.stdout.flush()
 
     if response_data and 'candidates' in response_data and response_data['candidates'] and \
        'content' in response_data['candidates'][0] and \
@@ -392,9 +406,14 @@ def send_gemini_query(api_key, model_name, user_query, active_service_name_displ
         else:
             print(gemini_text_response)
         display_message("-----------------------", "green") 
+        return gemini_text_response
     elif error_message_to_display: 
         display_message(error_message_to_display, "red")
+        return None
     elif not response_data and not error_message_to_display: 
         display_message("Error: Received an empty or unexpected response from Gemini API.", "orange")
+        return None
     elif response_data: 
         display_message(f"Error: Unexpected response format from Gemini. Full response: {json.dumps(response_data, indent=2)}", "orange")
+        return None
+    return None

gemini.py

@@ -18,7 +18,7 @@
 from settings import jump_to_previous_llm # Import the new function
 
 # Version
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 
 class CustomHelpFormatter(argparse.RawTextHelpFormatter):
     """Custom formatter for argparse help messages to adjust spacing."""
@@ -130,6 +130,68 @@ def set_gemini_api_key_interactive(config_dir, config_file):
     setup_config(config_dir, config_file, jump_to="gemini_keys", is_direct_flag_call=True)
     sys.exit(0)
 
+def start_interactive_session(config_data, config_dir, config_file):
+    """Starts an interactive chat session with the configured LLM."""
+    display_message("\n--- DeepShell Interactive Mode ---", "green")
+    display_message("Type 'exit' or 'quit' to end the session.", "yellow")
+
+    # Load service details from config
+    active_service_name = config_data.get("active_llm_service")
+    service_config = config_data["llm_services"][active_service_name]
+    model_name = service_config.get("model")
+    active_service_name_display = active_service_name.capitalize()
+
+    # Prepare service-specific details
+    api_key_value, api_key_nickname = (None, None)
+    server_address = None
+    if active_service_name == LLM_SERVICE_GEMINI:
+        api_key_value, api_key_nickname = _get_active_gemini_key_value(service_config)
+        if not api_key_value:
+            display_message("No active Gemini API key found. Please configure it via --setup.", "red")
+            sys.exit(1)
+    elif active_service_name == LLM_SERVICE_OLLAMA:
+        server_address = service_config.get("server_address")
+        if not server_address:
+            display_message("Ollama server address not configured. Please configure it via --setup.", "red")
+            sys.exit(1)
+
+    conversation_history = []
+    MAX_HISTORY_TURNS = 10 # 10 pairs of user/model messages
+    MAX_HISTORY_ITEMS = MAX_HISTORY_TURNS * 2
+
+    while True:
+        try:
+            user_input = input("> ")
+            if user_input.lower() in ['exit', 'quit']:
+                display_message("Exiting interactive mode.", "blue")
+                break
+            if not user_input.strip():
+                continue
+
+            # Trim history if it's too long. Keep the last 9 pairs and make room for the new one.
+            if len(conversation_history) >= MAX_HISTORY_ITEMS:
+                conversation_history = conversation_history[2:]
+
+            response_text = None
+            if active_service_name == LLM_SERVICE_GEMINI:
+                response_text = send_gemini_query(
+                    api_key_value, model_name, user_input, conversation_history,
+                    active_service_name_display, api_key_nickname, service_config
+                )
+            elif active_service_name == LLM_SERVICE_OLLAMA:
+                response_text = send_ollama_query(
+                    server_address, model_name, user_input, conversation_history,
+                    active_service_name_display, service_config
+                )
+
+            if response_text:
+                # Add to history using a canonical format
+                conversation_history.append({"role": "user", "content": user_input})
+                conversation_history.append({"role": "model", "content": response_text})
+
+        except EOFError: # Handle Ctrl+D
+            display_message("\nExiting interactive mode.", "blue")
+            break
 
 def main():
     """
@@ -151,13 +213,21 @@ def main():
             dest="model_change", 
             help="Change the default model for the active LLM service."
         )
-        parser.add_argument(
+        
+        # Group for mutually exclusive query/interactive modes
+        mode_group = parser.add_mutually_exclusive_group()
+        mode_group.add_argument(
             "-q", "--query",
             nargs='+', 
             metavar="QUERY",
             help="The query to send to the LLM. All text following this flag will be treated as the query.\n"
                  "Example: deepshell -q What is the capital of France?"
         )
+        mode_group.add_argument(
+            "-i", "--interactive",
+            action="store_true",
+            help="Start an interactive chat session."
+        )
         parser.add_argument(
             "-d", "--delete-config",
             action="store_true",
@@ -249,6 +319,18 @@ def main():
             jump_to_previous_llm(config_dir, config_file)
             sys.exit(0)
 
+        if args.interactive:
+            config_data = load_config(config_file)
+            if config_data is None or not config_data.get("active_llm_service"):
+                display_message("Configuration not found or no active LLM service. Running setup...", "yellow")
+                config_data = setup_config(config_dir, config_file, is_direct_flag_call=False)
+                if not config_data or not config_data.get("active_llm_service"):
+                    display_message("Setup incomplete. Exiting.", "red")
+                    sys.exit(1)
+            
+            start_interactive_session(config_data, config_dir, config_file)
+            sys.exit(0)
+
         config_data = load_config(config_file)
         user_query_list = args.query
         user_query = " ".join(user_query_list) if user_query_list else None
@@ -290,14 +372,14 @@ def main():
             if not server_address:
                 display_message("Ollama server address not configured. Please run --setup or --llm to configure Ollama.", "red")
                 sys.exit(1)
-            send_ollama_query(server_address, model_name, user_query, active_service_name_display, service_config)
+            send_ollama_query(server_address, model_name, user_query, [], active_service_name_display, service_config)
         elif active_service_name == LLM_SERVICE_GEMINI:
             active_api_key_value, active_nickname = _get_active_gemini_key_value(service_config)
             if not active_api_key_value:
                 display_message("No active Gemini API key configured or found. Please run --setup or --llm to configure Gemini.", "red")
                 sys.exit(1)
             send_gemini_query(
-                active_api_key_value, model_name, user_query,
+                active_api_key_value, model_name, user_query, [],
                 active_service_name_display,
                 active_nickname,
                 service_config 

main.py

@@ -1,4 +1,15 @@
 requests
 chardet
-nuitka
 rich
+argparse
+textwrap
+os
+sys
+subprocess
+shutil
+json
+requests
+threading
+time
+pyinstaller
+

modules.txt

@@ -132,32 +132,45 @@ def _setup_ollama_service(config_data, server_address_input_prompt="Enter OLLAMA
     display_message(f"Ollama service configured with model: {chosen_model}", "green")
     return config_data
 
-def send_ollama_query(server_address, model_name, user_query, active_service_name_display, ollama_service_config):
+def send_ollama_query(server_address, model_name, user_query, conversation_history, active_service_name_display, ollama_service_config):
     """
     Sends the user's query to the OLLAMA server's /api/chat endpoint
     and prints only the relevant response content.
+    `conversation_history` is a list of previous user/model messages.
+    Returns the text of the response, or None on failure.
     ollama_service_config is the specific configuration part for Ollama service.
     """
     sending_message = (
         f"Using active LLM service: {active_service_name_display}. "
         f"Sending query to {server_address} (Model: {model_name})..."
     )
-    # display_message(sending_message, "blue", end='') # Old way
-    display_message(sending_message, "blue") # New way, prints newline by default
-    sys.stdout.flush() # Ensure the message is displayed before animation starts
+    if not conversation_history:
+        display_message(sending_message, "blue")
+        sys.stdout.flush() # Ensure the message is displayed before animation starts
     message_len_for_animation = len(sending_message)
 
+    # Transform canonical history to Ollama's format
+    ollama_messages = []
+    for message in conversation_history:
+        # Ollama uses 'assistant' for model role
+        role = "assistant" if message["role"] == "model" else "user"
+        ollama_messages.append({
+            "role": role,
+            "content": message["content"]
+        })
+    # Add the new user query
+    ollama_messages.append({"role": "user", "content": user_query})
+
     url = f"{server_address}/api/chat"
     payload = {
-        "model": model_name,
-        "messages": [{"role": "user", "content": user_query}],
-        "stream": False 
+        "model": model_name, "messages": ollama_messages, "stream": False
     }
 
     stop_event = threading.Event()
     animation_thread = threading.Thread(target=_animate_progress, args=(stop_event, message_len_for_animation))
-    animation_thread.daemon = True 
-    animation_thread.start()
+    animation_thread.daemon = True
+    if not conversation_history: # Only animate on first query
+        animation_thread.start()
 
     response_data = None
     error_message_to_display = None 
@@ -181,12 +194,14 @@ def send_ollama_query(server_address, model_name, user_query, active_service_nam
         error_message_to_display = f"An unexpected error occurred during query: {e}"
     finally:
         stop_event.set()
-        animation_thread.join(timeout=0.5)
-        sys.stdout.write("\r" + " " * message_len_for_animation + "\r")
-        sys.stdout.flush()
+        if not conversation_history: # Only join/clear if started
+            animation_thread.join(timeout=0.5)
+            sys.stdout.write("\r" + " " * message_len_for_animation + "\r")
+            sys.stdout.flush()
 
     if error_message_to_display:
         display_message(error_message_to_display, "red")
+        return None
     elif response_data:
         if "message" in response_data and "content" in response_data["message"]:
             ollama_text_response = response_data["message"]["content"].strip()
@@ -203,5 +218,8 @@ def send_ollama_query(server_address, model_name, user_query, active_service_nam
             else:
                 print(ollama_text_response)
             display_message("-----------------------", "green") 
+            return ollama_text_response
         else:
-            display_message(f"Error: Unexpected response format from server. Full response: {json.dumps(response_data, indent=2)}", "orange")
+            display_message(f"Error: Unexpected response format from server. Full response: {json.dumps(response_data, indent=2)}", "orange")
+            return None
+    return None