feat: add image file validation and format detection for image generation

## CHANGES

• Add image file path validation with extension checking
• Implement dynamic output format detection from file extensions
• Update BuildChatOptions method to return error for validation
• Add comprehensive test coverage for image file validation
• Upgrade YAML library from v2 to v3
• Update shell completions to reflect supported image formats
• Add error handling for existing file conflicts
• Support PNG, JPEG, JPG, and WEBP image formats

cli/cli.go

@@ -270,7 +270,11 @@ func Cli(version string) (err error) {
 	if chatReq.Language == "" {
 		chatReq.Language = registry.Language.DefaultLanguage.Value
 	}
-	if session, err = chatter.Send(chatReq, currentFlags.BuildChatOptions()); err != nil {
+	var chatOptions *common.ChatOptions
+	if chatOptions, err = currentFlags.BuildChatOptions(); err != nil {
+		return
+	}
+	if session, err = chatter.Send(chatReq, chatOptions); err != nil {
 		return
 	}
 

cli/flags.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"reflect"
 	"strconv"
 	"strings"
@@ -14,7 +15,7 @@ import (
 	"github.com/danielmiessler/fabric/common"
 	"github.com/jessevdk/go-flags"
 	"golang.org/x/text/language"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 // Flags create flags struct. the users flags go into this, this will be passed to the chat struct in cli
@@ -257,7 +258,36 @@ func readStdin() (ret string, err error) {
 	return
 }
 
-func (o *Flags) BuildChatOptions() (ret *common.ChatOptions) {
+// validateImageFile validates the image file path and extension
+func validateImageFile(imagePath string) error {
+	if imagePath == "" {
+		return nil // No validation needed if no image file specified
+	}
+
+	// Check if file already exists
+	if _, err := os.Stat(imagePath); err == nil {
+		return fmt.Errorf("image file already exists: %s", imagePath)
+	}
+
+	// Check file extension
+	ext := strings.ToLower(filepath.Ext(imagePath))
+	validExtensions := []string{".png", ".jpeg", ".jpg", ".webp"}
+
+	for _, validExt := range validExtensions {
+		if ext == validExt {
+			return nil // Valid extension found
+		}
+	}
+
+	return fmt.Errorf("invalid image file extension '%s'. Supported formats: .png, .jpeg, .jpg, .webp", ext)
+}
+
+func (o *Flags) BuildChatOptions() (ret *common.ChatOptions, err error) {
+	// Validate image file if specified
+	if err = validateImageFile(o.ImageFile); err != nil {
+		return nil, err
+	}
+
 	ret = &common.ChatOptions{
 		Temperature:        o.Temperature,
 		TopP:               o.TopP,

cli/flags_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io"
 	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -64,7 +65,8 @@ func TestBuildChatOptions(t *testing.T) {
 		Raw:              false,
 		Seed:             1,
 	}
-	options := flags.BuildChatOptions()
+	options, err := flags.BuildChatOptions()
+	assert.NoError(t, err)
 	assert.Equal(t, expectedOptions, options)
 }
 
@@ -84,7 +86,8 @@ func TestBuildChatOptionsDefaultSeed(t *testing.T) {
 		Raw:              false,
 		Seed:             0,
 	}
-	options := flags.BuildChatOptions()
+	options, err := flags.BuildChatOptions()
+	assert.NoError(t, err)
 	assert.Equal(t, expectedOptions, options)
 }
 
@@ -164,3 +167,91 @@ model: 123  # should be string
 		assert.Error(t, err)
 	})
 }
+
+func TestValidateImageFile(t *testing.T) {
+	t.Run("Empty path should be valid", func(t *testing.T) {
+		err := validateImageFile("")
+		assert.NoError(t, err)
+	})
+
+	t.Run("Valid extensions should pass", func(t *testing.T) {
+		validExtensions := []string{".png", ".jpeg", ".jpg", ".webp"}
+		for _, ext := range validExtensions {
+			filename := "/tmp/test" + ext
+			err := validateImageFile(filename)
+			assert.NoError(t, err, "Extension %s should be valid", ext)
+		}
+	})
+
+	t.Run("Invalid extensions should fail", func(t *testing.T) {
+		invalidExtensions := []string{".gif", ".bmp", ".tiff", ".svg", ".txt", ""}
+		for _, ext := range invalidExtensions {
+			filename := "/tmp/test" + ext
+			err := validateImageFile(filename)
+			assert.Error(t, err, "Extension %s should be invalid", ext)
+			assert.Contains(t, err.Error(), "invalid image file extension")
+		}
+	})
+
+	t.Run("Existing file should fail", func(t *testing.T) {
+		// Create a temporary file
+		tempFile, err := os.CreateTemp("", "test*.png")
+		assert.NoError(t, err)
+		defer os.Remove(tempFile.Name())
+		tempFile.Close()
+
+		// Validation should fail because file exists
+		err = validateImageFile(tempFile.Name())
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "image file already exists")
+	})
+
+	t.Run("Non-existing file with valid extension should pass", func(t *testing.T) {
+		nonExistentFile := filepath.Join(os.TempDir(), "non_existent_file.png")
+		// Make sure the file doesn't exist
+		os.Remove(nonExistentFile)
+
+		err := validateImageFile(nonExistentFile)
+		assert.NoError(t, err)
+	})
+}
+
+func TestBuildChatOptionsWithImageFileValidation(t *testing.T) {
+	t.Run("Valid image file should pass", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile: "/tmp/output.png",
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.NoError(t, err)
+		assert.Equal(t, "/tmp/output.png", options.ImageFile)
+	})
+
+	t.Run("Invalid extension should fail", func(t *testing.T) {
+		flags := &Flags{
+			ImageFile: "/tmp/output.gif",
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.Error(t, err)
+		assert.Nil(t, options)
+		assert.Contains(t, err.Error(), "invalid image file extension")
+	})
+
+	t.Run("Existing file should fail", func(t *testing.T) {
+		// Create a temporary file
+		tempFile, err := os.CreateTemp("", "existing*.png")
+		assert.NoError(t, err)
+		defer os.Remove(tempFile.Name())
+		tempFile.Close()
+
+		flags := &Flags{
+			ImageFile: tempFile.Name(),
+		}
+
+		options, err := flags.BuildChatOptions()
+		assert.Error(t, err)
+		assert.Nil(t, options)
+		assert.Contains(t, err.Error(), "image file already exists")
+	})
+}