@ means read file

This is made popular by other prompts

Signed-off-by: Eric Curtin <eric.curtin@docker.com>

Author: ericcurtin

cmd/cli/commands/file_completion.go

@@ -0,0 +1,105 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// getFileSuggestions returns a list of files in the current or specified directory
+// that match the given prefix
+func getFileSuggestions(prefix string) []string {
+	var suggestions []string
+
+	// Determine the directory to look in
+	dir := "."
+	basePath := prefix
+
+	// If prefix contains directory separators, split the path
+	if strings.Contains(prefix, "/") || strings.Contains(prefix, string(os.PathSeparator)) {
+		lastSep := strings.LastIndexAny(prefix, "/\\")
+		if lastSep >= 0 {
+			dir = prefix[:lastSep+1]
+			basePath = prefix[lastSep+1:]
+		}
+	} else {
+		basePath = prefix
+	}
+
+	// Clean the directory path for security
+	cleanDir := filepath.Clean(dir)
+
+	// Read the directory contents
+	entries, err := os.ReadDir(cleanDir)
+	if err != nil {
+		return suggestions
+	}
+
+	// Filter entries based on the prefix
+	for _, entry := range entries {
+		name := entry.Name()
+		// Only include files/directories that match the prefix
+		if strings.HasPrefix(name, basePath) {
+			// If it's a directory, add a trailing slash
+			if entry.IsDir() {
+				suggestions = append(suggestions, filepath.Join(cleanDir, name)+string(os.PathSeparator))
+			} else {
+				suggestions = append(suggestions, filepath.Join(cleanDir, name))
+			}
+		}
+	}
+
+	// Sort suggestions
+	sort.Strings(suggestions)
+
+	// Format suggestions to be relative to the original prefix directory
+	if strings.Contains(prefix, "/") || strings.Contains(prefix, string(os.PathSeparator)) {
+		lastSep := strings.LastIndexAny(prefix, "/\\")
+		if lastSep >= 0 {
+			originalDir := prefix[:lastSep+1]
+			for i, suggestion := range suggestions {
+				// Remove the cleanDir prefix and add back the original directory prefix
+				trimmed := strings.TrimPrefix(suggestion, cleanDir+"/")
+				suggestions[i] = originalDir + trimmed
+			}
+		}
+	}
+
+	return suggestions
+}
+
+// printFileSuggestions prints file suggestions to stdout in a formatted way
+func printFileSuggestions(suggestions []string, prefix string) {
+	if len(suggestions) == 0 {
+		return
+	}
+
+	fmt.Println() // New line before suggestions
+
+	// Calculate the number of columns to display
+	maxLen := 0
+	for _, s := range suggestions {
+		if len(s) > maxLen {
+			maxLen = len(s)
+		}
+	}
+
+	// For now, just print them in a simple list format
+	for i, suggestion := range suggestions {
+		fmt.Printf(" %s", strings.TrimPrefix(suggestion, "./")) // Remove ./ prefix for cleaner display
+		if (i+1)%4 == 0 {                                       // New line every 4 suggestions
+			fmt.Println()
+		} else {
+			fmt.Print("   ") // Space between suggestions
+		}
+	}
+
+	if len(suggestions)%4 != 0 {
+		fmt.Println() // New line if the last row wasn't complete
+	}
+
+	// Print current position indicator
+	fmt.Printf("▼\n")
+}

cmd/cli/commands/images.go

@@ -94,10 +94,9 @@ func encodeImageToDataURL(filePath string) (string, error) {
 		return "", err
 	}
 
