magi-code 0.96.2

Repository-aware CLI coding agent for terminal work
Documentation 
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

use crate::{
    output::tool_display::{
        pending_tool_status, pending_tool_summary_metadata, should_show_pending_tool,
        tool_summary_metadata,
    },
    providers::ToolCall,
    tools::ToolResult,
};

use crate::output::{
    ActivityStatus, ToolDisplaySummary, ToolStatus, redact_sensitive_text, tool_display_label,
};

fn unicode_mark(status: ToolStatus) -> &'static str {
    match status {
        ToolStatus::Running | ToolStatus::Writing => "⟳",
        ToolStatus::Success => "✓",
        ToolStatus::Failure => "✗",
    }
}

fn ascii_mark(status: ToolStatus) -> &'static str {
    match status {
        ToolStatus::Running => "RUNNING",
        ToolStatus::Writing => "WRITING",
        ToolStatus::Success => "OK",
        ToolStatus::Failure => "FAIL",
    }
}

pub(crate) fn pending_tool_display_summary(call: &ToolCall) -> Option<ToolDisplaySummary> {
    if !should_show_pending_tool(call) {
        return None;
    }
    let status = pending_tool_status(call);
    let metadata = pending_tool_summary_metadata(call)
        .into_iter()
        .map(|(key, value)| (key, redact_sensitive_text(&value)))
        .collect();
    Some(ToolDisplaySummary {
        tool_name: call.name.clone(),
        status,
        unicode_mark: unicode_mark(status),
        ascii_mark: ascii_mark(status),
        label: tool_display_label(call),
        metadata,
    })
}

pub(crate) fn tool_status_label(status: ToolStatus) -> &'static str {
    match status {
        ToolStatus::Running => "running",
        ToolStatus::Writing => "writing",
        ToolStatus::Success => "success",
        ToolStatus::Failure => "failure",
    }
}

pub(crate) fn pending_activity_status(call: &ToolCall) -> ActivityStatus {
    match pending_tool_status(call) {
        ToolStatus::Writing => ActivityStatus::Writing,
        _ => ActivityStatus::Running,
    }
}

pub(crate) fn tool_display_summary(call: &ToolCall, result: &ToolResult) -> ToolDisplaySummary {
    let tool_name = if result.tool_name.is_empty() {
        call.name.clone()
    } else {
        result.tool_name.clone()
    };
    let status = if result.success {
        ToolStatus::Success
    } else {
        ToolStatus::Failure
    };
    let label = tool_display_label(call);
    let metadata = tool_summary_metadata(call, result)
        .into_iter()
        .map(|(key, value)| (key, redact_sensitive_text(&value)))
        .collect();
    ToolDisplaySummary {
        tool_name,
        status,
        unicode_mark: unicode_mark(status),
        ascii_mark: ascii_mark(status),
        label,
        metadata,
    }
}