pkg/config/import_test.go:16:9: G306: Expect WriteFile permissions to be 0600 or less (gosec)
	err := os.WriteFile(filePath, []byte(content), 0o644)
	       ^

pkg/config/import_test.go:38:8: G306: Expect WriteFile permissions to be 0600 or less (gosec)
	err = os.WriteFile(configFile1, []byte("key1: value1"), 0o644)
	      ^

pkg/config/import_test.go:42:8: G306: Expect WriteFile permissions to be 0600 or less (gosec)
	err = os.WriteFile(configFile2, []byte("key2: value2"), 0o644)
	      ^

pkg/config/import_test.go:47:8: G306: Expect WriteFile permissions to be 0600 or less (gosec)
	err = os.WriteFile(localFile, []byte("key3: value3"), 0o644)
	      ^

pkg/config/import_test.go:54:8: G306: Expect WriteFile permissions to be 0600 or less (gosec)
	err = os.WriteFile(configFile3, []byte("key4: value4"), 0o644)
	      ^

pkg/config/imports.go:128:65: add-constant: string literal "error" appears, at least, 4 times, create a named constant for it (revive)
		log.Debug("failed to read remote config", "path", importPath, "error", err)
		                                                              ^

pkg/config/load.go:242:68: add-constant: string literal "error" appears, at least, 4 times, create a named constant for it (revive)
		log.Debug("Failed to find atmos config file", "path", searchDir, "error", err)
		                                                                 ^

pkg/config/imports.go:148:50: add-constant: string literal "import" appears, at least, 4 times, create a named constant for it (revive)
			log.Debug("failed to process nested imports", "import", importPath, "err", err)
			                                              ^

pkg/config/load.go:250:43: add-constant: string literal "path" appears, at least, 4 times, create a named constant for it (revive)
			log.Debug("error loading config file", "path", filePath, "error", err)
			                                       ^

pkg/config/imports.go:173:52: add-constant: string literal "path" appears, at least, 4 times, create a named constant for it (revive)
		log.Debug("failed to resolve local import path", "path", importPath, "err", err)
		                                                 ^

pkg/config/load.go:26:1: cyclomatic: function LoadConfig has cyclomatic complexity 13 (> max enabled 10) (revive)
func LoadConfig(configAndStacksInfo schema.ConfigAndStacksInfo) (schema.AtmosConfiguration, error) {
	v := viper.New()
	var atmosConfig schema.AtmosConfiguration
	v.SetConfigType("yaml")
	v.SetTypeByDefaultValue(true)
	setDefaultConfiguration(v)
	err := readSystemConfig(v)
	if err != nil {
		return atmosConfig, err
	}

	err = readHomeConfig(v)
	if err != nil {
		return atmosConfig, err
	}

	err = readWorkDirConfig(v)
	if err != nil {
		return atmosConfig, err
	}
	err = readEnvAmosConfigPath(v)
	if err != nil {
		return atmosConfig, err
	}
	err = readAtmosConfigCli(v, configAndStacksInfo.AtmosCliConfigPath)
	if err != nil {
		return atmosConfig, err
	}

	atmosConfig.CliConfigPath = v.ConfigFileUsed()

	if atmosConfig.CliConfigPath == "" {
		log.Debug("'atmos.yaml' CLI config was not found", "paths", "system dir, home dir, current dir, ENV vars")
		log.Debug("Refer to https://atmos.tools/cli/configuration for details on how to configure 'atmos.yaml'")
		log.Debug("Using the default CLI config")
		j, err := json.Marshal(defaultCliConfig)
		if err != nil {
			return atmosConfig, err
		}
		reader := bytes.NewReader(j)
		err = v.MergeConfig(reader)
		if err != nil {
			return atmosConfig, err
		}
	}
	// Set the CLI config path in the atmosConfig struct
	if atmosConfig.CliConfigPath != "" && !filepath.IsAbs(atmosConfig.CliConfigPath) {
		absPath, err := filepath.Abs(atmosConfig.CliConfigPath)
		if err != nil {
			return atmosConfig, err
		}
		atmosConfig.CliConfigPath = absPath
	}
	// 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)
	if err != nil {
		return atmosConfig, err
	}
	return atmosConfig, nil
}

pkg/config/utils.go:800: file-length-limit: file length is 667 lines, which exceeds the limit of 500 (revive)

pkg/config/imports.go:68:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"base_Path required to process imports\")" (err113)
		return nil, fmt.Errorf("base_Path required to process imports")
		            ^

pkg/config/imports.go:71:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"tempDir required to process imports\")" (err113)
		return nil, fmt.Errorf("tempDir required to process imports")
		            ^

pkg/config/imports.go:74:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"maximum import depth of %d exceeded\", maxDepth)" (err113)
		return nil, fmt.Errorf("maximum import depth of %d exceeded", maxDepth)
		            ^

pkg/config/imports.go:78:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"failed to resolve base path: %v\", err)" (err113)
		return nil, fmt.Errorf("failed to resolve base path: %v", err)
		            ^

pkg/config/imports.go:117:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"unsupported URL '%s': %v\", importPath, err)" (err113)
		return nil, fmt.Errorf("unsupported URL '%s': %v", importPath, err)
		            ^

pkg/config/imports.go:129:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"failed to read remote config\")" (err113)
		return nil, fmt.Errorf("failed to read remote config")
		            ^

pkg/config/imports.go:149:16: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"failed to process nested imports\")" (err113)
			return nil, fmt.Errorf("failed to process nested imports")
			            ^

pkg/config/imports.go:160:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"import_path required to process imports\")" (err113)
		return nil, fmt.Errorf("import_path required to process imports")
		            ^

pkg/config/imports.go:174:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"failed to resolve local import path\")" (err113)
		return nil, fmt.Errorf("failed to resolve local import path")
		            ^

pkg/config/imports.go:283:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"no valid absolute paths found\")" (err113)
		return nil, fmt.Errorf("no valid absolute paths found")
		            ^

pkg/config/imports.go:373:15: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"no files matching patterns found\")" (err113)
		return nil, fmt.Errorf("no files matching patterns found")
		            ^

pkg/config/load.go:226:10: do not define dynamic errors, use wrapped static errors instead: "fmt.Errorf(\"atmos config directory not found path %s\", dirPath)" (err113)
		return fmt.Errorf("atmos config directory not found path %s", dirPath)
		       ^

pkg/config/imports.go:250:24: filepathJoin: "**/*.yaml" contains a path separator (gocritic)
			filepath.Join(path, "**/*.yaml"),
			                    ^