Disable response interruption, reorder AI prompts and add sysprompt command

Author: MituuZ

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sllama"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -2,7 +2,24 @@
 
 ## 0.1.5 - 2025-06-08
 
-_Use [rustyline](https://github.com/kkawakam/rustyline) for user input handling_
+_Integrate [rustyline](https://github.com/kkawakam/rustyline) for input handling, add `sysprompt` command, order prompts
+and disable interruption_
+
+### Interruption
+
+- Crossterm and rustyline do not play nice, disabled AI response interruption to keep input consistent.
+
+### Prompts
+
+- Use a more traditional ordering with:
+    1. System prompt
+    2. Context file
+    3. History file
+    4. Current user prompt
+
+### Commands
+
+- Enable modifying system prompt for the current session.
 
 ## 0.1.4 - 2025-06-08
 

changelog.md

@@ -7,9 +7,10 @@ A command-line interface for interacting with Ollama AI models.
 - Store conversations as files
 - Add context to a session with `-f/--file` flag
 - Prompts are built in the following way:
-    1. History file (including the current user prompt)
+    1. System prompt
     2. Context file
-    3. System prompt
+    3. History file
+    4. Current user prompt
 
 ## Installation
 
@@ -70,6 +71,12 @@ Exit the current chat.
 
 `:q`
 
+#### Sysprompt
+
+Update the system prompt for this session. Does not modify any configurations.
+
+`:sysprompt Enter the new system prompt here`
+
 ## Configuration
 
 You can configure your sllama by creating and modifying TOML configuration located at `~/.sllama.toml`/

readme.md

@@ -54,14 +54,17 @@ fn main() -> io::Result<()> {
     };
 
     let mut history = HistoryFile::new(filename.clone(), config.sllama_dir.clone())?;
-    let ollama_client = OllamaClient::new(config.model, config.system_prompt);
-
+    println!("{}", history.get_content());
+    println!("You're conversing with {} model", &config.model);
+    let mut ollama_client = OllamaClient::new(config.model, config.system_prompt);
     println!("Press Enter during AI generation to interrupt the response.");
 
     // Main conversation loop
     loop {
         // Prompt the user for input
-        println!("\nEnter your prompt (or type ':q' to end):");
+        println!(
+            "\nEnter your prompt or a command (type ':q' to end or ':help' for other commands)"
+        );
         let mut rl = match rustyline::DefaultEditor::new() {
             Ok(r) => r,
             Err(e) => {
@@ -106,17 +109,24 @@ fn main() -> io::Result<()> {
                     }
                     continue;
                 }
+                ":sysprompt" => {
+                    ollama_client.update_system_prompt(args.join(" "));
+                    continue;
+                }
                 _ => {
                     println!("Unknown command '{}'", command_string);
                     continue;
                 }
             }
         }
 
-        history.append_user_input(&user_prompt)?;
+        let (ollama_response, was_interrupted) = ollama_client.generate_response(
+            history.get_content(),
+            &user_prompt,
+            input_file_content.as_deref(),
+        )?;
 
-        let (ollama_response, was_interrupted) = ollama_client
-            .generate_response(history.get_content(), input_file_content.as_deref())?;
+        history.append_user_input(&user_prompt)?;
 
         history.append_ai_response(&ollama_response, was_interrupted)?;
     }

src/main.rs

@@ -1,5 +1,3 @@
-use crossterm::event;
-use crossterm::event::{Event, KeyCode};
 use std::io::{BufReader, Read, Write};
 use std::process::{Child, Command, Stdio};
 use std::sync::mpsc;
@@ -19,11 +17,12 @@ impl OllamaClient {
             system_prompt,
         }
     }
