magi-code 0.103.0

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
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

use super::*;
pub(super) fn list_files_card(input: &ToolCardInput<'_>) -> CardDraft {
    use crate::tool_contract::{arg_key, metadata_key};
    let detail = input.detail;
    let body = input.body;
    let mut status = input_status(input);
    if status == CardStatus::Failed && tool_was_canceled(detail) {
        status = CardStatus::Canceled;
    }
    let metadata = detail.map(|detail| &detail.metadata);
    let params = detail.map(|detail| &detail.params);
    let path = if status == CardStatus::Success {
        metadata
            .and_then(|value| value.get(metadata_key::PATH))
            .and_then(serde_json::Value::as_str)
            .or_else(|| {
                params
                    .and_then(|value| value.get(arg_key::PATH))
                    .and_then(serde_json::Value::as_str)
            })
    } else {
        params
            .and_then(|value| value.get(arg_key::PATH))
            .and_then(serde_json::Value::as_str)
            .or_else(|| {
                metadata
                    .and_then(|value| value.get(metadata_key::PATH))
                    .and_then(serde_json::Value::as_str)
            })
    }
    .unwrap_or(".");
    let path = truncate_preview_line(&sanitized_single_line(path), PREVIEW_LINE_MAX_CHARS);
    let files = list_files_count(metadata, metadata_key::FILES);
    let directories = list_files_count(metadata, metadata_key::DIRECTORIES);
    let include_directories = params
        .and_then(|value| value.get(arg_key::INCLUDE_DIRECTORIES))
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);
    let includes_directories = include_directories || directories.is_some_and(|count| count > 0);
    let truncated = metadata
        .and_then(|value| value.get(metadata_key::TRUNCATED))
        .and_then(serde_json::Value::as_bool)
        .unwrap_or(false);
    let returned = files
        .zip(directories)
        .map(|(files, directories)| files.saturating_add(directories));
    let title = match status {
        CardStatus::Success if truncated => returned.map_or_else(
            || "List Files • entries returned".to_string(),
            |returned| format!("List Files • {returned} entries returned"),
        ),
        CardStatus::Success if includes_directories => returned.map_or_else(
            || "List Files".to_string(),
            |returned| format!("List Files • {returned} entries"),
        ),
        CardStatus::Success => files.map_or_else(
            || "List Files".to_string(),
            |files| format!("List Files • {files} {}", plural(files, "file", "files")),
        ),
        CardStatus::Canceled => "List Files • canceled".to_string(),
        _ => "List Files".to_string(),
    };
    let mut lines = vec![path];
    match status {
        CardStatus::Running => {
            if include_directories {
                lines.push("include directories".to_string());
            }
        }
        CardStatus::Success => {
            let output_lines = detail
                .map(|detail| {
                    detail
                        .output
                        .lines()
                        .filter(|line| !line.is_empty())
                        .collect::<Vec<_>>()
                })
                .unwrap_or_default();
            lines.extend(output_lines.iter().take(TOOL_PREVIEW_LINES).map(|line| {
                truncate_preview_line(&sanitized_single_line(line), PREVIEW_LINE_MAX_CHARS)
            }));
            if output_lines.len() > TOOL_PREVIEW_LINES {
                lines.push(format!("… preview limited to {TOOL_PREVIEW_LINES} lines"));
            }
            if truncated {
                lines.push("… output capped at 1000 entries".to_string());
            }
            if output_lines.is_empty() && returned == Some(0) {
                lines.push("0 entries".to_string());
            }
        }
        CardStatus::Failed => lines.push(bounded_error_line(
            detail.map_or(body, |detail| detail.output.as_ref()),
        )),
        CardStatus::Canceled => lines.push("Canceled before completion".to_string()),
        CardStatus::None => {}
    }
    CardDraft {
        role: ToolCardRole::ListFiles,
        status,
        title,
        metadata: Vec::new(),
        body: lines.join("\n"),
        body_lines: Vec::new(),
        activity_rows: Vec::new(),
    }
}

fn list_files_count(metadata: Option<&serde_json::Value>, key: &str) -> Option<usize> {
    metadata
        .and_then(|value| value.get(key))
        .and_then(serde_json::Value::as_u64)
        .and_then(|value| usize::try_from(value).ok())
}