main.go

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"os"
	"sort"
)

var (
	compact  = flag.Bool("compact", false, "compact output (no whitespace)")
	validate = flag.Bool("validate", false, "validate only, no output")
	write    = flag.Bool("write", false, "write result back to file")
	indent   = flag.Int("indent", 2, "number of spaces for indentation")
	sortKeys = flag.Bool("sort", false, "sort object keys alphabetically")
)

func main() {
	flag.Parse()

	var input []byte
	var err error
	var filename string

	if flag.NArg() > 0 {
		filename = flag.Arg(0)
		input, err = os.ReadFile(filename)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error reading %s: %v\n", filename, err)
			os.Exit(1)
		}
	} else {
		input, err = io.ReadAll(os.Stdin)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error reading stdin: %v\n", err)
			os.Exit(1)
		}
	}

	var parsed interface{}
	if err := json.Unmarshal(input, &parsed); err != nil {
		fmt.Fprintf(os.Stderr, "invalid JSON: %v\n", err)
		os.Exit(1)
	}

	if *validate {
		fmt.Fprintln(os.Stderr, "valid JSON")
		os.Exit(0)
	}

	if *sortKeys {
		parsed = sortMapKeys(parsed)
	}

	var output []byte
	if *compact {
		output, err = json.Marshal(parsed)
	} else {
		indentStr := ""
		for i := 0; i < *indent; i++ {
			indentStr += " "
		}
		output, err = json.MarshalIndent(parsed, "", indentStr)
	}
	if err != nil {
		fmt.Fprintf(os.Stderr, "error formatting: %v\n", err)
		os.Exit(1)
	}

	output = append(output, '\n')

	if *write && filename != "" {
		if bytes.Equal(input, output) {
			return
		}
		if err := os.WriteFile(filename, output, 0644); err != nil {
			fmt.Fprintf(os.Stderr, "error writing %s: %v\n", filename, err)
			os.Exit(1)
		}
		return
	}

	os.Stdout.Write(output)
}

func sortMapKeys(v interface{}) interface{} {
	switch val := v.(type) {
	case map[string]interface{}:
		keys := make([]string, 0, len(val))
		for k := range val {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		sorted := make(map[string]interface{}, len(val))
		for _, k := range keys {
			sorted[k] = sortMapKeys(val[k])
		}
		return sorted
	case []interface{}:
		for i, item := range val {
			val[i] = sortMapKeys(item)
		}
		return val
	default:
		return v
	}
}