chabeau 0.7.3

A full-screen terminal chat interface that connects to various AI APIs for real-time conversations
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! String setting handlers for text-based settings.

use crate::cli::settings::error::SettingError;
use crate::cli::settings::helpers::{mutate_config_with_message, success_set};
use crate::cli::settings::{SetContext, SettingHandler};
use crate::core::config::data::{Config, DEFAULT_REFINE_INSTRUCTIONS, DEFAULT_REFINE_PREFIX};

/// Handler for the `refine-instructions` setting.
pub struct RefineInstructionsHandler;

impl SettingHandler for RefineInstructionsHandler {
    fn key(&self) -> &'static str {
        "refine-instructions"
    }

    fn set(&self, args: &[String], _ctx: &mut SetContext<'_>) -> Result<String, SettingError> {
        if args.is_empty() {
            return Err(SettingError::MissingArgs {
                hint: "To set refine instructions, provide the instruction text:",
                example: "chabeau set refine-instructions \"Custom refine instructions here\"",
            });
        }

        let value = args.join(" ");
        let display = truncate_with_ellipsis(&value, 50);

        mutate_config_with_message(
            move |config| {
                config.refine_instructions = Some(value);
                Ok(())
            },
            success_set("refine-instructions", &display),
        )
    }

    fn unset(
        &self,
        _args: Option<&str>,
        _ctx: &mut SetContext<'_>,
    ) -> Result<String, SettingError> {
        mutate_config_with_message(
            |config| {
                config.refine_instructions = None;
                Ok(())
            },
            "✅ Unset refine-instructions (will use default)".to_string(),
        )
    }

    fn format(&self, config: &Config) -> String {
        match &config.refine_instructions {
            Some(instructions) => {
                let flat = instructions.replace('\n', " ");
                let display = truncate_with_ellipsis(&flat, 50);
                format!("  refine-instructions: {display}")
            }
            None => {
                let default_preview = truncate_with_ellipsis(
                    &DEFAULT_REFINE_INSTRUCTIONS.trim().replace('\n', " "),
                    40,
                );
                format!("  refine-instructions: (unset, default: {default_preview})")
            }
        }
    }
}

/// Truncate a string to `max_chars` characters, appending "..." if truncated.
fn truncate_with_ellipsis(s: &str, max_chars: usize) -> String {
    let mut chars = s.chars();
    let truncated: String = chars.by_ref().take(max_chars).collect();
    if chars.next().is_some() {
        format!("{truncated}...")
    } else {
        truncated
    }
}

/// Handler for the `refine-prefix` setting.
pub struct RefinePrefixHandler;

impl SettingHandler for RefinePrefixHandler {
    fn key(&self) -> &'static str {
        "refine-prefix"
    }

    fn set(&self, args: &[String], _ctx: &mut SetContext<'_>) -> Result<String, SettingError> {
        if args.is_empty() {
            return Err(SettingError::MissingArgs {
                hint: "To set the refine prefix, provide the prefix text:",
                example: "chabeau set refine-prefix \"REVISE:\"",
            });
        }

        let value = args.join(" ");
        let message = success_set("refine-prefix", &value);

        mutate_config_with_message(
            move |config| {
                config.refine_prefix = Some(value);
                Ok(())
            },
            message,
        )
    }

    fn unset(
        &self,
        _args: Option<&str>,
        _ctx: &mut SetContext<'_>,
    ) -> Result<String, SettingError> {
        mutate_config_with_message(
            |config| {
                config.refine_prefix = None;
                Ok(())
            },
            format!(
                "✅ Unset refine-prefix (will use default: {})",
                DEFAULT_REFINE_PREFIX
            ),
        )
    }

    fn format(&self, config: &Config) -> String {
        match &config.refine_prefix {
            Some(prefix) => format!("  refine-prefix: {prefix}"),
            None => format!("  refine-prefix: (unset, default: {DEFAULT_REFINE_PREFIX})"),
        }
    }
}