1194 lines
42 KiB
Rust
1194 lines
42 KiB
Rust
use crate::api::{ApiClient, RecallRequest, ReflectRequest};
|
|
use anyhow::Result;
|
|
use crossterm::{
|
|
event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
|
|
execute,
|
|
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
use hindsight_client::types::{BankListItem, RecallResult, EntityListItem, Budget};
|
|
use serde_json::{Map, Value};
|
|
use ratatui::{
|
|
backend::{Backend, CrosstermBackend},
|
|
layout::{Alignment, Constraint, Direction, Layout, Rect},
|
|
style::{Color, Modifier, Style},
|
|
text::{Line, Span},
|
|
widgets::{Block, Borders, List, ListItem, ListState, Paragraph, Wrap},
|
|
Frame, Terminal,
|
|
};
|
|
use std::io;
|
|
use std::time::{Duration, Instant};
|
|
|
|
/// Main view types (like k9s contexts)
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
enum View {
|
|
Banks,
|
|
Memories(String), // bank_id
|
|
Entities(String), // bank_id
|
|
Documents(String), // bank_id
|
|
Recall(String), // bank_id
|
|
Reflect(String), // bank_id
|
|
}
|
|
|
|
impl View {
|
|
fn title(&self) -> &str {
|
|
match self {
|
|
View::Banks => "Banks",
|
|
View::Memories(_) => "Memories",
|
|
View::Entities(_) => "Entities",
|
|
View::Documents(_) => "Documents",
|
|
View::Recall(_) => "Recall",
|
|
View::Reflect(_) => "Reflect",
|
|
}
|
|
}
|
|
|
|
fn bank_id(&self) -> Option<&str> {
|
|
match self {
|
|
View::Banks => None,
|
|
View::Memories(id) | View::Entities(id) | View::Documents(id) | View::Recall(id) | View::Reflect(id) => Some(id),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Input mode for recall/reflect queries
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
enum InputMode {
|
|
Normal,
|
|
Query,
|
|
}
|
|
|
|
/// Application state
|
|
struct App {
|
|
client: ApiClient,
|
|
view: View,
|
|
view_history: Vec<View>,
|
|
|
|
// List states
|
|
banks: Vec<BankListItem>,
|
|
banks_state: ListState,
|
|
|
|
memories: Vec<Map<String, Value>>,
|
|
memories_state: ListState,
|
|
|
|
entities: Vec<EntityListItem>,
|
|
entities_state: ListState,
|
|
|
|
documents: Vec<Map<String, Value>>,
|
|
documents_state: ListState,
|
|
viewing_document: Option<Map<String, Value>>,
|
|
|
|
// Recall state
|
|
recall_query: String,
|
|
recall_results: Vec<RecallResult>,
|
|
recall_results_state: ListState,
|
|
|
|
// Reflect state
|
|
reflect_query: String,
|
|
reflect_response: String,
|
|
|
|
// Input mode
|
|
input_mode: InputMode,
|
|
|
|
// Status messages
|
|
status_message: String,
|
|
error_message: String,
|
|
|
|
// Help visibility
|
|
show_help: bool,
|
|
|
|
// Loading state
|
|
loading: bool,
|
|
|
|
// Auto-refresh
|
|
auto_refresh_enabled: bool,
|
|
last_refresh: Instant,
|
|
refresh_interval: Duration,
|
|
}
|
|
|
|
impl App {
|
|
fn new(client: ApiClient) -> Self {
|
|
let mut app = Self {
|
|
client,
|
|
view: View::Banks,
|
|
view_history: Vec::new(),
|
|
|
|
banks: Vec::new(),
|
|
banks_state: ListState::default(),
|
|
|
|
memories: Vec::new(),
|
|
memories_state: ListState::default(),
|
|
|
|
entities: Vec::new(),
|
|
entities_state: ListState::default(),
|
|
|
|
documents: Vec::new(),
|
|
documents_state: ListState::default(),
|
|
viewing_document: None,
|
|
|
|
recall_query: String::new(),
|
|
recall_results: Vec::new(),
|
|
recall_results_state: ListState::default(),
|
|
|
|
reflect_query: String::new(),
|
|
reflect_response: String::new(),
|
|
|
|
input_mode: InputMode::Normal,
|
|
status_message: String::from("Press ? for help"),
|
|
error_message: String::new(),
|
|
show_help: false,
|
|
loading: false,
|
|
|
|
auto_refresh_enabled: true,
|
|
last_refresh: Instant::now(),
|
|
refresh_interval: Duration::from_secs(5),
|
|
};
|
|
|
|
// Select first item by default
|
|
app.banks_state.select(Some(0));
|
|
app.memories_state.select(Some(0));
|
|
app.entities_state.select(Some(0));
|
|
app.recall_results_state.select(Some(0));
|
|
|
|
app
|
|
}
|
|
|
|
fn refresh(&mut self) -> Result<()> {
|
|
self.loading = true;
|
|
self.error_message.clear();
|
|
|
|
let result = match self.view.clone() {
|
|
View::Banks => self.load_banks(),
|
|
View::Memories(bank_id) => self.load_memories(&bank_id),
|
|
View::Entities(bank_id) => self.load_entities(&bank_id),
|
|
View::Documents(bank_id) => self.load_documents(&bank_id),
|
|
View::Recall(_) => Ok(()), // Recall is query-driven
|
|
View::Reflect(_) => Ok(()), // Reflect is query-driven
|
|
};
|
|
|
|
self.loading = false;
|
|
|
|
if let Err(e) = result {
|
|
self.error_message = format!("Error: {}", e);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn toggle_auto_refresh(&mut self) {
|
|
self.auto_refresh_enabled = !self.auto_refresh_enabled;
|
|
if self.auto_refresh_enabled {
|
|
self.status_message = "Auto-refresh enabled (5s)".to_string();
|
|
self.last_refresh = Instant::now();
|
|
} else {
|
|
self.status_message = "Auto-refresh disabled".to_string();
|
|
}
|
|
}
|
|
|
|
fn should_refresh(&self) -> bool {
|
|
self.auto_refresh_enabled && self.last_refresh.elapsed() >= self.refresh_interval
|
|
}
|
|
|
|
fn do_auto_refresh(&mut self) -> Result<()> {
|
|
if self.should_refresh() {
|
|
self.last_refresh = Instant::now();
|
|
self.refresh()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn load_banks(&mut self) -> Result<()> {
|
|
self.banks = self.client.list_agents(false)?;
|
|
|
|
if !self.banks.is_empty() && self.banks_state.selected().is_none() {
|
|
self.banks_state.select(Some(0));
|
|
}
|
|
|
|
self.status_message = format!("Loaded {} banks", self.banks.len());
|
|
Ok(())
|
|
}
|
|
|
|
fn load_memories(&mut self, bank_id: &str) -> Result<()> {
|
|
let response = self.client.list_memories(bank_id, None, None, Some(100), Some(0), false)?;
|
|
self.memories = response.items;
|
|
|
|
if !self.memories.is_empty() && self.memories_state.selected().is_none() {
|
|
self.memories_state.select(Some(0));
|
|
}
|
|
|
|
self.status_message = format!("Loaded {} memories", self.memories.len());
|
|
Ok(())
|
|
}
|
|
|
|
fn load_entities(&mut self, bank_id: &str) -> Result<()> {
|
|
let response = self.client.list_entities(bank_id, Some(100), false)?;
|
|
self.entities = response.entities;
|
|
|
|
if !self.entities.is_empty() && self.entities_state.selected().is_none() {
|
|
self.entities_state.select(Some(0));
|
|
}
|
|
|
|
self.status_message = format!("Loaded {} entities", self.entities.len());
|
|
Ok(())
|
|
}
|
|
|
|
fn load_documents(&mut self, bank_id: &str) -> Result<()> {
|
|
let response = self.client.list_documents(bank_id, None, Some(100), Some(0), false)?;
|
|
self.documents = response.items;
|
|
|
|
if !self.documents.is_empty() && self.documents_state.selected().is_none() {
|
|
self.documents_state.select(Some(0));
|
|
}
|
|
|
|
self.status_message = format!("Loaded {} documents", self.documents.len());
|
|
Ok(())
|
|
}
|
|
|
|
fn execute_recall(&mut self) -> Result<()> {
|
|
if let View::Recall(bank_id) = &self.view {
|
|
if self.recall_query.is_empty() {
|
|
self.error_message = "Query cannot be empty".to_string();
|
|
return Ok(());
|
|
}
|
|
|
|
self.loading = true;
|
|
self.error_message.clear();
|
|
|
|
let request = RecallRequest {
|
|
query: self.recall_query.clone(),
|
|
types: None,
|
|
budget: Some(Budget::Mid),
|
|
max_tokens: 4096,
|
|
trace: false,
|
|
query_timestamp: None,
|
|
filters: None,
|
|
include: None,
|
|
};
|
|
|
|
let response = self.client.recall(bank_id, &request, false)?;
|
|
self.recall_results = response.results;
|
|
|
|
if !self.recall_results.is_empty() {
|
|
self.recall_results_state.select(Some(0));
|
|
}
|
|
|
|
self.loading = false;
|
|
self.status_message = format!("Found {} results", self.recall_results.len());
|
|
self.input_mode = InputMode::Normal;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn execute_reflect(&mut self) -> Result<()> {
|
|
if let View::Reflect(bank_id) = &self.view {
|
|
if self.reflect_query.is_empty() {
|
|
self.error_message = "Query cannot be empty".to_string();
|
|
return Ok(());
|
|
}
|
|
|
|
self.loading = true;
|
|
self.error_message.clear();
|
|
|
|
let request = ReflectRequest {
|
|
query: self.reflect_query.clone(),
|
|
budget: Some(Budget::Mid),
|
|
context: None,
|
|
filters: None,
|
|
include: None,
|
|
};
|
|
|
|
let response = self.client.reflect(bank_id, &request, false)?;
|
|
self.reflect_response = response.text;
|
|
|
|
self.loading = false;
|
|
self.status_message = "Reflection complete".to_string();
|
|
self.input_mode = InputMode::Normal;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn next_item(&mut self) {
|
|
match &self.view {
|
|
View::Banks => {
|
|
let i = match self.banks_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.banks.len().saturating_sub(1) {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.banks_state.select(Some(i));
|
|
}
|
|
View::Memories(_) => {
|
|
let i = match self.memories_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.memories.len().saturating_sub(1) {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.memories_state.select(Some(i));
|
|
}
|
|
View::Entities(_) => {
|
|
let i = match self.entities_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.entities.len().saturating_sub(1) {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.entities_state.select(Some(i));
|
|
}
|
|
View::Documents(_) => {
|
|
let i = match self.documents_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.documents.len().saturating_sub(1) {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.documents_state.select(Some(i));
|
|
}
|
|
View::Recall(_) => {
|
|
let i = match self.recall_results_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.recall_results.len().saturating_sub(1) {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.recall_results_state.select(Some(i));
|
|
}
|
|
View::Reflect(_) => {} // No list to navigate
|
|
}
|
|
}
|
|
|
|
fn previous_item(&mut self) {
|
|
match &self.view {
|
|
View::Banks => {
|
|
let i = match self.banks_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.banks.len().saturating_sub(1)
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.banks_state.select(Some(i));
|
|
}
|
|
View::Memories(_) => {
|
|
let i = match self.memories_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.memories.len().saturating_sub(1)
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.memories_state.select(Some(i));
|
|
}
|
|
View::Entities(_) => {
|
|
let i = match self.entities_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.entities.len().saturating_sub(1)
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.entities_state.select(Some(i));
|
|
}
|
|
View::Documents(_) => {
|
|
let i = match self.documents_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.documents.len().saturating_sub(1)
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.documents_state.select(Some(i));
|
|
}
|
|
View::Recall(_) => {
|
|
let i = match self.recall_results_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.recall_results.len().saturating_sub(1)
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.recall_results_state.select(Some(i));
|
|
}
|
|
View::Reflect(_) => {} // No list to navigate
|
|
}
|
|
}
|
|
|
|
fn enter_view(&mut self) -> Result<()> {
|
|
match &self.view {
|
|
View::Banks => {
|
|
if let Some(i) = self.banks_state.selected() {
|
|
if let Some(bank) = self.banks.get(i) {
|
|
let bank_id = bank.bank_id.clone();
|
|
self.view_history.push(self.view.clone());
|
|
self.view = View::Memories(bank_id.clone());
|
|
self.load_memories(&bank_id)?;
|
|
}
|
|
}
|
|
}
|
|
View::Documents(bank_id) => {
|
|
if let Some(i) = self.documents_state.selected() {
|
|
if let Some(doc) = self.documents.get(i) {
|
|
// Fetch full document content
|
|
let doc_id = doc.get("id")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("");
|
|
|
|
if !doc_id.is_empty() {
|
|
match self.client.get_document(bank_id, doc_id, false) {
|
|
Ok(full_doc) => {
|
|
// Convert to Map for display
|
|
let doc_map: Map<String, Value> = serde_json::from_value(
|
|
serde_json::to_value(full_doc)?
|
|
)?;
|
|
self.viewing_document = Some(doc_map);
|
|
self.status_message = format!("Viewing document: {}", doc_id);
|
|
}
|
|
Err(e) => {
|
|
self.error_message = format!("Failed to load document: {}", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn go_back(&mut self) {
|
|
// If viewing a document, close it first
|
|
if self.viewing_document.is_some() {
|
|
self.viewing_document = None;
|
|
self.status_message = "Closed document view".to_string();
|
|
return;
|
|
}
|
|
|
|
// Otherwise go back to previous view
|
|
if let Some(prev_view) = self.view_history.pop() {
|
|
self.view = prev_view;
|
|
let _ = self.refresh();
|
|
}
|
|
}
|
|
|
|
fn switch_to_view(&mut self, new_view: View) -> Result<()> {
|
|
if self.view != new_view {
|
|
self.view_history.push(self.view.clone());
|
|
self.view = new_view;
|
|
self.refresh()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn delete_selected_document(&mut self) -> Result<()> {
|
|
if let View::Documents(bank_id) = &self.view {
|
|
if let Some(i) = self.documents_state.selected() {
|
|
if let Some(doc) = self.documents.get(i) {
|
|
let doc_id = doc.get("id")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("");
|
|
|
|
if !doc_id.is_empty() {
|
|
match self.client.delete_document(bank_id, doc_id, false) {
|
|
Ok(_) => {
|
|
self.status_message = format!("Deleted document: {}", doc_id);
|
|
self.refresh()?;
|
|
}
|
|
Err(e) => {
|
|
self.error_message = format!("Failed to delete document: {}", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn ui(f: &mut Frame, app: &mut App) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(5), // Shortcuts bar (context + shortcuts, max 3 rows + 2 border)
|
|
Constraint::Length(3), // Header
|
|
Constraint::Min(0), // Main content
|
|
Constraint::Length(1), // Footer/status only (no border)
|
|
])
|
|
.split(f.area());
|
|
|
|
// Control bar
|
|
render_control_bar(f, app, chunks[0]);
|
|
|
|
// Header
|
|
render_header(f, app, chunks[1]);
|
|
|
|
// Main content
|
|
if app.show_help {
|
|
render_help(f, chunks[2]);
|
|
} else {
|
|
match &app.view {
|
|
View::Banks => render_banks(f, app, chunks[2]),
|
|
View::Memories(_) => render_memories(f, app, chunks[2]),
|
|
View::Entities(_) => render_entities(f, app, chunks[2]),
|
|
View::Documents(_) => render_documents(f, app, chunks[2]),
|
|
View::Recall(_) => render_recall(f, app, chunks[2]),
|
|
View::Reflect(_) => render_reflect(f, app, chunks[2]),
|
|
}
|
|
}
|
|
|
|
// Footer
|
|
render_footer(f, app, chunks[3]);
|
|
}
|
|
|
|
fn render_control_bar(f: &mut Frame, app: &App, area: Rect) {
|
|
// Build contextual shortcuts based on view and input mode
|
|
let shortcuts = match (&app.view, &app.input_mode) {
|
|
(View::Banks, InputMode::Normal) => vec![
|
|
("Enter", "Select", Color::Cyan),
|
|
("m", "Mem", Color::Green),
|
|
("e", "Ent", Color::Green),
|
|
("d", "Docs", Color::Green),
|
|
("R", "Refresh", Color::Yellow),
|
|
("a", if app.auto_refresh_enabled { "Auto" } else { "Auto" },
|
|
if app.auto_refresh_enabled { Color::Green } else { Color::DarkGray }),
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
(View::Memories(_), InputMode::Normal) => vec![
|
|
("Enter", "View", Color::Cyan),
|
|
("Esc", "Back", Color::Yellow),
|
|
("r", "Recall", Color::Green),
|
|
("t", "Reflect", Color::Green),
|
|
("R", "Refresh", Color::Yellow),
|
|
("a", if app.auto_refresh_enabled { "Auto" } else { "Auto" },
|
|
if app.auto_refresh_enabled { Color::Green } else { Color::DarkGray }),
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
(View::Entities(_), InputMode::Normal) => vec![
|
|
("Enter", "View", Color::Cyan),
|
|
("Esc", "Back", Color::Yellow),
|
|
("R", "Refresh", Color::Yellow),
|
|
("a", if app.auto_refresh_enabled { "Auto" } else { "Auto" },
|
|
if app.auto_refresh_enabled { Color::Green } else { Color::DarkGray }),
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
(View::Documents(_), InputMode::Normal) => vec![
|
|
("Enter", "View", Color::Cyan),
|
|
("Del", "Delete", Color::Red),
|
|
("Esc", "Back", Color::Yellow),
|
|
("R", "Refresh", Color::Yellow),
|
|
("a", if app.auto_refresh_enabled { "Auto" } else { "Auto" },
|
|
if app.auto_refresh_enabled { Color::Green } else { Color::DarkGray }),
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
(View::Recall(_), InputMode::Normal) => vec![
|
|
("/", "Query", Color::Green),
|
|
("Esc", "Back", Color::Yellow),
|
|
("R", "Refresh", Color::Yellow),
|
|
("a", if app.auto_refresh_enabled { "Auto" } else { "Auto" },
|
|
if app.auto_refresh_enabled { Color::Green } else { Color::DarkGray }),
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
(View::Recall(_), InputMode::Query) => vec![
|
|
("Enter", "Search", Color::Green),
|
|
("Esc", "Cancel", Color::Red),
|
|
],
|
|
(View::Reflect(_), InputMode::Normal) => vec![
|
|
("/", "Query", Color::Green),
|
|
("Esc", "Back", Color::Yellow),
|
|
("R", "Refresh", Color::Yellow),
|
|
("a", if app.auto_refresh_enabled { "Auto" } else { "Auto" },
|
|
if app.auto_refresh_enabled { Color::Green } else { Color::DarkGray }),
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
(View::Reflect(_), InputMode::Query) => vec![
|
|
("Enter", "Reflect", Color::Green),
|
|
("Esc", "Cancel", Color::Red),
|
|
],
|
|
_ => vec![
|
|
("?", "Help", Color::Magenta),
|
|
("q", "Quit", Color::Red),
|
|
],
|
|
};
|
|
|
|
// Split into left (context) and right (shortcuts) sections
|
|
let columns = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([
|
|
Constraint::Percentage(30), // Context on left
|
|
Constraint::Percentage(70), // Shortcuts on right
|
|
])
|
|
.split(area);
|
|
|
|
// Left: Context info
|
|
let context_info = match &app.view {
|
|
View::Banks => "Context: Banks List".to_string(),
|
|
View::Memories(bank_id) => format!("Context: Memories [{}]", bank_id),
|
|
View::Entities(bank_id) => format!("Context: Entities [{}]", bank_id),
|
|
View::Documents(bank_id) => format!("Context: Documents [{}]", bank_id),
|
|
View::Recall(bank_id) => format!("Context: Recall [{}]", bank_id),
|
|
View::Reflect(bank_id) => format!("Context: Reflect [{}]", bank_id),
|
|
};
|
|
|
|
let context_widget = Paragraph::new(context_info)
|
|
.block(Block::default()
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Color::Cyan))
|
|
.title(" Context "))
|
|
.style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD))
|
|
.alignment(Alignment::Left);
|
|
f.render_widget(context_widget, columns[0]);
|
|
|
|
// Right: Shortcuts in columns if many
|
|
// Calculate shortcuts per column (max 3 lines of shortcuts)
|
|
let max_shortcuts_per_col = 3;
|
|
let num_cols = (shortcuts.len() + max_shortcuts_per_col - 1) / max_shortcuts_per_col;
|
|
|
|
let mut shortcut_lines = vec![];
|
|
for row in 0..max_shortcuts_per_col {
|
|
let mut line_spans = vec![];
|
|
|
|
for col in 0..num_cols {
|
|
let idx = col * max_shortcuts_per_col + row;
|
|
if idx < shortcuts.len() {
|
|
let (key, desc, color) = &shortcuts[idx];
|
|
|
|
// Each shortcut gets fixed width: <key> desc = total 17 chars with spacing
|
|
// Format: "<key> desc " (padded to 17 for alignment)
|
|
let shortcut_text = format!("<{:>6}> {:<9}", key, desc);
|
|
|
|
line_spans.push(Span::styled(
|
|
shortcut_text,
|
|
Style::default().fg(*color).add_modifier(Modifier::BOLD)
|
|
));
|
|
}
|
|
}
|
|
|
|
if !line_spans.is_empty() {
|
|
shortcut_lines.push(Line::from(line_spans));
|
|
}
|
|
}
|
|
|
|
let shortcuts_widget = Paragraph::new(shortcut_lines)
|
|
.block(Block::default()
|
|
.borders(Borders::ALL)
|
|
.border_style(Style::default().fg(Color::Cyan))
|
|
.title(" Shortcuts "))
|
|
.alignment(Alignment::Left);
|
|
|
|
f.render_widget(shortcuts_widget, columns[1]);
|
|
}
|
|
|
|
fn render_header(f: &mut Frame, app: &App, area: Rect) {
|
|
let bank_info = if let Some(bank_id) = app.view.bank_id() {
|
|
format!(" [{}]", bank_id)
|
|
} else {
|
|
String::new()
|
|
};
|
|
|
|
let title = format!("Hindsight Explorer - {}{}", app.view.title(), bank_info);
|
|
|
|
let header = Paragraph::new(title)
|
|
.style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
|
|
.alignment(Alignment::Center)
|
|
.block(Block::default().borders(Borders::ALL));
|
|
|
|
f.render_widget(header, area);
|
|
}
|
|
|
|
fn render_footer(f: &mut Frame, app: &App, area: Rect) {
|
|
// Simple status line only (shortcuts are now at the top, no border)
|
|
let status_line = if !app.error_message.is_empty() {
|
|
Line::from(vec![
|
|
Span::styled(" Error: ", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)),
|
|
Span::raw(&app.error_message),
|
|
])
|
|
} else if app.loading {
|
|
Line::from(Span::styled(" Loading...", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)))
|
|
} else if !app.status_message.is_empty() {
|
|
Line::from(vec![
|
|
Span::raw(" "),
|
|
Span::styled(&app.status_message, Style::default().fg(Color::Green)),
|
|
])
|
|
} else {
|
|
Line::from("")
|
|
};
|
|
|
|
let footer = Paragraph::new(status_line).alignment(Alignment::Left);
|
|
f.render_widget(footer, area);
|
|
}
|
|
|
|
fn render_banks(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let items: Vec<ListItem> = app
|
|
.banks
|
|
.iter()
|
|
.map(|bank| {
|
|
let name = if bank.name.is_empty() { "Unnamed" } else { &bank.name };
|
|
let content = format!("{} - {}", bank.bank_id, name);
|
|
ListItem::new(content).style(Style::default().fg(Color::White))
|
|
})
|
|
.collect();
|
|
|
|
let list = List::new(items)
|
|
.block(Block::default().borders(Borders::ALL).title("Banks"))
|
|
.highlight_style(
|
|
Style::default()
|
|
.bg(Color::DarkGray)
|
|
.add_modifier(Modifier::BOLD),
|
|
)
|
|
.highlight_symbol(">> ");
|
|
|
|
f.render_stateful_widget(list, area, &mut app.banks_state);
|
|
}
|
|
|
|
fn render_memories(f: &mut Frame, app: &mut App, area: Rect) {
|
|
// K9s-style table with columns
|
|
let mut items = vec![
|
|
// Header row
|
|
ListItem::new(format!("{:<12} {:<20} {}", "TYPE", "CREATED", "TEXT"))
|
|
.style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
|
|
];
|
|
|
|
// Data rows
|
|
for memory in &app.memories {
|
|
let mem_type = memory.get("type").and_then(|v| v.as_str()).unwrap_or("unknown");
|
|
let created = memory.get("created_at")
|
|
.and_then(|v| v.as_str())
|
|
.and_then(|s| s.split('T').next())
|
|
.unwrap_or("unknown");
|
|
let text = memory.get("text").and_then(|v| v.as_str()).unwrap_or("");
|
|
let preview = text.chars().take(60).collect::<String>();
|
|
|
|
let content = format!("{:<12} {:<20} {}", mem_type, created, preview);
|
|
items.push(ListItem::new(content).style(Style::default().fg(Color::White)));
|
|
}
|
|
|
|
let list = List::new(items)
|
|
.block(Block::default().borders(Borders::ALL).title("Memories"))
|
|
.highlight_style(
|
|
Style::default()
|
|
.bg(Color::DarkGray)
|
|
.add_modifier(Modifier::BOLD),
|
|
)
|
|
.highlight_symbol(">> ");
|
|
|
|
f.render_stateful_widget(list, area, &mut app.memories_state);
|
|
}
|
|
|
|
fn render_entities(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let items: Vec<ListItem> = app
|
|
.entities
|
|
.iter()
|
|
.map(|entity| {
|
|
let content = format!("{} (mentioned {} times)", entity.canonical_name, entity.mention_count);
|
|
ListItem::new(content).style(Style::default().fg(Color::White))
|
|
})
|
|
.collect();
|
|
|
|
let list = List::new(items)
|
|
.block(Block::default().borders(Borders::ALL).title("Entities"))
|
|
.highlight_style(
|
|
Style::default()
|
|
.bg(Color::DarkGray)
|
|
.add_modifier(Modifier::BOLD),
|
|
)
|
|
.highlight_symbol(">> ");
|
|
|
|
f.render_stateful_widget(list, area, &mut app.entities_state);
|
|
}
|
|
|
|
fn render_documents(f: &mut Frame, app: &mut App, area: Rect) {
|
|
// If viewing a document, show its content
|
|
if let Some(doc) = &app.viewing_document {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(5), // Document metadata
|
|
Constraint::Min(0), // Content
|
|
])
|
|
.split(area);
|
|
|
|
// Metadata section
|
|
let doc_id = doc.get("id")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("unknown");
|
|
let content_type = doc.get("content_type")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("unknown");
|
|
let created_at = doc.get("created_at")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("unknown");
|
|
|
|
let metadata_text = format!(
|
|
"ID: {}\nType: {}\nCreated: {}\n",
|
|
doc_id, content_type, created_at
|
|
);
|
|
|
|
let metadata = Paragraph::new(metadata_text)
|
|
.block(Block::default().borders(Borders::ALL).title("Document Metadata"))
|
|
.style(Style::default().fg(Color::Cyan));
|
|
|
|
f.render_widget(metadata, chunks[0]);
|
|
|
|
// Content section
|
|
let content = doc.get("content")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("No content available");
|
|
|
|
let content_widget = Paragraph::new(content)
|
|
.block(Block::default().borders(Borders::ALL).title("Content (Esc to close)"))
|
|
.wrap(Wrap { trim: false })
|
|
.style(Style::default().fg(Color::White));
|
|
|
|
f.render_widget(content_widget, chunks[1]);
|
|
} else {
|
|
// Show document list
|
|
let items: Vec<ListItem> = app
|
|
.documents
|
|
.iter()
|
|
.map(|doc| {
|
|
let id = doc.get("id")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("unknown");
|
|
let content_type = doc.get("content_type")
|
|
.and_then(|v| v.as_str())
|
|
.unwrap_or("unknown");
|
|
let content = format!("{} ({})", id, content_type);
|
|
ListItem::new(content).style(Style::default().fg(Color::White))
|
|
})
|
|
.collect();
|
|
|
|
let list = List::new(items)
|
|
.block(Block::default().borders(Borders::ALL).title("Documents"))
|
|
.highlight_style(
|
|
Style::default()
|
|
.bg(Color::DarkGray)
|
|
.add_modifier(Modifier::BOLD),
|
|
)
|
|
.highlight_symbol(">> ");
|
|
|
|
f.render_stateful_widget(list, area, &mut app.documents_state);
|
|
}
|
|
}
|
|
|
|
fn render_recall(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(3), // Query input
|
|
Constraint::Min(0), // Results
|
|
])
|
|
.split(area);
|
|
|
|
// Query input
|
|
let query_style = if app.input_mode == InputMode::Query {
|
|
Style::default().fg(Color::Yellow)
|
|
} else {
|
|
Style::default()
|
|
};
|
|
|
|
let query = Paragraph::new(app.recall_query.as_str())
|
|
.style(query_style)
|
|
.block(Block::default().borders(Borders::ALL).title("Query (press / to edit)"));
|
|
|
|
f.render_widget(query, chunks[0]);
|
|
|
|
// Results
|
|
let items: Vec<ListItem> = app
|
|
.recall_results
|
|
.iter()
|
|
.map(|result| {
|
|
let preview = result.text.chars().take(100).collect::<String>();
|
|
let type_field = result.type_.as_deref().unwrap_or("unknown");
|
|
let content = format!("[{}] {}", type_field, preview);
|
|
ListItem::new(content).style(Style::default().fg(Color::White))
|
|
})
|
|
.collect();
|
|
|
|
let list = List::new(items)
|
|
.block(Block::default().borders(Borders::ALL).title(format!("Results ({})", app.recall_results.len())))
|
|
.highlight_style(
|
|
Style::default()
|
|
.bg(Color::DarkGray)
|
|
.add_modifier(Modifier::BOLD),
|
|
)
|
|
.highlight_symbol(">> ");
|
|
|
|
f.render_stateful_widget(list, chunks[1], &mut app.recall_results_state);
|
|
}
|
|
|
|
fn render_reflect(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(3), // Query input
|
|
Constraint::Min(0), // Response
|
|
])
|
|
.split(area);
|
|
|
|
// Query input
|
|
let query_style = if app.input_mode == InputMode::Query {
|
|
Style::default().fg(Color::Yellow)
|
|
} else {
|
|
Style::default()
|
|
};
|
|
|
|
let query = Paragraph::new(app.reflect_query.as_str())
|
|
.style(query_style)
|
|
.block(Block::default().borders(Borders::ALL).title("Query (press / to edit)"));
|
|
|
|
f.render_widget(query, chunks[0]);
|
|
|
|
// Response
|
|
let response = Paragraph::new(app.reflect_response.as_str())
|
|
.style(Style::default())
|
|
.block(Block::default().borders(Borders::ALL).title("Response"))
|
|
.wrap(Wrap { trim: false });
|
|
|
|
f.render_widget(response, chunks[1]);
|
|
}
|
|
|
|
fn render_help(f: &mut Frame, area: Rect) {
|
|
let help_text = vec![
|
|
Line::from(Span::styled("Hindsight Explorer - Keyboard Shortcuts", Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))),
|
|
Line::from(""),
|
|
Line::from(vec![
|
|
Span::styled("Navigation", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
|
|
]),
|
|
Line::from(" ↑/↓, j/k - Navigate up/down in lists"),
|
|
Line::from(" Enter - Select item / drill down"),
|
|
Line::from(" Esc - Go back to previous view"),
|
|
Line::from(""),
|
|
Line::from(vec![
|
|
Span::styled("Views (from Bank selection)", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
|
|
]),
|
|
Line::from(" m - View memories for selected bank"),
|
|
Line::from(" e - View entities for selected bank"),
|
|
Line::from(" r - Recall (search) in selected bank"),
|
|
Line::from(" t - Reflect (think) with selected bank"),
|
|
Line::from(""),
|
|
Line::from(vec![
|
|
Span::styled("Actions", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
|
|
]),
|
|
Line::from(" / - Enter query (in Recall/Reflect views)"),
|
|
Line::from(" Enter - Execute query (when in query mode)"),
|
|
Line::from(" R - Refresh current view"),
|
|
Line::from(" a - Toggle auto-refresh (5s interval)"),
|
|
Line::from(""),
|
|
Line::from(vec![
|
|
Span::styled("General", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
|
|
]),
|
|
Line::from(" ? - Toggle this help screen"),
|
|
Line::from(" q - Quit"),
|
|
Line::from(""),
|
|
Line::from(Span::styled("Press ? to close help", Style::default().fg(Color::DarkGray))),
|
|
];
|
|
|
|
let help = Paragraph::new(help_text)
|
|
.block(Block::default().borders(Borders::ALL).title("Help"))
|
|
.alignment(Alignment::Left);
|
|
|
|
f.render_widget(help, area);
|
|
}
|
|
|
|
fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> Result<()> {
|
|
// Initial load
|
|
app.refresh()?;
|
|
|
|
loop {
|
|
terminal.draw(|f| ui(f, &mut app))?;
|
|
|
|
if event::poll(Duration::from_millis(100))? {
|
|
if let Event::Key(key) = event::read()? {
|
|
// Handle Ctrl+C to exit
|
|
if key.code == KeyCode::Char('c') && key.modifiers.contains(crossterm::event::KeyModifiers::CONTROL) {
|
|
return Ok(());
|
|
}
|
|
|
|
match app.input_mode {
|
|
InputMode::Normal => {
|
|
match key.code {
|
|
KeyCode::Char('q') => return Ok(()),
|
|
KeyCode::Char('?') => app.show_help = !app.show_help,
|
|
|
|
// Navigation
|
|
KeyCode::Down | KeyCode::Char('j') => app.next_item(),
|
|
KeyCode::Up | KeyCode::Char('k') => app.previous_item(),
|
|
KeyCode::Enter => app.enter_view()?,
|
|
KeyCode::Esc => app.go_back(),
|
|
|
|
// View switching (only from Banks view or same bank)
|
|
KeyCode::Char('m') => {
|
|
if let Some(i) = app.banks_state.selected() {
|
|
if let Some(bank) = app.banks.get(i) {
|
|
app.switch_to_view(View::Memories(bank.bank_id.clone()))?;
|
|
}
|
|
}
|
|
}
|
|
KeyCode::Char('e') => {
|
|
if let Some(i) = app.banks_state.selected() {
|
|
if let Some(bank) = app.banks.get(i) {
|
|
app.switch_to_view(View::Entities(bank.bank_id.clone()))?;
|
|
}
|
|
}
|
|
}
|
|
KeyCode::Char('d') => {
|
|
if let Some(i) = app.banks_state.selected() {
|
|
if let Some(bank) = app.banks.get(i) {
|
|
app.switch_to_view(View::Documents(bank.bank_id.clone()))?;
|
|
}
|
|
}
|
|
}
|
|
KeyCode::Char('r') => {
|
|
if let Some(i) = app.banks_state.selected() {
|
|
if let Some(bank) = app.banks.get(i) {
|
|
app.switch_to_view(View::Recall(bank.bank_id.clone()))?;
|
|
}
|
|
} else if let Some(bank_id) = app.view.bank_id() {
|
|
app.switch_to_view(View::Recall(bank_id.to_string()))?;
|
|
}
|
|
}
|
|
KeyCode::Char('t') => {
|
|
if let Some(i) = app.banks_state.selected() {
|
|
if let Some(bank) = app.banks.get(i) {
|
|
app.switch_to_view(View::Reflect(bank.bank_id.clone()))?;
|
|
}
|
|
} else if let Some(bank_id) = app.view.bank_id() {
|
|
app.switch_to_view(View::Reflect(bank_id.to_string()))?;
|
|
}
|
|
}
|
|
|
|
// Refresh
|
|
KeyCode::Char('R') => {
|
|
app.refresh()?;
|
|
}
|
|
|
|
// Toggle auto-refresh
|
|
KeyCode::Char('a') => {
|
|
app.toggle_auto_refresh();
|
|
}
|
|
|
|
// Query input
|
|
KeyCode::Char('/') => {
|
|
if matches!(app.view, View::Recall(_) | View::Reflect(_)) {
|
|
app.input_mode = InputMode::Query;
|
|
}
|
|
}
|
|
|
|
// Delete document
|
|
KeyCode::Delete => {
|
|
if matches!(app.view, View::Documents(_)) {
|
|
app.delete_selected_document()?;
|
|
}
|
|
}
|
|
|
|
_ => {}
|
|
}
|
|
}
|
|
InputMode::Query => {
|
|
match key.code {
|
|
KeyCode::Enter => {
|
|
match &app.view {
|
|
View::Recall(_) => app.execute_recall()?,
|
|
View::Reflect(_) => app.execute_reflect()?,
|
|
_ => {}
|
|
}
|
|
}
|
|
KeyCode::Esc => {
|
|
app.input_mode = InputMode::Normal;
|
|
}
|
|
KeyCode::Char(c) => {
|
|
match &app.view {
|
|
View::Recall(_) => app.recall_query.push(c),
|
|
View::Reflect(_) => app.reflect_query.push(c),
|
|
_ => {}
|
|
}
|
|
}
|
|
KeyCode::Backspace => {
|
|
match &app.view {
|
|
View::Recall(_) => { app.recall_query.pop(); }
|
|
View::Reflect(_) => { app.reflect_query.pop(); }
|
|
_ => {}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Auto-refresh check
|
|
app.do_auto_refresh()?;
|
|
}
|
|
}
|
|
|
|
pub fn run(client: &ApiClient) -> Result<()> {
|
|
// Setup terminal
|
|
enable_raw_mode()?;
|
|
let mut stdout = io::stdout();
|
|
execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
|
|
let backend = CrosstermBackend::new(stdout);
|
|
let mut terminal = Terminal::new(backend)?;
|
|
|
|
// Create app and run it
|
|
let app = App::new(client.clone());
|
|
let res = run_app(&mut terminal, app);
|
|
|
|
// Restore terminal
|
|
disable_raw_mode()?;
|
|
execute!(
|
|
terminal.backend_mut(),
|
|
LeaveAlternateScreen,
|
|
DisableMouseCapture
|
|
)?;
|
|
terminal.show_cursor()?;
|
|
|
|
if let Err(err) = res {
|
|
println!("Error: {:?}", err);
|
|
}
|
|
|
|
Ok(())
|
|
}
|