Add no-color support for atmos

cmd/root.go

@@ -95,6 +95,17 @@
 		log.SetLevel(log.InfoLevel)
 	}
 
+	if atmosConfig.Settings.Terminal.NoColor {
+		styles := log.DefaultStyles()
+		// Clear colors for levels
+		styles.Levels[log.DebugLevel] = styles.Levels[log.DebugLevel].UnsetForeground()
+		styles.Levels[log.InfoLevel] = styles.Levels[log.InfoLevel].UnsetForeground()
+		styles.Levels[log.WarnLevel] = styles.Levels[log.WarnLevel].UnsetForeground()
+		styles.Levels[log.ErrorLevel] = styles.Levels[log.ErrorLevel].UnsetForeground()
+		styles.Levels[log.FatalLevel] = styles.Levels[log.FatalLevel].UnsetForeground()
+
+		log.SetStyles(styles)
+	}
 	var output io.Writer
 
 	switch atmosConfig.Logs.File {
@@ -194,6 +205,7 @@
 	RootCmd.PersistentFlags().String("base-path", "", "Base path for Atmos project")
 	RootCmd.PersistentFlags().StringSlice("config", []string{}, "Paths to configuration files (comma-separated or repeated flag)")
 	RootCmd.PersistentFlags().StringSlice("config-path", []string{}, "Paths to configuration directories (comma-separated or repeated flag)")
+	RootCmd.PersistentFlags().Bool("no-color", false, "Disable color output")
 	// Set custom usage template
 	err := templates.SetCustomUsageFunc(RootCmd)
 	if err != nil {

cmd/validate_editorconfig.go

@@ -116,8 +116,9 @@
 			cliConfig.Verbose = true
 		}
 	}
