vibe-workspace 0.0.12

Extremely lightweight CLI for managing multiple git repositories and workspace configurations
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

//! Output configuration and mode management

use console::Term;
use tracing::Level;
use tracing_subscriber::EnvFilter;

/// Output mode for the application
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OutputMode {
    /// Normal CLI operation - display to stdout, logs to stderr
    Cli,
    /// MCP server mode - everything to stderr except protocol messages
    Mcp,
}

/// Configuration for the output system
#[derive(Debug)]
pub struct OutputConfig {
    mode: OutputMode,
    color_enabled: bool,
    log_level: Level,
}

impl OutputConfig {
    /// Create a new output configuration
    pub fn new(mode: OutputMode) -> Self {
        // Detect color support
        let color_enabled = match mode {
            OutputMode::Cli => Term::stdout().features().colors_supported(),
            OutputMode::Mcp => false, // Disable colors in MCP mode
        };

        // Determine log level from environment or defaults
        let log_level = match std::env::var("RUST_LOG") {
            Ok(level) => match level.to_lowercase().as_str() {
                "trace" => Level::TRACE,
                "debug" => Level::DEBUG,
                "info" => Level::INFO,
                "warn" => Level::WARN,
                "error" => Level::ERROR,
                _ => match mode {
                    OutputMode::Cli => Level::INFO,
                    OutputMode::Mcp => Level::WARN, // Less verbose in MCP mode
                },
            },
            Err(_) => match mode {
                OutputMode::Cli => Level::INFO,
                OutputMode::Mcp => Level::WARN,
            },
        };

        Self {
            mode,
            color_enabled,
            log_level,
        }
    }

    /// Get the current output mode
    pub fn mode(&self) -> OutputMode {
        self.mode
    }

    /// Check if colors are enabled
    pub fn colors_enabled(&self) -> bool {
        self.color_enabled
    }

    /// Get the current log level
    pub fn log_level(&self) -> Level {
        self.log_level
    }

    /// Set verbose mode (DEBUG level)
    pub fn set_verbose(&mut self) {
        self.log_level = Level::DEBUG;
    }

    /// Initialize the tracing subscriber based on configuration
    pub fn init_tracing(&self) {
        let builder = tracing_subscriber::fmt()
            .with_env_filter(EnvFilter::from_default_env().add_directive(self.log_level.into()))
            .with_target(false)
            .with_level(true);

        match self.mode {
            OutputMode::Cli => {
                // In CLI mode, logs go to stderr with colors if supported
                builder
                    .with_ansi(self.color_enabled)
                    .with_writer(std::io::stderr)
                    .init();
            }
            OutputMode::Mcp => {
                // In MCP mode, everything goes to stderr without colors
                builder
                    .with_ansi(false)
                    .with_writer(std::io::stderr)
                    .without_time() // Simpler format for MCP
                    .compact() // More compact format
                    .init();
            }
        }
    }
}