agent-code 0.8.7

An AI-powered coding agent for the terminal, written in pure Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Interactive permission prompts.
//!
//! When a tool requires permission in "ask" mode, display a rich
//! TUI modal with tool details and multiple response options.

use crossterm::style::Stylize;

/// Result of a permission prompt.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PermissionResponse {
    /// Allow this specific invocation.
    AllowOnce,
    /// Allow this tool for the rest of the session.
    AllowSession,
    /// Deny this invocation.
    Deny,
}

/// Ask the user whether to allow a tool operation.
///
/// Shows a rich prompt with tool name, description, input summary,
/// and multiple response options. Returns true if allowed.
pub fn ask_permission(tool_name: &str, description: &str) -> bool {
    let response = ask_permission_detailed(tool_name, description, None);
    matches!(
        response,
        PermissionResponse::AllowOnce | PermissionResponse::AllowSession
    )
}

/// Detailed permission prompt with full context.
pub fn ask_permission_detailed(
    tool_name: &str,
    description: &str,
    input_preview: Option<&str>,
) -> PermissionResponse {
    let t = super::theme::current();

    eprintln!();
    eprintln!(
        "{} {} wants to execute:",
        super::theme::label(" PERMISSION ", t.warning, crossterm::style::Color::Black),
        tool_name.with(t.text).bold(),
    );

    // Show the action description.
    eprintln!("  {}", description.with(t.muted));

    // Show input preview if available.
    if let Some(preview) = input_preview {
        eprintln!();
        let lines: Vec<&str> = preview.lines().take(5).collect();
        for line in &lines {
            eprintln!("  {}", line.with(t.inactive));
        }
        if preview.lines().count() > 5 {
            eprintln!("  {}", "...".with(t.muted));
        }
    }

    eprintln!();

    let choice = super::selector::select(&[
        super::selector::SelectOption {
            label: "Allow".into(),
            description: "allow this action".into(),
            value: "allow_once".into(),
            preview: None,
        },
        super::selector::SelectOption {
            label: "Allow for session".into(),
            description: format!("always allow {tool_name} this session"),
            value: "allow_session".into(),
            preview: None,
        },
        super::selector::SelectOption {
            label: "Deny".into(),
            description: "block this action".into(),
            value: "deny".into(),
            preview: None,
        },
    ]);

    match choice.as_str() {
        "allow_once" => PermissionResponse::AllowOnce,
        "allow_session" => PermissionResponse::AllowSession,
        _ => PermissionResponse::Deny,
    }
}

/// Display a diff with theme-colored lines.
pub fn print_colored_diff(diff: &str) {
    let t = super::theme::current();
    for line in diff.lines() {
        if line.starts_with('+') && !line.starts_with("+++") {
            println!("{}", line.with(t.diff_add));
        } else if line.starts_with('-') && !line.starts_with("---") {
            println!("{}", line.with(t.diff_remove));
        } else if line.starts_with("@@") {
            println!("{}", line.with(t.tool));
        } else if line.starts_with("diff ") {
            println!("{}", line.bold());
        } else {
            println!("{line}");
        }
    }
}

/// Display a file edit summary with before/after context.
pub fn print_edit_summary(file_path: &str, old: &str, new: &str) {
    let t = super::theme::current();
    println!("{}", format!("  {file_path}:").bold());
    for line in old.lines().take(3) {
        println!("  {}", format!("- {line}").with(t.diff_remove));
    }
    for line in new.lines().take(3) {
        println!("  {}", format!("+ {line}").with(t.diff_add));
    }
    if old.lines().count() > 3 || new.lines().count() > 3 {
        println!("  {}", "...".with(t.muted));
    }
}