-	if !cmd.Flags().Changed("no-color") && !atmosConfig.Validate.EditorConfig.Color {
-		cliConfig.NoColor = !atmosConfig.Validate.EditorConfig.Color
+	cliConfig.NoColor = atmosConfig.Settings.Terminal.NoColor
+	if atmosConfig.Settings.Terminal.NoColor {
+		cliConfig.NoColor = atmosConfig.Settings.Terminal.NoColor
 	}
 	if !cmd.Flags().Changed("disable-trim-trailing-whitespace") && atmosConfig.Validate.EditorConfig.DisableTrimTrailingWhitespace {
 		cliConfig.Disable.TrimTrailingWhitespace = atmosConfig.Validate.EditorConfig.DisableTrimTrailingWhitespace
@@ -192,7 +193,6 @@
 	cmd.PersistentFlags().BoolVar(&cliConfig.DryRun, "dry-run", false, "Show which files would be checked")
 	cmd.PersistentFlags().BoolVar(&cliConfig.ShowVersion, "version", false, "Print the version number")
 	cmd.PersistentFlags().StringVar(&format, "format", "default", "Specify the output format: default, gcc")
-	cmd.PersistentFlags().BoolVar(&cliConfig.NoColor, "no-color", false, "Don't print colors")
 	cmd.PersistentFlags().BoolVar(&cliConfig.Disable.TrimTrailingWhitespace, "disable-trim-trailing-whitespace", false, "Disable trailing whitespace check")
 	cmd.PersistentFlags().BoolVar(&cliConfig.Disable.EndOfLine, "disable-end-of-line", false, "Disable end-of-line check")
 	cmd.PersistentFlags().BoolVar(&cliConfig.Disable.InsertFinalNewline, "disable-insert-final-newline", false, "Disable final newline check")

pkg/config/config.go

@@ -77,6 +77,11 @@
 	if v, ok := flagKeyValue["logs-file"]; ok {
 		atmosConfig.Logs.File = v
 	}
+	if flagKeyValue, ok := flagKeyValue["no-color"]; ok || flagKeyValue == "true" {
+		atmosConfig.Settings.Terminal.NoColor = true
+	} else if flagKeyValue == "false" {
+		atmosConfig.Settings.Terminal.NoColor = false
+	}
 }
 
 // TODO: This function works well, but we should generally avoid implementing manual flag parsing,

pkg/config/default.go

@@ -56,7 +56,6 @@ var (
 			Terminal: schema.Terminal{
 				MaxWidth: templates.GetTerminalWidth(),
 				Pager:    true,
-				Colors:   true,
 				Unicode:  true,
 				SyntaxHighlighting: schema.SyntaxHighlighting{
 					Enabled:                true,

pkg/config/load.go

@@ -75,8 +75,6 @@ func LoadConfig(configAndStacksInfo *schema.ConfigAndStacksInfo) (schema.AtmosCo
 		}
 	}
 	setEnv(v)
-	// We want the editorconfig color by default to be true
-	atmosConfig.Validate.EditorConfig.Color = true
 	// https://gist.github.com/chazcheadle/45bf85b793dea2b71bd05ebaa3c28644
 	// https://sagikazarmark.hu/blog/decoding-custom-formats-with-viper/
 	err := v.Unmarshal(&atmosConfig)
@@ -99,6 +97,8 @@ func setEnv(v *viper.Viper) {
 	bindEnv(v, "settings.gitlab_token", "GITLAB_TOKEN")
 	bindEnv(v, "settings.inject_gitlab_token", "ATMOS_INJECT_GITLAB_TOKEN")
 	bindEnv(v, "settings.atmos_gitlab_token", "ATMOS_GITLAB_TOKEN")
+
+	bindEnv(v, "settings.terminal.no_color", "ATMOS_NO_COLOR", "NO_COLOR")
 }
 
 func bindEnv(v *viper.Viper, key ...string) {
@@ -115,6 +115,7 @@ func setDefaultConfiguration(v *viper.Viper) {
 	v.SetDefault("settings.inject_github_token", true)
 	v.SetDefault("logs.file", "/dev/stderr")
 	v.SetDefault("logs.level", "Info")
+	v.SetDefault("settings.terminal.no_color", false)
 }
 
 // loadConfigSources delegates reading configs from each source,

pkg/schema/schema.go

@@ -173,7 +173,6 @@ type EditorConfig struct {
 	IgnoreDefaults  bool     `yaml:"ignore_defaults,omitempty" json:"ignore_defaults,omitempty" mapstructure:"ignore_defaults"`
 	DryRun          bool     `yaml:"dry_run,omitempty" json:"dry_run,omitempty" mapstructure:"dry_run"`
 	Format          string   `yaml:"format,omitempty" json:"format,omitempty" mapstructure:"format"`
-	Color           bool     `yaml:"color,omitempty" json:"color,omitempty" mapstructure:"color"`
 	ConfigFilePaths []string `yaml:"config_file_paths,omitempty" json:"config_file_paths,omitempty" mapstructure:"config_file_paths"`
 	Exclude         []string `yaml:"exclude,omitempty" json:"exclude,omitempty" mapstructure:"exclude"`
 	Init            bool     `yaml:"init,omitempty" json:"init,omitempty" mapstructure:"init"`
@@ -189,9 +188,9 @@ type EditorConfig struct {
 type Terminal struct {
 	MaxWidth           int                `yaml:"max_width" json:"max_width" mapstructure:"max_width"`
 	Pager              bool               `yaml:"pager" json:"pager" mapstructure:"pager"`
-	Colors             bool               `yaml:"colors" json:"colors" mapstructure:"colors"`
 	Unicode            bool               `yaml:"unicode" json:"unicode" mapstructure:"unicode"`
 	SyntaxHighlighting SyntaxHighlighting `yaml:"syntax_highlighting" json:"syntax_highlighting" mapstructure:"syntax_highlighting"`
+	NoColor            bool               `yaml:"no_color" json:"no_color" mapstructure:"no_color"`
 }
 
 type SyntaxHighlighting struct {

pkg/ui/markdown/renderer.go

@@ -14,24 +14,43 @@
 
 // Renderer is a markdown renderer using Glamour
 type Renderer struct {
-	renderer    *glamour.TermRenderer
-	width       uint
-	profile     termenv.Profile
-	atmosConfig *schema.AtmosConfiguration
+	renderer              *glamour.TermRenderer
+	width                 uint
+	profile               termenv.Profile
+	atmosConfig           *schema.AtmosConfiguration
+	isTTYSupportForStdout func() bool
+	isTTYSupportForStderr func() bool
 }
 
 // NewRenderer creates a new markdown renderer with the given options
 func NewRenderer(atmosConfig schema.AtmosConfiguration, opts ...Option) (*Renderer, error) {
 	r := &Renderer{
-		width:   80,                     // default width
-		profile: termenv.ColorProfile(), // default color profile
+		width:                 80,                     // default width
+		profile:               termenv.ColorProfile(), // default color profile
+		isTTYSupportForStdout: term.IsTTYSupportForStdout,
+		isTTYSupportForStderr: term.IsTTYSupportForStderr,
 	}
 
 	// Apply options
 	for _, opt := range opts {
 		opt(r)
 	}
 
+	if atmosConfig.Settings.Terminal.NoColor {
+		renderer, err := glamour.NewTermRenderer(
+			glamour.WithAutoStyle(),
+			glamour.WithWordWrap(int(r.width)),
+			glamour.WithColorProfile(r.profile),
+			glamour.WithEmoji(),
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		r.renderer = renderer
+		return r, nil
+	}
+
 	// Get default style
 	style, err := GetDefaultStyle(atmosConfig)
 	if err != nil {
@@ -66,7 +85,7 @@
 		return "", err
 	}
 	result := ""
-	if term.IsTTYSupportForStdout() {
+	if r.isTTYSupportForStdout() {
 		result, err = out.Render(content)
 	} else {
 		// Fallback to ASCII rendering for non-TTY stdout
@@ -79,7 +98,7 @@
 func (r *Renderer) Render(content string) (string, error) {
 	var rendered string
 	var err error
-	if term.IsTTYSupportForStdout() {
+	if r.isTTYSupportForStdout() {
 		rendered, err = r.renderer.Render(content)
 	} else {
 		// Fallback to ASCII rendering for non-TTY stdout
@@ -183,7 +202,7 @@
 
 // RenderErrorf renders an error message with specific styling
 func (r *Renderer) RenderErrorf(content string, args ...interface{}) (string, error) {
-	if term.IsTTYSupportForStderr() {
+	if r.isTTYSupportForStderr() {
 		return r.Render(content)
 	}
 	// Fallback to ASCII rendering for non-TTY stderr

pkg/ui/markdown/renderer_test.go

@@ -0,0 +1,53 @@
+package markdown
+
+import (
+	"testing"
+
+	"github.com/cloudposse/atmos/pkg/schema"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRenderer(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		expected    string
+		atmosConfig schema.AtmosConfiguration
+	}{
+		{
+			name:     "Test with no color",
+			input:    "## Hello **world**",
+			expected: "  ## Hello **world**",
+			atmosConfig: schema.AtmosConfiguration{
+				Settings: schema.AtmosSettings{
+					Terminal: schema.Terminal{
+						NoColor: true,
+					},
+				},
+			},
+		},
+		{
+			name:     "Test with color",
+			input:    "## Hello **world**",
+			expected: "\x1b[;1m\x1b[0m\x1b[;1m\x1b[0m\x1b[;1m## \x1b[0m\x1b[;1mHello \x1b[0m\x1b[;1m**\x1b[0m\x1b[;1mworld\x1b[0m\x1b[;1m**\x1b[0m",
+			atmosConfig: schema.AtmosConfiguration{
+				Settings: schema.AtmosSettings{
+					Terminal: schema.Terminal{
+						NoColor: false,
+					},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r, _ := NewRenderer(tt.atmosConfig)
+			r.isTTYSupportForStdout = func() bool {
+				return true
+			}
+			str, err := r.Render(tt.input)
+			assert.Contains(t, str, tt.expected)
+			assert.NoError(t, err)
+		})
+	}
+}