Eladrin shell improvements

aethelos-source/heartwood/src/attunement/keyboard.rs

···
             0x32 => Some('m'),
             0x39 => Some(' '),  // Space
             0x1C => Some('\n'), // Enter
+            0x0E => Some('\x08'), // Backspace
+            0x48 => Some('\x01'), // Up arrow (special control char)
+            0x50 => Some('\x02'), // Down arrow (special control char)
             _ => None,  // Ignore other keys
         };
 
-        // If we got a valid character, send it to both display and shell buffer
+        // Handle the character
         if let Some(character) = ch {
-            crate::print!("{}", character);
-            crate::eldarin::handle_char(character);
+            match character {
+                '\x08' => {
+                    // Backspace: erase character visually and update buffer
+                    crate::eldarin::handle_backspace();
+                }
+                '\x01' => {
+                    // Up arrow: navigate to previous command
+                    crate::eldarin::handle_arrow_up();
+                }
+                '\x02' => {
+                    // Down arrow: navigate to next command
+                    crate::eldarin::handle_arrow_down();
+                }
+                _ => {
+                    // Regular character: display and buffer it
+                    crate::print!("{}", character);
+                    crate::eldarin::handle_char(character);
+                }
+            }
         }
     }
 }

aethelos-source/heartwood/src/eldarin.rs

···
 /// Maximum command buffer size
 const BUFFER_SIZE: usize = 256;
 
+/// Maximum number of commands to store in history
+const HISTORY_SIZE: usize = 32;
+
 /// The Scroll Buffer - stores the command being typed
 pub struct CommandBuffer {
     buffer: [u8; BUFFER_SIZE],
     position: usize,
+}
+
+/// Command History - stores previous commands for recall
+pub struct CommandHistory {
+    /// Ring buffer of previous commands
+    commands: [[u8; BUFFER_SIZE]; HISTORY_SIZE],
+    /// Length of each command in the ring buffer
+    lengths: [usize; HISTORY_SIZE],
+    /// Current write position in ring buffer
+    write_pos: usize,
+    /// Current read position when navigating history
+    read_pos: usize,
+    /// Total number of commands in history (up to HISTORY_SIZE)
+    count: usize,
+    /// True if currently navigating history
+    navigating: bool,
 }
 
 impl CommandBuffer {
···
     pub fn is_empty(&self) -> bool {
         self.position == 0
     }
+
+    /// Set buffer contents from a byte slice
+    pub fn set_from_bytes(&mut self, bytes: &[u8]) {
+        self.clear();
+        let len = bytes.len().min(BUFFER_SIZE);
+        self.buffer[..len].copy_from_slice(&bytes[..len]);
+        self.position = len;
+    }
+}
+
+impl CommandHistory {
+    pub const fn new() -> Self {
+        CommandHistory {
+            commands: [[0; BUFFER_SIZE]; HISTORY_SIZE],
+            lengths: [0; HISTORY_SIZE],
+            write_pos: 0,
+            read_pos: 0,
+            count: 0,
+            navigating: false,
+        }
+    }
+
+    /// Add a command to history
+    pub fn add(&mut self, cmd: &str) {
+        if cmd.is_empty() {
+            return;
+        }
+
+        let bytes = cmd.as_bytes();
+        let len = bytes.len().min(BUFFER_SIZE);
+
+        self.commands[self.write_pos][..len].copy_from_slice(&bytes[..len]);
+        self.lengths[self.write_pos] = len;
+
+        self.write_pos = (self.write_pos + 1) % HISTORY_SIZE;
+        if self.count < HISTORY_SIZE {
+            self.count += 1;
+        }
+
+        // Reset navigation state
+        self.navigating = false;
+        self.read_pos = self.write_pos;
+    }
+
+    /// Navigate to previous command (up arrow)
+    /// Returns Some(command) if available, None if at the beginning
+    pub fn previous(&mut self) -> Option<&[u8]> {
+        if self.count == 0 {
+            return None;
+        }
+
+        if !self.navigating {
+            // First time navigating, start from most recent
+            self.navigating = true;
+            self.read_pos = if self.write_pos == 0 {
+                self.count - 1
+            } else {
+                self.write_pos - 1
+            };
+        } else {
+            // Already navigating, go back one more
+            if self.read_pos == 0 {
+                self.read_pos = self.count - 1;
+            } else {
+                self.read_pos -= 1;
+            }
+        }
+
+        let len = self.lengths[self.read_pos];
+        Some(&self.commands[self.read_pos][..len])
+    }
+
+    /// Navigate to next command (down arrow)
+    /// Returns Some(command) if available, None if at the end
+    pub fn next(&mut self) -> Option<&[u8]> {
+        if !self.navigating {
+            return None;
+        }
+
+        self.read_pos = (self.read_pos + 1) % self.count;
+
+        // If we're back at the write position, stop navigating (return to empty)
+        if self.read_pos == self.write_pos {
+            self.navigating = false;
+            return None;
+        }
+
+        let len = self.lengths[self.read_pos];
+        Some(&self.commands[self.read_pos][..len])
+    }
 }
 
 /// Global command buffer (interrupt-safe for keyboard input)
 static mut COMMAND_BUFFER: MaybeUninit<InterruptSafeLock<CommandBuffer>> = MaybeUninit::uninit();
 static mut BUFFER_INITIALIZED: bool = false;
 
