codexctl 0.9.0

Codex Controller - Full control plane for Codex CLI
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
131
132
133
134
135
136
137
138
139

use crate::utils::config::Config;
use crate::utils::validation::ProfileName;
use anyhow::{Context as _, Result};
use colored::Colorize as _;
use prettytable::{Cell, Row, Table, format};
use std::collections::HashMap;

#[allow(clippy::too_many_lines)]
pub async fn execute(
    config: Config,
    profile1: String,
    profile2: String,
    changes_only: bool,
    quiet: bool,
) -> Result<()> {
    let name1 = ProfileName::try_from(profile1.as_str())
        .with_context(|| format!("Invalid profile name '{profile1}'"))?;
    let name2 = ProfileName::try_from(profile2.as_str())
        .with_context(|| format!("Invalid profile name '{profile2}'"))?;
    let dir1 = config.profile_path_validated(&name1)?;
    let dir2 = config.profile_path_validated(&name2)?;

    if !dir1.exists() {
        anyhow::bail!("Profile '{profile1}' not found");
    }
    if !dir2.exists() {
        anyhow::bail!("Profile '{profile2}' not found");
    }

    if !quiet {
        println!(
            "\n{} Comparing profiles: {} vs {}",
            "🔍".cyan(),
            profile1.green(),
            profile2.yellow()
        );
    }

    // Get file listings for both profiles
    let files1 = get_profile_files(&dir1).await?;
    let files2 = get_profile_files(&dir2).await?;

    // Compare files
    let mut table = Table::new();
    table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);

    // Header
    table.add_row(Row::new(vec![
        Cell::new("File").style_spec("Fb"),
        Cell::new(&profile1.clone()).style_spec("Fg"),
        Cell::new(&profile2.clone()).style_spec("Fy"),
        Cell::new("Status").style_spec("Fb"),
    ]));

    // Get all unique files
    let mut all_files: Vec<String> = files1.keys().cloned().collect();
    for file in files2.keys() {
        if !all_files.contains(file) {
            all_files.push(file.clone());
        }
    }
    all_files.sort();

    let mut differences = 0;

    for file in &all_files {
        let (content1, content2) = (
            files1.get(file).map(Vec::as_slice),
            files2.get(file).map(Vec::as_slice),
        );

        let status = match (content1, content2) {
            (Some(c1), Some(c2)) => {
                if c1 == c2 {
                    if changes_only {
                        continue;
                    }
                    "✓ Same".to_string()
                } else {
                    differences += 1;
                    format!("{} Different", "≠".yellow())
                }
            }
            (Some(_), None) => {
                differences += 1;
                format!("{} Only in {}", "→".green(), profile1)
            }
            (None, Some(_)) => {
                differences += 1;
                format!("{} Only in {}", "→".yellow(), profile2)
            }
            (None, None) => unreachable!(),
        };

        let size1 = content1.map_or_else(|| "-".to_string(), |c| format!("{} bytes", c.len()));
        let size2 = content2.map_or_else(|| "-".to_string(), |c| format!("{} bytes", c.len()));

        table.add_row(Row::new(vec![
            Cell::new(file),
            Cell::new(&size1),
            Cell::new(&size2),
            Cell::new(&status),
        ]));
    }

    if !all_files.is_empty() {
        table.printstd();
    }

    if !quiet {
        println!();
        if differences == 0 {
            println!("{} Profiles are identical!", "✓".green());
        } else {
            println!("{} {} difference(s) found", "!".yellow(), differences);
        }
    }

    Ok(())
}

async fn get_profile_files(dir: &std::path::Path) -> Result<HashMap<String, Vec<u8>>> {
    let mut files = HashMap::new();

    let mut entries = tokio::fs::read_dir(dir).await?;
    while let Some(entry) = entries.next_entry().await? {
        let path = entry.path();
        if path.is_file() {
            let name = path
                .file_name()
                .map(|s| s.to_string_lossy().to_string())
                .unwrap_or_default();
            let content = tokio::fs::read(&path).await?;
            files.insert(name, content);
        }
    }

    Ok(files)
}