feat: Added persistent history

closes: #46

Signed-off-by: Vaibhav Sapate <sapatevaibhav96@gmail.com>

Author: sapatevaibhav

README.md

@@ -15,6 +15,7 @@ A cross-platform, AI-powered terminal assistant with custom commands, local API
 - Terminal-like UI with command history and autocompletion
 - AI-powered responses for natural language queries
 - Custom shell command execution (with sudo/password support)
+- **Built-in text editors: nano and vim with full modal editing support**
 - Secure local storage for API keys
 - Cross-platform: Linux, Windows, macOS (experimental)
 - Colorful output and user-friendly design

TODO

@@ -11,14 +11,18 @@ SCRAPED: change command to change the API key # Scraped as we have new settings
 DONE: Add support to various AI models like gemini, groq, etc
 DONE: add markdown support
 DONE: clickable links
+DONE: Add support for nano/vim
+DONE: Persistent command history (saved to ~/.term_history)
+
+TODO:
 add proper updates to the command like sync/update (for progress)
-handle nano/vim
 write tests for each of above
-Persistent history
 API key in build
 change model to change the model
 A faster sudo command
 focus on infutfield in password field each time and after closing on terminal
 minimal ls command output
-Implement context
+Implement context (history knowledge)
+Update Welcome screen when there isn't any API key set
+Implement landing page with onboarding
 handle failing commands

src-tauri/src/commands/history.rs

@@ -0,0 +1,67 @@
+use std::fs;
+use std::path::PathBuf;
+
+fn get_history_file_path() -> Result<PathBuf, String> {
+    let home_dir = dirs::home_dir()
+        .ok_or_else(|| "Failed to get home directory".to_string())?;
+    
+    Ok(home_dir.join(".term_history"))
+}
+
+#[tauri::command]
+pub fn save_command_to_history(command: String) -> Result<(), String> {
+    let history_file = get_history_file_path()?;
+    
+    // Read existing history
+    let mut history = if history_file.exists() {
+        fs::read_to_string(&history_file)
+            .map_err(|e| format!("Failed to read history file: {}", e))?
+    } else {
+        String::new()
+    };
+    
+    // Append new command with newline
+    if !history.is_empty() && !history.ends_with('\n') {
+        history.push('\n');
+    }
+    history.push_str(&command);
+    history.push('\n');
+    
+    // Write back to file
+    fs::write(&history_file, history)
+        .map_err(|e| format!("Failed to write history file: {}", e))?;
+    
+    Ok(())
+}
+
+#[tauri::command]
+pub fn load_command_history() -> Result<Vec<String>, String> {
+    let history_file = get_history_file_path()?;
+    
+    if !history_file.exists() {
+        return Ok(Vec::new());
+    }
+    
+    let content = fs::read_to_string(&history_file)
+        .map_err(|e| format!("Failed to read history file: {}", e))?;
+    
+    let history: Vec<String> = content
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .map(|line| line.to_string())
+        .collect();
+    
+    Ok(history)
+}
+
+#[tauri::command]
+pub fn clear_command_history() -> Result<(), String> {
+    let history_file = get_history_file_path()?;
+    
+    if history_file.exists() {
+        fs::remove_file(&history_file)
+            .map_err(|e| format!("Failed to clear history file: {}", e))?;
+    }
+    
+    Ok(())
+}

src-tauri/src/commands/mod.rs

@@ -1,11 +1,13 @@
 pub mod ai;
 pub mod api_key;
-mod files;
+pub mod files;
+pub mod history;
 pub mod settings;
 pub mod shell;
 
 pub use ai::*;
 pub use api_key::*;
 pub use files::*;
+pub use history::*;
 pub use settings::*;
 pub use shell::*;

src-tauri/src/main.rs

@@ -16,6 +16,10 @@ fn main() {
             commands::shell::change_directory,
             commands::shell::read_file_for_editor,
             commands::shell::write_file_from_editor,
+            commands::history::save_command_to_history,
+            commands::history::load_command_history,
+            commands::history::clear_command_history,
+            commands::files::read_file,
             commands::ai::ask_llm,
             commands::api_key::save_api_key,
             commands::api_key::get_api_key,

src/hooks/useCommandHistory.tsx

@@ -1,12 +1,38 @@
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
+import { invoke } from '@tauri-apps/api/core';
 
 const useCommandHistory = () => {
     const [commandHistory, setCommandHistory] = useState<string[]>([]);
     const [historyIndex, setHistoryIndex] = useState(-1);
+    const [isLoaded, setIsLoaded] = useState(false);
 
-    const addToHistory = (command: string) => {
+    // Load history from file on mount
+    useEffect(() => {
+        const loadHistory = async () => {
+            try {
+                const history = await invoke<string[]>('load_command_history');
+                setCommandHistory(history);
+                setIsLoaded(true);
+            } catch (error) {
+                console.error('Failed to load command history:', error);
+                setIsLoaded(true);
+            }
+        };
+
+        loadHistory();
+    }, []);
+
+    const addToHistory = async (command: string) => {
+        // Add to local state
         setCommandHistory(prev => [...prev, command]);
         setHistoryIndex(-1);
+
+        // Save to file
+        try {
+            await invoke('save_command_to_history', { command });
+        } catch (error) {
+            console.error('Failed to save command to history:', error);
+        }
     };
 
     const navigateHistory = (direction: 'up' | 'down'): string | undefined => {
@@ -29,11 +55,24 @@ const useCommandHistory = () => {
         return undefined;
     };
 
+    const clearHistory = async () => {
+        setCommandHistory([]);
+        setHistoryIndex(-1);
+
+        try {
+            await invoke('clear_command_history');
+        } catch (error) {
+            console.error('Failed to clear command history:', error);
+        }
+    };
+
     return {
         commandHistory,
         historyIndex,
+        isLoaded,
         addToHistory,
-        navigateHistory
+        navigateHistory,
+        clearHistory
     };
 };
 

src/utils/intentParser.ts

@@ -8,15 +8,18 @@ export type Intent =
 export function parseInput(input: string): Intent {
     const trimmed = input.trim();
 
-    // File viewing: "cat abc.txt", "view abc.txt"
-    if (/^(view|show|cat)\s+[\w./-]+\.txt$/i.test(trimmed)) {
-        const filename = trimmed.split(' ').pop()!;
-        return { type: 'file_view', filename };
+    // File viewing: "cat abc.txt", "view abc.txt", "cat filename"
+    if (/^(view|show|cat)\s+[\w./-]+/i.test(trimmed)) {
+        const parts = trimmed.split(/\s+/);
+        if (parts.length >= 2) {
+            const filename = parts.slice(1).join(' ');
+            return { type: 'file_view', filename };
+        }
     }
 
     // File summary: "summarize abc.txt", "give summary of abc.txt"
-    if (/summar(y|ise|ize).+\.txt/i.test(trimmed)) {
-        const match = trimmed.match(/(?:of|about|on)\s+([\w./-]+\.txt)/i);
+    if (/summar(y|ise|ize).+/i.test(trimmed)) {
+        const match = trimmed.match(/(?:of|about|on)\s+([\w./-]+)/i);
         if (match) return { type: 'file_summary', filename: match[1] };
     }