+/// Global command history
+static mut COMMAND_HISTORY: MaybeUninit<InterruptSafeLock<CommandHistory>> = MaybeUninit::uninit();
+static mut HISTORY_INITIALIZED: bool = false;
+
 /// Initialize the shell
 pub fn init() {
     unsafe {
···
         let lock = InterruptSafeLock::new(buffer);
         core::ptr::write(COMMAND_BUFFER.as_mut_ptr(), lock);
         BUFFER_INITIALIZED = true;
+
+        let history = CommandHistory::new();
+        let history_lock = InterruptSafeLock::new(history);
+        core::ptr::write(COMMAND_HISTORY.as_mut_ptr(), history_lock);
+        HISTORY_INITIALIZED = true;
     }
 }
 
 /// Get reference to command buffer
 unsafe fn get_buffer() -> &'static InterruptSafeLock<CommandBuffer> {
     COMMAND_BUFFER.assume_init_ref()
+}
+
+/// Get reference to command history
+unsafe fn get_history() -> &'static InterruptSafeLock<CommandHistory> {
+    COMMAND_HISTORY.assume_init_ref()
 }
 
 /// Handle a character from keyboard input
···
     }
 }
 
+/// Handle backspace key - erase character visually and from buffer
+pub fn handle_backspace() {
+    unsafe {
+        if !BUFFER_INITIALIZED {
+            return;
+        }
+
+        let mut buffer = get_buffer().lock();
+        if buffer.pop() {
+            // Erase character visually (VGA driver handles the erasure)
+            crate::print!("\x08");
+        }
+    }
+}
+
+/// Handle up arrow - navigate to previous command in history
+pub fn handle_arrow_up() {
+    unsafe {
+        if !BUFFER_INITIALIZED || !HISTORY_INITIALIZED {
+            return;
+        }
+
+        let mut history = get_history().lock();
+        if let Some(cmd_bytes) = history.previous() {
+            let mut buffer = get_buffer().lock();
+            let current_len = buffer.as_str().len();
+
+            // Erase current line (VGA driver erases each character as we backspace)
+            for _ in 0..current_len {
+                crate::print!("\x08");
+            }
+
+            // Set buffer to historical command and display it
+            buffer.set_from_bytes(cmd_bytes);
+            if let Ok(cmd_str) = core::str::from_utf8(cmd_bytes) {
+                crate::print!("{}", cmd_str);
+            }
+        }
+    }
+}
+
+/// Handle down arrow - navigate to next command in history
+pub fn handle_arrow_down() {
+    unsafe {
+        if !BUFFER_INITIALIZED || !HISTORY_INITIALIZED {
+            return;
+        }
+
+        let mut history = get_history().lock();
+        let mut buffer = get_buffer().lock();
+        let current_len = buffer.as_str().len();
+
+        // Erase current line (VGA driver erases each character as we backspace)
+        for _ in 0..current_len {
+            crate::print!("\x08");
+        }
+
+        if let Some(cmd_bytes) = history.next() {
+            // Set buffer to next historical command and display it
+            buffer.set_from_bytes(cmd_bytes);
+            if let Ok(cmd_str) = core::str::from_utf8(cmd_bytes) {
+                crate::print!("{}", cmd_str);
+            }
+        } else {
+            // At the end of history, clear buffer
+            buffer.clear();
+        }
+    }
+}
+
 /// Check for pending commands and execute them (call from shell thread)
 pub fn poll() {
     unsafe {
···
                 buffer.clear();
             }
 
-            // Execute command
+            // Execute command and save to history
             if cmd_len > 0 {
                 if let Ok(cmd_str) = core::str::from_utf8(&cmd_copy[..cmd_len]) {
+                    // Save to history before executing
+                    if HISTORY_INITIALIZED {
+                        let mut history = get_history().lock();
+                        history.add(cmd_str);
+                    }
+
                     execute_command(cmd_str);
                 }
             }

aethelos-source/heartwood/src/vga_buffer.rs

···
     pub fn write_byte(&mut self, byte: u8) {
         match byte {
             b'\n' => self.new_line(),
+            b'\x08' => {
+                // Backspace: move cursor back and erase character
+                if self.column_position > 0 {
+                    self.column_position -= 1;
+                    let row = self.row_position;
+                    let col = self.column_position;
+
+                    // Write a space to erase the character
+                    unsafe {
+                        core::ptr::write_volatile(
+                            &mut self.buffer.chars[row][col] as *mut ScreenChar,
+                            ScreenChar {
+                                ascii_character: b' ',
+                                color_code: self.color_code,
+                            }
+                        );
+                    }
+
+                    move_cursor(self.row_position, self.column_position);
+                }
+            }
             byte => {
                 if self.column_position >= BUFFER_WIDTH {
                     self.new_line();
···
         }
         for byte in s.bytes() {
             match byte {
-                0x20..=0x7e | b'\n' => self.write_byte(byte),
+                0x20..=0x7e | b'\n' | b'\x08' => self.write_byte(byte),
                 _ => self.write_byte(0xfe), // ■ for unprintable
             }
         }