feat: integrate LLM-based suggestions into TUI

- Added support for LLM-based suggestions using the Qwen2 model.
- Updated `Cargo.toml` to include necessary dependencies for LLM functionality.
- Modified `App` struct to include ensemble for multi-model suggestions.
- Enhanced `run_tui` and `run_tui_loop` functions to handle LLM configuration.
- Implemented LLM model loading and suggestion generation in a new `llm.rs` module.
- Updated SQLite schema to support command execution history.
- Added command hashing and persistence logic for improved history tracking.

Author: trknhr

rust/Cargo.lock

@@ -8,6 +8,7 @@ libsql-client = "0.33.4"
 libsql = "0.9.24"
 tokio = { version = "1", features = ["full"] }
 anyhow = "1"
+llama-cpp-2 = "0.1.124"   
 
 clap = { version = "4", features = ["derive"] }
 fuzzy-matcher = "0.3"
@@ -22,3 +23,9 @@ log = "0.4"
 env_logger = "0.11"
 sha2 = "0.10"
 hex = "0.4"
+# LLM inference with candle - using git to avoid rand version conflicts
+candle-core = { git = "https://github.com/huggingface/candle.git", features = ["accelerate"] }
+candle-transformers = { git = "https://github.com/huggingface/candle.git" }
+candle-nn = { git = "https://github.com/huggingface/candle.git" }
+tokenizers = "0.20"
+hf-hub = "0.3"

rust/Cargo.toml

@@ -3,17 +3,21 @@ use anyhow::{bail, Context, Result};
 use directories::UserDirs;
 use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
+use hex::encode;
 use libsql::Value;
 use once_cell::sync::Lazy;
 use ratatui::layout::Rect;
+use sha2::{Digest, Sha256};
 use std::cmp::Ordering;
 use std::fs::File;
 use std::io::Read;
 use std::path::{Path, PathBuf};
 
 use crate::model::{
-    AliasModel, EnsembleBuilder, FreqModel, PrefixModel, SqlitePool, SuggestModel, Suggestion,
+    AliasModel, EnsembleBuilder, FreqModel, LlmConfig, LlmModel, LlmWhich, PrefixModel,
+    SqlitePool, SuggestModel, Suggestion,
 };
+use crate::model::ensemble::Ensemble;
 
 static MATCHER: Lazy<SkimMatcherV2> = Lazy::new(SkimMatcherV2::default);
 /// Run the fuzzy search over one or more history files