-	contentType := http.DetectContentType(buf)
-	allowedTypes := []string{"image/jpeg", "image/png", "image/webp"}
-	if !slices.Contains(allowedTypes, contentType) {
-		return "", fmt.Errorf("invalid image type: %s", contentType)
+	// Validate that this is an image file using both content and extension
+	if !isImageFileByContentAndExtension(buf, filePath) {
+		return "", fmt.Errorf("invalid image type for file: %s", filePath)
 	}
 
 	info, err := file.Stat()
@@ -158,3 +157,112 @@ func processImagesInPrompt(prompt string) (string, []string, error) {
 
 	return strings.TrimSpace(prompt), imageDataURLs, nil
 }
+
+// extractFileInclusions finds file paths in the prompt text using the @ symbol
+// e.g., @filename.txt, @./path/to/file.txt, @/absolute/path/file.txt
+func extractFileInclusions(prompt string) []string {
+	// Regex to match @ followed by a file path
+	// Pattern explanation:
+	// - @ symbol before the path
+	// - File path can be quoted (at least one char) or unquoted (at least one char)
+	// - Supports relative (./, ../) and absolute paths
+	regexPattern := `@(?:"([^"]+)"|'([^']+)'|([^\s"']+\b))`
+	re := regexp.MustCompile(regexPattern)
+	matches := re.FindAllStringSubmatch(prompt, -1)
+
+	paths := []string{}
+	for _, match := range matches {
+		// match[0] is the full match
+		// match[1] is double-quoted content
+		// match[2] is single-quoted content
+		// match[3] is unquoted content
+		if len(match) >= 2 && match[1] != "" {
+			paths = append(paths, match[1])
+		} else if len(match) >= 3 && match[2] != "" {
+			paths = append(paths, match[2])
+		} else if len(match) >= 4 && match[3] != "" {
+			paths = append(paths, match[3])
+		}
+	}
+
+	return paths
+}
+
+// hasValidImageExtension checks if the file has a valid image extension
+func hasValidImageExtension(filePath string) bool {
+	filePathLower := strings.ToLower(filePath)
+	return strings.HasSuffix(filePathLower, ".jpg") ||
+		strings.HasSuffix(filePathLower, ".jpeg") ||
+		strings.HasSuffix(filePathLower, ".png") ||
+		strings.HasSuffix(filePathLower, ".webp")
+}
+
+// isImageFileByContentAndExtension checks if a file is an image using both file extension and content type detection
+func isImageFileByContentAndExtension(content []byte, filePath string) bool {
+	// First check content type
+	contentType := http.DetectContentType(content)
+	if strings.HasPrefix(contentType, "image/") {
+		return true
+	}
+
+	// Fallback to file extension check if content detection fails
+	return hasValidImageExtension(filePath)
+}
+
+// processFileInclusions extracts files mentioned with @ symbol, reads their contents,
+// and returns the prompt with file contents embedded
+func processFileInclusions(prompt string) (string, error) {
+	filePaths := extractFileInclusions(prompt)
+
+	// Process each file inclusion in order
+	for _, filePath := range filePaths {
+		nfp := normalizeFilePath(filePath)
+
+		// Read the file content
+		content, err := os.ReadFile(nfp)
+		if err != nil {
+			// Skip non-existent files or files that can't be read
+			continue
+		}
+
+		// Check if the file is an image to handle it appropriately
+		// Only content is checked here, not file extension, to maintain original behavior
+		if isImageFileByContentAndExtension(content, nfp) {
+			// For image files, we keep the original file reference (@filePath) in the prompt
+			// so that processImagesInPrompt can handle it properly
+			continue
+		}
+
+		// For non-image files, replace the @filename with the file content
+		// Try different variations to match how it appears in the prompt
+		escapedPath := regexp.QuoteMeta(filePath) // Escape special regex chars
+		quotedPath := regexp.QuoteMeta(nfp)       // Also try normalized path
+
+		// Replace all occurrences of the file reference with its content
+		contentStr := string(content)
+
+		// Replace @ symbol usage with the file content - preserve the space or end by using word boundaries
+		// Use capturing groups to preserve the space
+		prompt = regexp.MustCompile(`@`+`"`+escapedPath+`"`).ReplaceAllString(prompt, contentStr)
+		prompt = regexp.MustCompile(`@`+`'`+escapedPath+`'`).ReplaceAllString(prompt, contentStr)
+		// For the unquoted version, we need to match @ + path and replace with content + the boundary character
+		// Use a more specific pattern that captures the space or end
+		prompt = regexp.MustCompile(`(@`+escapedPath+`)(\s|$)`).ReplaceAllString(prompt, contentStr+"$2")
+
+		// Also try replacing with normalized path
+		prompt = regexp.MustCompile(`@`+`"`+quotedPath+`"`).ReplaceAllString(prompt, contentStr)
+		prompt = regexp.MustCompile(`@`+`'`+quotedPath+`'`).ReplaceAllString(prompt, contentStr)
+		prompt = regexp.MustCompile(`(@`+quotedPath+`)(\s|$)`).ReplaceAllString(prompt, contentStr+"$2")
+	}
+
+	return prompt, nil
+}
+
+// For testing purposes - making the functions public so they can be tested
+func ExtractFileInclusions(prompt string) []string {
+	return extractFileInclusions(prompt)
+}
+
+func ProcessFileInclusions(prompt string) (string, error) {
+	return processFileInclusions(prompt)
+}