claude-code-status-line 1.3.0

A configurable status line for Claude Code with powerline arrows, context tracking, and quota monitoring
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

use std::io::{self, Read};

use claude_code_status_line::app::{parse_claude_input, render_statusline_with_width};
use claude_code_status_line::commands::{self, InstallOutcome};
use claude_code_status_line::config::load_config;
use claude_code_status_line::utils::{get_home_dir, get_terminal_width};

fn main() {
    const VERSION: &str = env!("CARGO_PKG_VERSION");
    const PKG_NAME: &str = env!("CARGO_PKG_NAME");

    if std::env::args().any(|a| a == "--version" || a == "-V") {
        println!("{} {}", PKG_NAME, VERSION);
        return;
    }

    if std::env::args().any(|a| a == "--help" || a == "-h") {
        println!(
            "{} {} - Beautiful statusline for Claude Code",
            PKG_NAME, VERSION
        );
        println!("\nUsage:");
        println!(
            "  Receives JSON on stdin from Claude Code, outputs formatted statusline to stdout"
        );
        println!("\nOptions:");
        println!("  --version, -V        Show version");
        println!("  --install-commands   Install/update slash commands in ~/.claude/commands/ (honours CLAUDE_CONFIG_DIR)");
        println!("  --help, -h           Show this help");
        println!("\nConfiguration:");
        println!("  ~/.claude/statusline/settings.json   - Statusline settings");
        println!("  ~/.claude/statusline/colors.json     - Color customization");
        println!("\nSlash Commands:");
        println!("  /install-statusline     - Interactive installation wizard");
        println!("  /update-statusline      - Update to latest version");
        println!("  /customize-statusline   - Interactive configuration wizard");
        println!("  /uninstall-statusline   - Remove the statusline");
        println!("\nDocumentation:");
        println!("  https://crates.io/crates/claude-code-status-line");
        println!("  https://ndave92.github.io/claude-code-status-line/");
        return;
    }

    if std::env::args().any(|a| a == "--install-commands") {
        std::process::exit(install_commands());
    }

    let config = load_config();

    let mut input_str = String::new();
    if io::stdin().read_to_string(&mut input_str).is_err() {
        eprintln!("statusline error: failed to read stdin");
        println!();
        return;
    }

    let input = match parse_claude_input(&input_str) {
        Ok(input) => input,
        Err(_) => {
            eprintln!("statusline error: invalid JSON");
            println!();
            return;
        }
    };

    let term_width = get_terminal_width(&config);

    if std::env::var("STATUSLINE_DEBUG").is_ok() {
        eprintln!("Debug: term_width detected as {}", term_width);
    }

    let lines = render_statusline_with_width(&input, &config, term_width);

    for line in lines {
        println!("{}", line);
    }
}

fn install_commands() -> i32 {
    // Claude Code reads commands from CLAUDE_CONFIG_DIR when it is set.
    let config_dir = match std::env::var_os("CLAUDE_CONFIG_DIR").filter(|dir| !dir.is_empty()) {
        Some(dir) => std::path::PathBuf::from(dir),
        None => match get_home_dir() {
            Some(home) => home.join(".claude"),
            None => {
                eprintln!("error: could not determine home directory");
                return 1;
            }
        },
    };
    let dir = config_dir.join("commands");

    match commands::install_commands(&dir) {
        Ok(results) => {
            for (name, outcome) in results {
                match outcome {
                    InstallOutcome::Installed => println!("installed  {}", name),
                    InstallOutcome::UpToDate => println!("up to date {}", name),
                    InstallOutcome::Updated { backup } => {
                        println!(
                            "updated    {} (previous saved to {})",
                            name,
                            backup.display()
                        )
                    }
                }
            }
            println!("Commands directory: {}", dir.display());
            0
        }
        Err(err) => {
            eprintln!(
                "error: failed to install commands into {}: {}",
                dir.display(),
                err
            );
            1
        }
    }
}