feat: add Tier 1 file content operations (read, write, append, concatenate, move)

Add essential file content operations to complete the file operations toolkit:

Operations added:
- read-file: Read entire file contents as string
- write-file: Write string contents to file (overwrites existing)
- append-to-file: Append content to existing file (creates if doesn't exist)
- concatenate-files: Merge multiple source files into single destination
- move-path: Move/rename files or directories (cross-filesystem compatible)

Implementation details:
- All operations include security validation via ValidatePath
- Parent directory auto-creation for write operations
- MovePath falls back to copy+remove for cross-filesystem moves
- Full JSON batch operation support with backward compatibility
- Comprehensive test coverage for all new operations

Files modified:
- wit/file-operations.wit: Added 5 new WIT interface functions
- tinygo/operations.go: Implemented all 5 operations (157 lines)
- tinygo/json_bridge.go: Added JSON support with validation (129 lines)
- tinygo/operations_test.go: Added 8 comprehensive tests (236 lines)

All tests passing (32/32), component builds successfully.

Author: avrabe

tinygo/json_bridge.go

@@ -27,6 +27,8 @@ type Operation struct {
 	Args       []string `json:"args,omitempty"`
 	WorkDir    string   `json:"work_dir,omitempty"`
 	OutputFile string   `json:"output_file,omitempty"`
+	Content    string   `json:"content,omitempty"`    // For write_file, append_to_file
+	Sources    []string `json:"sources,omitempty"`    // For concatenate_files
 }
 
 // WorkspaceInfo represents the result of workspace operations
@@ -108,15 +110,17 @@ func GetJsonSchema() string {
         "properties": {
           "type": {
             "type": "string",
-            "enum": ["copy_file", "mkdir", "copy_directory_contents", "run_command"]
+            "enum": ["copy_file", "mkdir", "copy_directory_contents", "run_command", "read_file", "write_file", "append_to_file", "concatenate_files", "move_path"]
           },
           "src_path": {"type": "string"},
           "dest_path": {"type": "string"},
           "path": {"type": "string"},
           "command": {"type": "string"},
           "args": {"type": "array", "items": {"type": "string"}},
           "work_dir": {"type": "string"},
-          "output_file": {"type": "string"}
+          "output_file": {"type": "string"},
+          "content": {"type": "string"},
+          "sources": {"type": "array", "items": {"type": "string"}}
         }
       }
     }
@@ -180,6 +184,52 @@ func validateOperation(op Operation, index int) error {
 		if op.Command == "" {
 			return fmt.Errorf("operation %d: run_command requires command", index)
 		}
+	case "read_file":
+		if op.Path == "" {
+			return fmt.Errorf("operation %d: read_file requires path", index)
+		}
+		if !filepath.IsAbs(op.Path) {
+			return fmt.Errorf("operation %d: path must be absolute: %s", index, op.Path)
+		}
+	case "write_file":
+		if op.Path == "" {
+			return fmt.Errorf("operation %d: write_file requires path", index)
+		}
+		if filepath.IsAbs(op.Path) {
+			return fmt.Errorf("operation %d: path must be relative: %s", index, op.Path)
+		}
+	case "append_to_file":
+		if op.Path == "" {
+			return fmt.Errorf("operation %d: append_to_file requires path", index)
+		}
+		if filepath.IsAbs(op.Path) {
+			return fmt.Errorf("operation %d: path must be relative: %s", index, op.Path)
+		}
+	case "concatenate_files":
+		if len(op.Sources) == 0 {
+			return fmt.Errorf("operation %d: concatenate_files requires sources", index)
+		}
+		if op.DestPath == "" {
+			return fmt.Errorf("operation %d: concatenate_files requires dest_path", index)
+		}
+		for i, source := range op.Sources {
+			if !filepath.IsAbs(source) {
+				return fmt.Errorf("operation %d: source %d must be absolute: %s", index, i, source)
+			}
+		}
+		if filepath.IsAbs(op.DestPath) {
+			return fmt.Errorf("operation %d: dest_path must be relative: %s", index, op.DestPath)
+		}
+	case "move_path":
+		if op.SrcPath == "" || op.DestPath == "" {
+			return fmt.Errorf("operation %d: move_path requires src_path and dest_path", index)
+		}
+		if !filepath.IsAbs(op.SrcPath) {
+			return fmt.Errorf("operation %d: src_path must be absolute: %s", index, op.SrcPath)
+		}
+		if filepath.IsAbs(op.DestPath) {
+			return fmt.Errorf("operation %d: dest_path must be relative: %s", index, op.DestPath)
+		}
 	default:
 		return fmt.Errorf("operation %d: unknown operation type: %s", index, op.Type)
 	}