-    
+
     pub(crate) fn generate_response(
         &self,
         history_content: &str,
-        context_content: Option<&str>
+        user_prompt: &str,
+        context_content: Option<&str>,
     ) -> io::Result<(String, bool)> {
         // Create the ollama command with stdout piped
         let mut cmd = Command::new("ollama")
@@ -35,18 +34,23 @@ impl OllamaClient {
 
         // Create the input for the ollama process
         if let Some(mut stdin) = cmd.stdin.take() {
-            // Use the full history for context (including current user input)
-            stdin.write_all(history_content.as_bytes())?;
+            // First, add the system prompt
+            stdin.write_all(b"Here is the system prompt: ")?;
+            stdin.write_all(self.system_prompt.as_bytes())?;
 
-            // Include the context file content if available
+            // Then add the context file content if available
             if let Some(ref content) = context_content {
                 stdin.write_all(b"\n\nAdditional context from file: ")?;
                 stdin.write_all(content.as_bytes())?;
             }
 
-            // Finally, add the system prompt
-            stdin.write_all(b"\n\n")?;
-            stdin.write_all(self.system_prompt.as_bytes())?;
+            // Then include the full history file for context
+            stdin.write_all(b"\n\nPrevious conversation: ")?;
+            stdin.write_all(history_content.as_bytes())?;
+
+            // Finally, add the user prompt
+            stdin.write_all(b"\n\nCurrent user prompt: ")?;
+            stdin.write_all(user_prompt.as_bytes())?;
         }
 
         // Get stdout stream from the child process
@@ -56,35 +60,39 @@ impl OllamaClient {
         // Set up channel for interrupt signal
         let (interrupt_tx, interrupt_rx) = mpsc::channel();
 
-        thread::spawn(move || {
-            println!("\nAI is responding... (Press Enter to interrupt)\n");
-            loop {
-                if event::poll(Duration::from_millis(100)).unwrap() {
-                    if let Event::Key(key) = event::read().unwrap() {
-                        if key.code == KeyCode::Enter {
-                            let _ = interrupt_tx.send(());
-                            break;
-                        }
-                    }
-                }
-            }
-        });
+        // thread::spawn(move || {
+        //     println!("\nAI is responding... (Press Enter to interrupt)\n");
+        //     loop {
+        //         if event::poll(Duration::from_millis(100)).unwrap() {
+        //             if let Event::Key(key) = event::read().unwrap() {
+        //                 if key.code == KeyCode::Enter {
+        //                     let _ = interrupt_tx.send(());
+        //                     break;
+        //                 }
+        //             }
+        //         }
+        //     }
+        // });
 
         // Read response while checking for interrupt
         let (full_response, was_interrupted) =
             read_process_output_with_interrupt(&mut reader, &interrupt_rx, &mut cmd)
                 .expect("error reading process output");
 
         let ollama_response = String::from_utf8_lossy(&full_response).to_string();
-        
+
         Ok((ollama_response, was_interrupted))
     }
+
+    pub(crate) fn update_system_prompt(&mut self, new_system_prompt: String) {
+        self.system_prompt = new_system_prompt;
+    }
 }
 
 fn read_process_output_with_interrupt(
     reader: &mut BufReader<impl Read>,
     interrupt_rx: &Receiver<()>,
-    cmd: &mut Child
+    cmd: &mut Child,
 ) -> io::Result<(Vec<u8>, bool)> {
     let mut buffer = [0; 1024];
     let mut full_response = Vec::new();
@@ -135,7 +143,7 @@ fn read_process_output_with_interrupt(
                 Ok(0) => break,
                 Ok(bytes_read) => {
                     full_response.extend_from_slice(&buffer[..bytes_read]);
-                },
+                }
                 Err(_) => break,
             }
         }
@@ -152,9 +160,9 @@ mod tests {
     fn test_ollama_client_creation() {
         let model = "llama2".to_string();
         let system_prompt = "You are a helpful assistant.".to_string();
-        
+
         let client = OllamaClient::new(model.clone(), system_prompt.clone());
-        
+
         assert_eq!(client.model, model);
         assert_eq!(client.system_prompt, system_prompt);
     }