Merge branch 'main' into feat/atmos-list-upload

Author: milldr

pkg/config/atmos.yaml

@@ -12,3 +12,4 @@ settings:
     enabled: true
     endpoint: "https://us.i.posthog.com"
     token: "phc_7s7MrHWxPR2if1DHHDrKBRgx7SvlaoSM59fIiQueexS"
+    logging: false

pkg/config/load.go

@@ -122,6 +122,7 @@ func setEnv(v *viper.Viper) {
 	bindEnv(v, "settings.telemetry.enabled", "ATMOS_TELEMETRY_ENABLED")
 	bindEnv(v, "settings.telemetry.token", "ATMOS_TELEMETRY_TOKEN")
 	bindEnv(v, "settings.telemetry.endpoint", "ATMOS_TELEMETRY_ENDPOINT")
+	bindEnv(v, "settings.telemetry.logging", "ATMOS_TELEMETRY_LOGGING")
 }
 
 func bindEnv(v *viper.Viper, key ...string) {

pkg/downloader/file_downloader.go

@@ -44,6 +44,7 @@ func (fd *fileDownloader) Fetch(src, dest string, mode ClientMode, timeout time.
 // FetchAutoParse downloads a remote file, detects its format, and parses it.
 func (fd *fileDownloader) FetchAndAutoParse(src string) (any, error) {
 	filePath := fd.tempPathGenerator()
+	defer os.Remove(filePath)
 
 	if err := fd.Fetch(src, filePath, ClientModeFile, 30*time.Second); err != nil {
 		return nil, fmt.Errorf("failed to download file '%s': %w", src, err)
@@ -52,9 +53,41 @@ func (fd *fileDownloader) FetchAndAutoParse(src string) (any, error) {
 	return filetype.DetectFormatAndParseFile(fd.fileReader, filePath)
 }
 
+// FetchAndParseByExtension downloads a remote file and parses it based on its extension.
+func (fd *fileDownloader) FetchAndParseByExtension(src string) (any, error) {
+	filePath := fd.tempPathGenerator()
+	defer os.Remove(filePath)
+
+	if err := fd.Fetch(src, filePath, ClientModeFile, 30*time.Second); err != nil {
+		return nil, fmt.Errorf("failed to download file '%s': %w", src, err)
+	}
+
+	// Create a custom reader that reads the downloaded file but uses the original URL for extension detection
+	readFunc := func(filename string) ([]byte, error) {
+		// Read the actual downloaded file, not the URL
+		return fd.fileReader(filePath)
+	}
+
+	// Pass the original source URL for extension detection
+	return filetype.ParseFileByExtension(readFunc, src)
+}
+
+// FetchAndParseRaw downloads a remote file and always returns it as a raw string.
+func (fd *fileDownloader) FetchAndParseRaw(src string) (any, error) {
+	filePath := fd.tempPathGenerator()
+	defer os.Remove(filePath)
+
+	if err := fd.Fetch(src, filePath, ClientModeFile, 30*time.Second); err != nil {
+		return nil, fmt.Errorf("failed to download file '%s': %w", src, err)
+	}
+
+	return filetype.ParseFileRaw(fd.fileReader, filePath)
+}
+
 // FetchData fetches content from a given source and returns it as a byte slice.
 func (fd *fileDownloader) FetchData(src string) ([]byte, error) {
 	filePath := fd.tempPathGenerator()
+	defer os.Remove(filePath)
 
 	if err := fd.Fetch(src, filePath, ClientModeFile, 30*time.Second); err != nil {
 		return nil, fmt.Errorf("failed to download file '%s': %w", src, err)

pkg/downloader/file_downloader_interface.go

@@ -16,6 +16,12 @@ type FileDownloader interface {
 	// FetchAndAutoParse downloads a remote file, detects its format, and parses it
 	FetchAndAutoParse(src string) (any, error)
 
+	// FetchAndParseByExtension downloads a remote file and parses it based on its extension
+	FetchAndParseByExtension(src string) (any, error)
+
+	// FetchAndParseRaw downloads a remote file and always returns it as a raw string
+	FetchAndParseRaw(src string) (any, error)
+
 	// FetchData fetches content from a given source and returns it as a byte slice
 	FetchData(src string) ([]byte, error)
 }

pkg/downloader/mock_file_downloader_interface.go

@@ -0,0 +1,123 @@
+package filetype
+
+import (
+	pathpkg "path"
+	"path/filepath"
+	"strings"
+)
+
+// ParseFileByExtension parses a file based on its file extension.
+// It determines the format from the extension, not the content.
+// Supported extensions:
+// - .json → JSON parsing.
+// - .yaml, .yml → YAML parsing.
+// - .hcl, .tf, .tfvars → HCL parsing.
+// - All others (including .txt or no extension) → raw string.
+func ParseFileByExtension(readFileFunc func(string) ([]byte, error), filename string) (any, error) {
+	// Extract clean filename from potential URL.
+	cleanFilename := ExtractFilenameFromPath(filename)
+	ext := GetFileExtension(cleanFilename)
+
+	// Read the file content.
+	data, err := readFileFunc(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse based on extension.
+	return ParseByExtension(data, ext, filename)
+}
+
+// ParseFileRaw always returns the file content as a raw string,
+// regardless of the file extension or content.
+func ParseFileRaw(readFileFunc func(string) ([]byte, error), filename string) (any, error) {
+	data, err := readFileFunc(filename)
+	if err != nil {
+		return nil, err
+	}
+	return string(data), nil
+}
+
+// ParseByExtension parses data based on the provided extension.
+func ParseByExtension(data []byte, ext string, filename string) (any, error) {
+	switch ext {
+	case ".json":
+		return parseJSON(data)
+	case ".yaml", ".yml":
+		return parseYAML(data)
+	case ".hcl", ".tf", ".tfvars":
+		return parseHCL(data, filename)
+	default:
+		// Return as raw string for unknown extensions.
+		return string(data), nil
+	}
+}
+
+// ExtractFilenameFromPath extracts the actual filename from a path or URL.
+// It removes query strings and fragments from URLs.
+// Examples:
+//   - "https://example.com/file.json?v=1#section" → "file.json".
+//   - "/path/to/file.yaml" → "file.yaml".
+//   - "file.txt" → "file.txt".
+func ExtractFilenameFromPath(path string) string {
+	// Remove fragment (everything after #).
+	if idx := strings.Index(path, "#"); idx != -1 {
+		path = path[:idx]
+	}
+
+	// Remove query string (everything after ?).
+	if idx := strings.Index(path, "?"); idx != -1 {
+		path = path[:idx]
+	}
+
+	// For URLs, use path package instead of filepath to ensure forward slashes.
+	// This handles URLs correctly on Windows where filepath.Base expects backslashes.
+	if strings.Contains(path, "://") {
+		// Use path package for URLs (always uses forward slashes).
+		return pathpkg.Base(path)
+	}
+
+	// For local files, use filepath package (handles OS-specific separators).
+	return filepath.Base(path)
+}
+
+// GetFileExtension returns the lowercase file extension including the dot.
+// Examples:
+//   - "file.json" → ".json".
+//   - "FILE.JSON" → ".json".
+//   - "file.backup.json" → ".json".
+//   - "file" → "".
+//   - ".hidden" → "".
+func GetFileExtension(filename string) string {
+	// Handle special cases.
+	if filename == "" || filename == "." {
+		return ""
+	}
+
+	ext := filepath.Ext(filename)
+
+	// If the extension is the whole filename (e.g., ".env"), check if it looks like a known extension.
+	if ext == filename {
+		// Check if it's actually an extension (has letters after the dot).
+		if len(ext) > 1 && !strings.Contains(ext[1:], ".") {
+			// It looks like an extension file (e.g., ".json", ".yaml").
+			// Check if it's a known extension.
+			lowerExt := strings.ToLower(ext)
+			knownExts := []string{".json", ".yaml", ".yml", ".hcl", ".tf", ".tfvars", ".txt", ".md"}
+			for _, known := range knownExts {
+				if lowerExt == known {
+					return lowerExt
+				}
+			}
+		}
+		// Otherwise it's a hidden file without an extension (e.g., ".env", ".gitignore").
+		return ""
+	}
+
+	// If filename ends with a dot, there's no extension.
+	if ext == "." {
+		return ""
+	}
+
+	return strings.ToLower(ext)
+}