anveesa 0.5.1 → 0.5.3

package/Cargo.lock

@@ -60,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.5.1"
+version = "0.5.3"
 edition = "2024"
 default-run = "anveesa"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {

package/src/lib.rs

@@ -636,7 +636,7 @@ async fn ask_streaming(
     history: &[ChatMessage],
     workspace_context: Option<&str>,
     policy: ApprovalPolicy,
-    image: Option<ImageAttachment>,
+    image: Option<ImageAttachment>, // single-image path kept for REPL compatibility
     mode: RenderMode,
 ) -> Result<TurnResult> {
     let provider_name = config
@@ -652,7 +652,7 @@ async fn ask_streaming(
         system: options.system.clone(),
         workspace_context: workspace_context.map(str::to_string),
         history: history.to_vec(),
-        image,
+        images: image.into_iter().collect(),
         mcp: None, // REPL path: MCP not yet wired here
     };
 

package/src/provider/mod.rs

@@ -49,8 +49,8 @@ pub struct PromptRequest {
     pub system: Option<String>,
     pub workspace_context: Option<String>,
     pub history: Vec<ChatMessage>,
-    /// Optional image grabbed from the clipboard for the current turn only.
-    pub image: Option<ImageAttachment>,
+    /// Images attached to the current turn (clipboard paste or explicit attach).
+    pub images: Vec<ImageAttachment>,
     /// Connected MCP servers (runtime only, not part of session history).
     pub mcp: Option<std::sync::Arc<crate::mcp::McpManager>>,
 }

package/src/provider/openai_compatible.rs

@@ -822,13 +822,15 @@ fn build_messages(
         messages.push(json!({ "role": role, "content": message.content }));
     }
 
-    // Current user turn — multimodal when a clipboard image is attached.
-    let user_content = match &request.image {
-        Some(img) => json!([
-            { "type": "text", "text": &request.prompt },
-            { "type": "image_url", "image_url": { "url": format!("data:{};base64,{}", img.mime, img.data) } }
-        ]),
-        None => json!(&request.prompt),
+    // Current user turn — multimodal when images are attached.
+    let user_content = if request.images.is_empty() {
+        json!(&request.prompt)
+    } else {
+        let mut parts = vec![json!({ "type": "text", "text": &request.prompt })];
+        for img in &request.images {
+            parts.push(json!({ "type": "image_url", "image_url": { "url": format!("data:{};base64,{}", img.mime, img.data) } }));
+        }
+        json!(parts)
     };
     messages.push(json!({ "role": "user", "content": user_content }));
 

package/src/tui.rs

@@ -46,7 +46,7 @@ enum Msg {
     User { text: String },
     Assistant { text: String },
     Tool { done: bool, ok: bool, text: String, elapsed_ms: Option<u128> },
-    FileOp { verb: String, path: String, added: usize, removed: usize, diff: Vec<(bool, String)> },
+    FileOp { verb: String, path: String, added: usize, removed: usize, diff: Vec<(bool, String)>, collapsed: bool },
     Error(String),
     System(String),
     Separator, // thin line between turns — "AI is done, your turn"
@@ -98,7 +98,7 @@ pub struct App {
     input_history: Vec<String>,
     hist_idx: Option<usize>,
     hist_saved: String,
-    pending_image: Option<ImageAttachment>,
+    pending_images: Vec<ImageAttachment>,
     last_image_fp: Option<String>,
     images_available: bool,
 
@@ -114,6 +114,13 @@ pub struct App {
     session_cost_usd: f64,
     cwd: String,
 
+    // message navigation / collapsing
+    msg_focus: Option<usize>,
+    msg_line_offsets: Vec<usize>,
+
+    // tab completion state: (original input, candidates, current index)
+    tab_state: Option<(String, Vec<String>, usize)>,
+
     // mode
     mode: Mode,
     confirm: Option<PendingConfirm>,
@@ -186,7 +193,7 @@ impl App {
             input_history,
             hist_idx: None,
             hist_saved: String::new(),
-            pending_image: None,
+            pending_images: Vec::new(),
             last_image_fp: None,
             images_available,
 
@@ -200,6 +207,10 @@ impl App {
             session_cost_usd: 0.0,
             cwd,
 
+            msg_focus: None,
+            msg_line_offsets: Vec::new(),
+            tab_state: None,
+
             mode: Mode::Input,
             confirm: None,
             mouse_capture: true,
@@ -313,11 +324,9 @@ async fn handle_event(app: &mut App, event: Event) -> Result<()> {
         Event::Paste(text) => {
             if app.mode != Mode::Input { return Ok(()); }
             if text.trim().is_empty() {
-                // Empty paste = user pasted an image (terminal can't forward it as text)
-                // Try to grab it directly from the clipboard
                 if app.images_available {
                     if let Some(img) = crate::grab_clipboard_image() {
-                        app.pending_image = Some(img);
+                        app.pending_images.push(img);
                         app.last_image_fp = None;
                         return Ok(());
                     }
@@ -327,6 +336,7 @@ async fn handle_event(app: &mut App, event: Event) -> Result<()> {
                 app.input.insert_str(app.input_cursor, &normalized);
                 app.input_cursor += normalized.len();
                 app.hist_idx = None;
+                app.tab_state = None;
             }
         }
         Event::Resize(_, _) => {}
@@ -393,11 +403,50 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
             app.input_cursor += 1;
             app.hist_idx = None;
         }
+        KeyCode::Tab => {
+            tab_complete(app);
+        }
+
+        KeyCode::Char('[') if app.input.is_empty() => {
+            let cur = app.msg_focus.unwrap_or(app.messages.len());
+            let prev = app.messages[..cur].iter().rposition(|m| matches!(m, Msg::FileOp { .. }));
+            if let Some(idx) = prev {
+                app.msg_focus = Some(idx);
+                app.auto_scroll = false;
+                if let Some(&off) = app.msg_line_offsets.get(idx) {
+                    app.scroll = off.saturating_sub(2);
+                }
+            }
+        }
+        KeyCode::Char(']') if app.input.is_empty() => {
+            let start = app.msg_focus.map(|i| i + 1).unwrap_or(0);
+            let next = app.messages[start..].iter().position(|m| matches!(m, Msg::FileOp { .. })).map(|i| start + i);
+            if let Some(idx) = next {
+                app.msg_focus = Some(idx);
+                app.auto_scroll = false;
+                if let Some(&off) = app.msg_line_offsets.get(idx) {
+                    app.scroll = off.saturating_sub(2);
+                }
+            }
+        }
+        KeyCode::Esc if app.msg_focus.is_some() => {
+            app.msg_focus = None;
+        }
+
         KeyCode::Enter => {
+            // Toggle collapse on focused FileOp if one is selected
+            if let Some(idx) = app.msg_focus {
+                if let Some(Msg::FileOp { collapsed, .. }) = app.messages.get_mut(idx) {
+                    *collapsed = !*collapsed;
+                    return Ok(());
+                }
+            }
             let text = app.input.trim().to_string();
             if text.is_empty() {
                 return Ok(());
             }
+            app.msg_focus = None;
+            app.tab_state = None;
             if !handle_slash_command(app, &text) {
                 submit_prompt(app, text).await?;
             }
@@ -425,22 +474,25 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
             delete_word_before(&mut app.input, &mut app.input_cursor);
             app.hist_idx = None;
         }
-        // Ctrl+V — universal paste: image first, then clipboard text
-        KeyCode::Char('v') if modifiers.contains(KeyModifiers::CONTROL) => {
+        // Ctrl+V (all platforms) or Cmd+V (macOS) — image first, then text
+        KeyCode::Char('v')
+            if modifiers.contains(KeyModifiers::CONTROL)
+                || (cfg!(target_os = "macos") && modifiers.contains(KeyModifiers::SUPER)) =>
+        {
             if app.images_available {
                 if let Some(img) = crate::grab_clipboard_image() {
-                    app.pending_image = Some(img);
+                    app.pending_images.push(img);
                     app.last_image_fp = None;
                     return Ok(());
                 }
             }
-            // No image — fall back to clipboard text
             if let Some(text) = crate::read_clipboard_text() {
                 if !text.is_empty() {
                     let normalized = text.replace('\r', "\n");
                     app.input.insert_str(app.input_cursor, &normalized);
                     app.input_cursor += normalized.len();
                     app.hist_idx = None;
+                    app.tab_state = None;
                 }
             }
         }
@@ -459,6 +511,7 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
                 app.input.drain(start..app.input_cursor);
                 app.input_cursor = start;
                 app.hist_idx = None;
+                app.tab_state = None;
             }
         }
         KeyCode::Delete => {
@@ -466,6 +519,7 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
                 let len = next_char_len(&app.input, app.input_cursor);
                 app.input.drain(app.input_cursor..app.input_cursor + len);
                 app.hist_idx = None;
+                app.tab_state = None;
             }
         }
 
@@ -536,6 +590,8 @@ async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -
             app.input.insert_str(app.input_cursor, &s);
             app.input_cursor += s.len();
             app.hist_idx = None;
+            app.msg_focus = None;
+            app.tab_state = None;
         }
 
         _ => {}
@@ -556,7 +612,7 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
             app.streaming_buf.clear();
             app.accumulated_response.clear();
             app.usage = Usage::default();
-            app.pending_image = None;
+            app.pending_images.clear();
             app.seen_paths.clear();
             app.undo_stack.clear();
             app.input.clear();
@@ -577,8 +633,10 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
                  /model [name] · /provider [name] · /status · /exit\n\
                  \n\
                  Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
+                 Tab   complete /command or file path (press again to cycle)\n\
+                 [ ]   navigate between file diffs  Enter expand/collapse focused diff\n\
                  j/k scroll (when input empty)  PageUp/Dn scroll\n\
-                 Ctrl+V paste (image or text)  Ctrl+M scroll/select mode\n\
+                 ⌘V (macOS) / Ctrl+V  paste image or text (repeat to queue multiple images)\n\
                  Ctrl+W delete-word  Ctrl+U clear line\n\
                  \n\
                  Search: set BRAVE_SEARCH_API_KEY or SERPER_API_KEY for better results".into(),
@@ -728,6 +786,87 @@ fn handle_slash_command(app: &mut App, text: &str) -> bool {
     }
 }
 
+// ── Tab completion ────────────────────────────────────────────────────────────
+
+const SLASH_COMMANDS: &[&str] = &[
+    "/clear", "/compact", "/copy", "/exit", "/export",
+    "/help", "/model", "/provider", "/quit", "/status", "/undo",
+];
+
+fn tab_complete(app: &mut App) {
+    let input = app.input.clone();
+
+    // If we're still on the same completion cycle, advance the index
+    let continuing = app.tab_state.as_ref().map(|(_, cands, idx)| {
+        cands.get(*idx).map(|s| s == &input).unwrap_or(false)
+    }).unwrap_or(false);
+
+    if continuing {
+        if let Some((_, cands, idx)) = &mut app.tab_state {
+            *idx = (*idx + 1) % cands.len();
+            let next = cands[*idx].clone();
+            app.input = next;
+            app.input_cursor = app.input.len();
+        }
+        return;
+    }
+
+    let cands = compute_tab_completions(&input, &app.cwd);
+    if cands.is_empty() { return; }
+
+    app.input = cands[0].clone();
+    app.input_cursor = app.input.len();
+    app.tab_state = Some((input, cands, 0));
+}
+
+fn compute_tab_completions(input: &str, cwd: &str) -> Vec<String> {
+    // Slash command completion: /pro → /provider, /model, …
+    if input.starts_with('/') && !input.contains(' ') {
+        let matches: Vec<String> = SLASH_COMMANDS.iter()
+            .filter(|c| c.starts_with(input))
+            .map(|s| s.to_string())
+            .collect();
+        if !matches.is_empty() { return matches; }
+    }
+
+    // File path completion after "/export <path>"
+    if let Some(partial) = input.strip_prefix("/export ") {
+        let paths = tab_complete_path(partial, cwd);
+        return paths.into_iter().map(|p| format!("/export {p}")).collect();
+    }
+
+    vec![]
+}
+
+fn tab_complete_path(partial: &str, cwd: &str) -> Vec<String> {
+    let (dir_part, file_part) = if let Some(i) = partial.rfind('/') {
+        (&partial[..i + 1], &partial[i + 1..])
+    } else {
+        ("", partial)
+    };
+
+    let search_dir = if dir_part.is_empty() {
+        std::path::PathBuf::from(cwd)
+    } else if dir_part.starts_with('/') {
+        std::path::PathBuf::from(dir_part)
+    } else {
+        std::path::Path::new(cwd).join(dir_part)
+    };
+
+    let Ok(entries) = std::fs::read_dir(&search_dir) else { return vec![]; };
+    let mut out: Vec<String> = entries
+        .filter_map(|e| e.ok())
+        .filter_map(|e| {
+            let name = e.file_name().into_string().ok()?;
+            if !name.starts_with(file_part) { return None; }
+            let trail = if e.file_type().map(|t| t.is_dir()).unwrap_or(false) { "/" } else { "" };
+            Some(format!("{dir_part}{name}{trail}"))
+        })
+        .collect();
+    out.sort();
+    out
+}
+
 async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
     // Save to input history
     if app.input_history.last().map(|s| s.as_str()) != Some(&text) {
@@ -737,17 +876,24 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
     app.pending_prompt = text.clone();
     app.accumulated_response.clear();
 
-    // Auto-attach clipboard image if nothing was explicitly Ctrl+V'd
-    let image = app.pending_image.take().or_else(|| {
-        if !app.images_available { return None; }
-        let img = crate::grab_clipboard_image()?;
-        let fp = crate::image_fingerprint(&img);
-        if app.last_image_fp.as_deref() == Some(&fp) {
-            return None; // same image as last time
+    // Collect explicitly pasted images; if none, auto-attach a new clipboard image once.
+    let images: Vec<crate::provider::ImageAttachment> = if !app.pending_images.is_empty() {
+        std::mem::take(&mut app.pending_images)
+    } else if app.images_available {
+        if let Some(img) = crate::grab_clipboard_image() {
+            let fp = crate::image_fingerprint(&img);
+            if app.last_image_fp.as_deref() == Some(&fp) {
+                vec![]
+            } else {
+                app.last_image_fp = Some(fp);
+                vec![img]
+            }
+        } else {
+            vec![]
         }
-        app.last_image_fp = Some(fp);
-        Some(img)
-    });
+    } else {
+        vec![]
+    };
 
     app.messages.push(Msg::User { text: text.clone() });
     app.input.clear();
@@ -787,7 +933,7 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
             system: options.system.clone(),
             workspace_context,
             history,
-            image,
+            images,
             mcp: mcp_arc,
         };
         let result = crate::provider::ask(&config, &provider_name, request, policy, &stream_tx_inner).await;
@@ -874,11 +1020,11 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
         TuiEvent::FileOp { verb, path, added, removed, diff } => {
             flush_streaming_buf(app);
             commit_pending_tool(app, true);
-            // Snapshot for /undo (read current content before the write is reflected in messages)
             let old_content = std::fs::read_to_string(&path).ok();
             if app.undo_stack.len() >= 20 { app.undo_stack.remove(0); }
             app.undo_stack.push((path.clone(), old_content));
-            app.messages.push(Msg::FileOp { verb, path, added, removed, diff });
+            let collapsed = diff.len() > 8;
+            app.messages.push(Msg::FileOp { verb, path, added, removed, diff, collapsed });
         }
         TuiEvent::Confirm { summary, diff, reply } => {
             flush_streaming_buf(app);
@@ -1165,8 +1311,12 @@ fn render_header(frame: &mut Frame, area: Rect, app: &App) {
 fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
     let width = area.width.saturating_sub(4) as usize;
     let mut lines: Vec<Line<'static>> = vec![Line::from("")];
+    let mut msg_offsets: Vec<usize> = Vec::with_capacity(app.messages.len());
 
-    for msg in &app.messages {
+    for (msg_idx, msg) in app.messages.iter().enumerate() {
+        msg_offsets.push(lines.len());
+        let focused = app.msg_focus == Some(msg_idx);
+        let _ = focused; // used below in FileOp branch
         match msg {
             Msg::User { text } => {
                 lines.push(user_header());
@@ -1201,32 +1351,43 @@ fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
                 ]));
                 lines.push(Line::from(""));
             }
-            Msg::FileOp { verb, path, added, removed, diff } => {
+            Msg::FileOp { verb, path, added, removed, diff, collapsed } => {
+                let focus_icon = if focused { "►" } else { " " };
+                let header_bg = if focused { Color::Rgb(25, 25, 50) } else { Color::Reset };
+                let toggle_hint = if *collapsed {
+                    format!("  [▶ {} lines]", diff.len())
+                } else if diff.len() > 8 {
+                    "  [▼ collapse]".to_string()
+                } else {
+                    String::new()
+                };
                 lines.push(Line::from(vec![
-                    Span::styled("  📄 ", Style::default().fg(Color::Rgb(229, 192, 123))),
-                    Span::styled(format!("{verb} "), Style::default().fg(Color::White)),
-                    Span::styled(path.clone(), Style::default().fg(Color::Rgb(97, 175, 239))),
-                    Span::styled(format!("  +{added}"), Style::default().fg(Color::Rgb(152, 195, 121))),
-                    Span::styled(format!(" -{removed}"), Style::default().fg(Color::Rgb(224, 108, 117))),
+                    Span::styled(format!(" {focus_icon}📄 "), Style::default().fg(Color::Rgb(229, 192, 123)).bg(header_bg)),
+                    Span::styled(format!("{verb} "), Style::default().fg(Color::White).bg(header_bg)),
+                    Span::styled(path.clone(), Style::default().fg(Color::Rgb(97, 175, 239)).bg(header_bg)),
+                    Span::styled(format!("  +{added}"), Style::default().fg(Color::Rgb(152, 195, 121)).bg(header_bg)),
+                    Span::styled(format!(" -{removed}"), Style::default().fg(Color::Rgb(224, 108, 117)).bg(header_bg)),
+                    Span::styled(toggle_hint, Style::default().fg(Color::Rgb(80, 80, 100)).bg(header_bg)),
                 ]));
-                // Show inline diff (up to 40 lines)
-                for (is_add, line) in diff.iter().take(40) {
-                    let (prefix, color) = if *is_add {
-                        ("  + ", Color::Rgb(152, 195, 121))
-                    } else {
-                        ("  - ", Color::Rgb(224, 108, 117))
-                    };
-                    let bg = if *is_add { Color::Rgb(20, 35, 20) } else { Color::Rgb(35, 20, 20) };
-                    lines.push(Line::from(Span::styled(
-                        format!("{prefix}{}", &line.trim_end().chars().take(width.saturating_sub(6)).collect::<String>()),
-                        Style::default().fg(color).bg(bg),
-                    )));
-                }
-                if diff.len() > 40 {
-                    lines.push(Line::from(Span::styled(
-                        format!("  … {} more lines", diff.len() - 40),
-                        Style::default().fg(Color::DarkGray),
-                    )));
+                if !collapsed {
+                    for (is_add, line) in diff.iter().take(40) {
+                        let (prefix, color) = if *is_add {
+                            ("  + ", Color::Rgb(152, 195, 121))
+                        } else {
+                            ("  - ", Color::Rgb(224, 108, 117))
+                        };
+                        let bg = if *is_add { Color::Rgb(20, 35, 20) } else { Color::Rgb(35, 20, 20) };
+                        lines.push(Line::from(Span::styled(
+                            format!("{prefix}{}", &line.trim_end().chars().take(width.saturating_sub(6)).collect::<String>()),
+                            Style::default().fg(color).bg(bg),
+                        )));
+                    }
+                    if diff.len() > 40 {
+                        lines.push(Line::from(Span::styled(
+                            format!("  … {} more lines", diff.len() - 40),
+                            Style::default().fg(Color::DarkGray),
+                        )));
+                    }
                 }
                 lines.push(Line::from(""));
             }
@@ -1258,6 +1419,8 @@ fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
         }
     }
 
+    app.msg_line_offsets = msg_offsets;
+
     // Live pending tool (running, not yet committed) — animated with elapsed time
     if let Some(tool) = &app.pending_tool {
         let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -1371,10 +1534,9 @@ fn render_input(frame: &mut Frame, area: Rect, app: &App) {
         return;
     }
 
-    if app.input.is_empty() && app.pending_image.is_none() {
-        // Placeholder hint
+    if app.input.is_empty() && app.pending_images.is_empty() {
         frame.render_widget(
-            Paragraph::new("  ❯ Ask anything…  (↑/↓ history · Ctrl+V paste image)")
+            Paragraph::new("  ❯ Ask anything…  (↑/↓ history · ⌘V paste image)")
                 .style(Style::default().fg(Color::Rgb(60, 60, 80))),
             inner,
         );
@@ -1382,7 +1544,11 @@ fn render_input(frame: &mut Frame, area: Rect, app: &App) {
         return;
     }
 
-    let label = if app.pending_image.is_some() { "  [📎] ❯ " } else { "  ❯ " };
+    let label = match app.pending_images.len() {
+        0 => "  ❯ ".to_string(),
+        1 => "  [📎] ❯ ".to_string(),
+        n => format!("  [📎 ×{n}] ❯ "),
+    };
     let label_w = label.chars().count();
     let display = format!("{label}{}", app.input);