@@ -95,20 +99,54 @@ pub struct App {
     pub output_scroll: u16,        // scroll offset for main tab output
     pub history_scroll: u16,       // scroll offset for history tab output
 
-    // corpus
+    // corpus (legacy fuzzy matching)
     pub corpus: Vec<String>,
+
+    // ensemble for multi-model suggestions
+    pub ensemble: Ensemble,
 }
 
 impl App {
-    pub fn new(corpus: Vec<String>, top: usize, db: Option<SqlitePool>) -> Self {
+    pub fn new(
+        corpus: Vec<String>,
+        top: usize,
+        db: Option<SqlitePool>,
+        enable_llm: bool,
+        llm_model: Option<PathBuf>,
+        llm_which: String,
+    ) -> Result<Self> {
         // Load recent history from database
         let history = if let Some(ref pool) = db {
             load_recent_history(pool, 100).unwrap_or_default()
         } else {
             Vec::new()
         };
 
-        Self {
+        // Build ensemble with all suggestion models
+        let mut builder = EnsembleBuilder::new().with_light_model(FuzzyHistoryModel::new(corpus.clone()));
+
+        // Add database-backed models if available
+        if let Some(ref pool) = db {
+            builder = builder
+                .with_light_model(PrefixModel::new(pool.clone()))
+                .with_light_model(FreqModel::new(pool.clone()))
+                .with_light_model(AliasModel::with_sql_store(pool.clone()));
+        }
+
+        // Add LLM model if enabled
+        if enable_llm {
+            let which = LlmWhich::from_str(&llm_which).unwrap_or(LlmWhich::W0_5b);
+            let llm_config = LlmConfig {
+                model_path: llm_model,
+                which,
+                ..Default::default()
+            };
+            builder = builder.with_light_model(LlmModel::new(llm_config));
+        }
+
+        let ensemble = builder.build();
+
+        Ok(Self {
             input: String::new(),
             cursor: 0,
             suggestions: Vec::new(),
@@ -127,7 +165,8 @@ impl App {
             output_scroll: 0,
             history_scroll: 0,
             corpus,
-        }
+            ensemble,
+        })
     }
 
     pub fn refresh_suggestions(&mut self) {
@@ -136,19 +175,38 @@ impl App {
             self.selected = 0;
             return;
         }
+
         let query = self.input.as_str();
-        let mut scored: Vec<(i64, String)> = Vec::new();
-        for line in self.corpus.iter() {
-            if let Some(score) = MATCHER.fuzzy_match(line, query) {
-                scored.push((score, line.clone()));
+
+        // Use ensemble for multi-model suggestions
+        match self.ensemble.predict(query) {
+            Ok(suggestions) => {
+                self.suggestions = suggestions
+                    .into_iter()
+                    .take(self.max_suggestions)
+                    .map(|s| s.text)
+                    .collect();
+            }
+            Err(e) => {
+                // Fallback to simple fuzzy matching if ensemble fails
+                use log::warn;
+                warn!("Ensemble prediction failed: {}. Falling back to fuzzy matching.", e);
+
+                let mut scored: Vec<(i64, String)> = Vec::new();
+                for line in self.corpus.iter() {
+                    if let Some(score) = MATCHER.fuzzy_match(line, query) {
+                        scored.push((score, line.clone()));
+                    }
+                }
+                scored.sort_by(|a, b| b.0.cmp(&a.0));
+                self.suggestions = scored
+                    .into_iter()
+                    .take(self.max_suggestions)
+                    .map(|(_, s)| s)
+                    .collect();
             }
         }
-        scored.sort_by(|a, b| b.0.cmp(&a.0));
-        self.suggestions = scored
-            .into_iter()
-            .take(self.max_suggestions)
-            .map(|(_, s)| s)
-            .collect();
+
         self.selected = self.selected.min(self.suggestions.len().saturating_sub(1));
     }
 
@@ -197,7 +255,7 @@ pub fn read_history_file(path: &Path) -> Result<Vec<String>> {
 
 fn load_recent_history(pool: &SqlitePool, limit: usize) -> Result<Vec<HistoryEntry>> {
     pool.query_collect(
-        "SELECT command, output FROM history ORDER BY id DESC LIMIT ?1",
+        "SELECT command, output FROM command_executions ORDER BY executed_at DESC LIMIT ?1",
         vec![Value::Integer(limit as i64)],
         |row| {
             let command: String = row.get(0)?;
@@ -216,6 +274,82 @@ fn load_recent_history(pool: &SqlitePool, limit: usize) -> Result<Vec<HistoryEnt
     )
 }
 
+fn hash_command(command: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(command.as_bytes());
+    encode(hasher.finalize())
+}
+
+pub fn persist_command_to_history(pool: &SqlitePool, command: &str, session_id: &str) -> Result<()> {
+    let trimmed = command.trim();
+    if trimmed.is_empty() {
+        return Ok(());
+    }
+
+    let hash = hash_command(trimmed);
+
+    // Update history table (for frequency counting)
+    pool.execute(
+        r#"
+        INSERT INTO history (command, hash, count, source, output)
+        VALUES (?1, ?2, 1, 'tui', '')
+        ON CONFLICT(hash) DO UPDATE SET
+            count = count + 1,
+            source = 'tui',
+            created_at = CURRENT_TIMESTAMP;
+    "#,
+        vec![
+            Value::Text(trimmed.to_string()),
+            Value::Text(hash),
+        ],
+    )?;
+
+    // Insert into command_executions (for full history with output)
+    pool.execute(
+        r#"
+        INSERT INTO command_executions (command, output, session_id, executed_at)
+        VALUES (?1, '', ?2, CURRENT_TIMESTAMP);
+    "#,
+        vec![
+            Value::Text(trimmed.to_string()),
+            Value::Text(session_id.to_string()),
+        ],
+    )?;
+
+    Ok(())
+}
+
+pub fn import_shell_history_to_db(pool: &SqlitePool, files: &[PathBuf]) -> Result<()> {
+    let lines = load_history_lines(files.to_vec(), true)?; // unique=true to avoid duplicates in memory
+
+    for command in lines {
+        let trimmed = command.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+
+        let hash = hash_command(trimmed);
+
+        // Insert into history table with source='shell'
+        // On conflict, just increment count (don't change source from 'tui' to 'shell')
+        pool.execute(
+            r#"
+            INSERT INTO history (command, hash, count, source, output)
+            VALUES (?1, ?2, 1, 'shell', '')
+            ON CONFLICT(hash) DO UPDATE SET
+                count = count + 1,
+                created_at = CURRENT_TIMESTAMP;
+        "#,
+            vec![
+                Value::Text(trimmed.to_string()),
+                Value::Text(hash),
+            ],
+        ).ok(); // Ignore errors for individual commands
+    }
+
+    Ok(())
+}
+
 #[derive(Debug)]
 struct FuzzyHistoryModel {
     corpus: Vec<String>,

rust/src/core.rs

@@ -32,6 +32,18 @@ enum Cmd {
         /// Remove duplicate lines
         #[arg(long, default_value_t = true)]
         unique: bool,
+
+        /// Enable LLM-based suggestions
+        #[arg(long, default_value_t = false)]
+        enable_llm: bool,
+
+        /// Path to GGUF model file (optional, downloads from HF if not provided)
+        #[arg(long)]
+        llm_model: Option<PathBuf>,
+
+        /// LLM model variant (0.5b, 1.5b, 7b)
+        #[arg(long, default_value = "0.5b")]
+        llm_which: String,
     },
 
     /// Non-TUI fuzzy search (existing behavior)
@@ -51,7 +63,14 @@ fn main() -> Result<()> {
     let _ = env_logger::Builder::from_env(Env::default().default_filter_or("info")).try_init();
     let cli = Cli::parse();
     match cli.cmd {
-        Some(Cmd::Tui { files, top, unique }) => tui::run_tui_loop(files, top, unique),
+        Some(Cmd::Tui {
+            files,
+            top,
+            unique,
+            enable_llm,
+            llm_model,
+            llm_which,
+        }) => tui::run_tui_loop(files, top, unique, enable_llm, llm_model, llm_which),
         Some(Cmd::Search {
             files,
             query,