cai-output 0.1.0

Output formatters for Coding Agent Insights
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

//! CAI Output - Output formatters
//!
//! Trait-based output formatting for AI coding interaction data.

#![warn(missing_docs)]

pub mod formats;
pub mod formatter;

pub use formatter::{Formatter, FormatterConfig};

/// Re-export formatters
pub use formats::{
    AiFormatter, CsvFormatter, JsonFormatter, JsonlFormatter, StatsFormatter, TableFormatter,
};

/// Output format options
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum OutputFormat {
    /// Standard JSON array
    Json,
    /// JSON Lines (newline-delimited JSON)
    Jsonl,
    /// CSV with headers
    Csv,
    /// Pretty terminal table
    Table,
    /// AI-optimized compact format
    Ai,
    /// Summary statistics
    Stats,
}

/// Dynamic formatter that can hold any formatter type
#[non_exhaustive]
pub enum DynFormatter {
    /// JSON array formatter
    Json(JsonFormatter),
    /// JSON Lines formatter
    Jsonl(JsonlFormatter),
    /// CSV formatter
    Csv(CsvFormatter),
    /// Table formatter
    Table(TableFormatter),
    /// AI-optimized formatter
    Ai(AiFormatter),
    /// Statistics formatter
    Stats(StatsFormatter),
}

impl DynFormatter {
    /// Create formatter from output format
    pub fn from_format(format: OutputFormat) -> Self {
        match format {
            OutputFormat::Json => Self::Json(JsonFormatter::default()),
            OutputFormat::Jsonl => Self::Jsonl(JsonlFormatter::default()),
            OutputFormat::Csv => Self::Csv(CsvFormatter::default()),
            OutputFormat::Table => Self::Table(TableFormatter::default()),
            OutputFormat::Ai => Self::Ai(AiFormatter::default()),
            OutputFormat::Stats => Self::Stats(StatsFormatter::default()),
        }
    }

    /// Get the config for this formatter
    pub fn config(&self) -> &FormatterConfig {
        match self {
            Self::Json(f) => f.config(),
            Self::Jsonl(f) => f.config(),
            Self::Csv(f) => f.config(),
            Self::Table(f) => f.config(),
            Self::Ai(f) => f.config(),
            Self::Stats(f) => f.config(),
        }
    }

    /// Set config for this formatter
    pub fn set_config(&mut self, config: FormatterConfig) {
        match self {
            Self::Json(f) => f.set_config(config),
            Self::Jsonl(f) => f.set_config(config),
            Self::Csv(f) => f.set_config(config),
            Self::Table(f) => f.set_config(config),
            Self::Ai(f) => f.set_config(config),
            Self::Stats(f) => f.set_config(config),
        }
    }
}

// Delegate Formatter trait methods
macro_rules! delegate_formatter {
    ($($format:ident),*) => {
        impl Formatter for DynFormatter {
            fn format<W: std::io::Write>(&self, entries: &[cai_core::Entry], writer: &mut W) -> cai_core::Result<()> {
                match self {
                    $(Self::$format(f) => f.format(entries, writer),)*
                }
            }

            fn format_one<W: std::io::Write>(&self, entry: &cai_core::Entry, writer: &mut W) -> cai_core::Result<()> {
                match self {
                    $(Self::$format(f) => f.format_one(entry, writer),)*
                }
            }

            fn config(&self) -> &FormatterConfig {
                match self {
                    $(Self::$format(f) => f.config(),)*
                }
            }

            fn set_config(&mut self, config: FormatterConfig) {
                match self {
                    $(Self::$format(f) => f.set_config(config),)*
                }
            }
        }
    }
}

delegate_formatter!(Json, Jsonl, Csv, Table, Ai, Stats);