@@ -198,6 +248,16 @@ func executeJsonOperation(op Operation, workspaceDir string) ([]string, error) {
 		return executeJsonCopyDirectoryContents(op, workspaceDir)
 	case "run_command":
 		return executeJsonRunCommand(op, workspaceDir)
+	case "read_file":
+		return executeJsonReadFile(op, workspaceDir)
+	case "write_file":
+		return executeJsonWriteFile(op, workspaceDir)
+	case "append_to_file":
+		return executeJsonAppendToFile(op, workspaceDir)
+	case "concatenate_files":
+		return executeJsonConcatenateFiles(op, workspaceDir)
+	case "move_path":
+		return executeJsonMovePath(op, workspaceDir)
 	default:
 		return nil, fmt.Errorf("unsupported operation type: %s", op.Type)
 	}
@@ -295,3 +355,68 @@ func executeJsonRunCommand(op Operation, workspaceDir string) ([]string, error)
 
 	return []string{}, nil
 }
+
+// executeJsonReadFile executes read_file operation
+func executeJsonReadFile(op Operation, workspaceDir string) ([]string, error) {
+	// Read file uses absolute path (from validation)
+	content, err := ReadFile(op.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	// If output_file is specified, write content there
+	if op.OutputFile != "" {
+		outputPath := filepath.Join(workspaceDir, op.OutputFile)
+		if err := WriteFile(outputPath, content); err != nil {
+			return nil, fmt.Errorf("failed to write output: %w", err)
+		}
+		return []string{outputPath}, nil
+	}
+
+	// Otherwise just return the source path as processed
+	return []string{op.Path}, nil
+}
+
+// executeJsonWriteFile executes write_file operation
+func executeJsonWriteFile(op Operation, workspaceDir string) ([]string, error) {
+	path := filepath.Join(workspaceDir, op.Path)
+
+	if err := WriteFile(path, op.Content); err != nil {
+		return nil, err
+	}
+
+	return []string{path}, nil
+}
+
+// executeJsonAppendToFile executes append_to_file operation
+func executeJsonAppendToFile(op Operation, workspaceDir string) ([]string, error) {
+	path := filepath.Join(workspaceDir, op.Path)
+
+	if err := AppendToFile(path, op.Content); err != nil {
+		return nil, err
+	}
+
+	return []string{path}, nil
+}
+
+// executeJsonConcatenateFiles executes concatenate_files operation
+func executeJsonConcatenateFiles(op Operation, workspaceDir string) ([]string, error) {
+	dest := filepath.Join(workspaceDir, op.DestPath)
+
+	if err := ConcatenateFiles(op.Sources, dest); err != nil {
+		return nil, err
+	}
+
+	return []string{dest}, nil
+}
+
+// executeJsonMovePath executes move_path operation
+func executeJsonMovePath(op Operation, workspaceDir string) ([]string, error) {
+	dest := filepath.Join(workspaceDir, op.DestPath)
+
+	if err := MovePath(op.SrcPath, dest); err != nil {
+		return nil, err
+	}
+
+	return []string{dest}, nil
+}

tinygo/operations.go

@@ -200,6 +200,163 @@ func ListDirectory(dir string, pattern *string) ([]string, error) {
 	return result, nil
 }
 
+// ReadFile reads the entire contents of a file as a string
+// Implements the read-file WIT interface function
+func ReadFile(path string) (string, error) {
+	// Security validation
+	if err := ValidatePath(path, []string{}); err != nil {
+		return "", fmt.Errorf("security validation failed: %w", err)
+	}
+
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file %s: %w", path, err)
+	}
+
+	return string(content), nil
+}
+
+// WriteFile writes string contents to a file, overwriting if it exists
+// Implements the write-file WIT interface function
+func WriteFile(path, content string) error {
+	// Security validation
+	if err := ValidatePath(path, []string{}); err != nil {
+		return fmt.Errorf("security validation failed: %w", err)
+	}
+
+	// Ensure parent directory exists
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create parent directory %s: %w", dir, err)
+	}
+
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		return fmt.Errorf("failed to write file %s: %w", path, err)
+	}
+
+	return nil
+}
+
+// AppendToFile appends string content to an existing file (creates if doesn't exist)
+// Implements the append-to-file WIT interface function
+func AppendToFile(path, content string) error {
+	// Security validation
+	if err := ValidatePath(path, []string{}); err != nil {
+		return fmt.Errorf("security validation failed: %w", err)
+	}
+
+	// Ensure parent directory exists
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create parent directory %s: %w", dir, err)
+	}
+
+	// Open file in append mode (create if doesn't exist)
+	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to open file %s for appending: %w", path, err)
+	}
+	defer file.Close()
+
+	if _, err := file.WriteString(content); err != nil {
+		return fmt.Errorf("failed to append to file %s: %w", path, err)
+	}
+
+	return nil
+}
+
+// ConcatenateFiles concatenates multiple source files into a single destination file
+// Implements the concatenate-files WIT interface function
+func ConcatenateFiles(sources []string, dest string) error {
+	// Security validation for destination
+	if err := ValidatePath(dest, []string{}); err != nil {
+		return fmt.Errorf("security validation failed for destination: %w", err)
+	}
+
+	if len(sources) == 0 {
+		return fmt.Errorf("no source files provided for concatenation")
+	}
+
+	// Ensure destination directory exists
+	destDir := filepath.Dir(dest)
+	if err := os.MkdirAll(destDir, 0755); err != nil {
+		return fmt.Errorf("failed to create destination directory %s: %w", destDir, err)
+	}
+
+	// Create destination file
+	destFile, err := os.Create(dest)
+	if err != nil {
+		return fmt.Errorf("failed to create destination file %s: %w", dest, err)
+	}
+	defer destFile.Close()
+
+	// Read and concatenate each source file
+	for i, source := range sources {
+		// Security validation for each source
+		if err := ValidatePath(source, []string{}); err != nil {
+			return fmt.Errorf("security validation failed for source %d (%s): %w", i, source, err)
+		}
+
+		content, err := os.ReadFile(source)
+		if err != nil {
+			return fmt.Errorf("failed to read source file %s: %w", source, err)
+		}
+
+		if _, err := destFile.Write(content); err != nil {
+			return fmt.Errorf("failed to write content from %s to destination: %w", source, err)
+		}
+	}
+
+	return nil
+}
+
+// MovePath moves or renames a file or directory from source to destination
+// Implements the move-path WIT interface function
+func MovePath(src, dest string) error {
+	// Security validation
+	if err := ValidatePath(src, []string{}); err != nil {
+		return fmt.Errorf("security validation failed for source: %w", err)
+	}
+	if err := ValidatePath(dest, []string{}); err != nil {
+		return fmt.Errorf("security validation failed for destination: %w", err)
+	}
+
+	// Ensure destination parent directory exists
+	destDir := filepath.Dir(dest)
+	if err := os.MkdirAll(destDir, 0755); err != nil {
+		return fmt.Errorf("failed to create destination directory %s: %w", destDir, err)
+	}
+
+	// Attempt rename (works if on same filesystem)
+	err := os.Rename(src, dest)
+	if err != nil {
+		// If rename fails (e.g., cross-filesystem), fall back to copy + remove
+		srcInfo, statErr := os.Stat(src)
+		if statErr != nil {
+			return fmt.Errorf("failed to stat source %s: %w", src, statErr)
+		}
+
+		if srcInfo.IsDir() {
+			// Copy directory recursively
+			if err := CopyDirectory(src, dest); err != nil {
+				return fmt.Errorf("failed to copy directory during move: %w", err)
+			}
+		} else {
+			// Copy file
+			if err := CopyFile(src, dest); err != nil {
+				return fmt.Errorf("failed to copy file during move: %w", err)
+			}
+		}
+
+		// Remove source after successful copy
+		if err := RemovePath(src); err != nil {
+			return fmt.Errorf("failed to remove source after move: %w", err)
+		}
+	}
+
+	return nil
+}
+
 // Helper functions
 
 // copyDirectoryContents recursively copies directory contents