quietlight/skraak_mcp - Change 5KIKDA72HM6JFIPKOWGLM2EO7D5PTSK7WEVYV3YZWGMG3M34PJXQC

sixel support

Created by quietlight on March 2, 2026

5KIKDA72HM6JFIPKOWGLM2EO7D5PTSK7WEVYV3YZWGMG3M34PJXQC

Dependencies

In channels

main

Change contents

File deletion: kitty_image_test.go

BF:BFD[4.1] → [5.2152:2195]

BF:BFD[5.2195] → [5.1:1]

B:BD[5.1] → [5.2:50]

∅:D[3.28] → [5.50:783]

B:BD[5.50] → [5.50:783]

∅:D[3.325] → [5.995:2151]

B:BD[5.995] → [5.995:2151]

B:BD[5.783] → [3.29:325]

B:BD[5.50] → [3.15:28]

package utils
import (
	"image"
	"image/color"
	"strings"
	"testing"
)
func TestWriteKittyImage_SmallImage(t *testing.T) {
	// 2x2 image produces small base64 payload — single chunk, no m= key
	img := image.NewGray(image.Rect(0, 0, 2, 2))
	img.SetGray(0, 0, color.Gray{Y: 128})
	var buf strings.Builder
	if err := WriteKittyImage(img, &buf); err != nil {
		t.Fatalf("WriteKittyImage: %v", err)
	}
	out := buf.String()
	if !strings.HasPrefix(out, "\x1b_Gf=100,a=T;") {
		t.Error("expected single-chunk header with f=100,a=T")
	}
	if strings.Contains(out, "m=") {
		t.Error("small image should not use chunked m= key")
	}
	if !strings.HasSuffix(out, "\x1b\\") {
		t.Error("expected escape sequence terminator")
	}
}
func TestWriteKittyImage_LargeImage_Chunked(t *testing.T) {
		}
	}
	var buf strings.Builder
	if err := WriteKittyImage(img, &buf); err != nil {
		t.Fatalf("WriteKittyImage: %v", err)
	}
	out := buf.String()
	// Should have multiple escape sequences
	chunks := strings.Split(out, "\x1b\\")
	// Last element is empty after final terminator
	chunks = chunks[:len(chunks)-1]
	if len(chunks) < 2 {
		t.Fatalf("expected multiple chunks, got %d", len(chunks))
	}
	// First chunk should have f=100,a=T,m=1
	if !strings.Contains(chunks[0], "f=100,a=T,m=1") {
		t.Errorf("first chunk missing f=100,a=T,m=1: %s", chunks[0][:min(80, len(chunks[0]))])
	}
	// Last chunk should have m=0
	last := chunks[len(chunks)-1]
	if !strings.Contains(last, "\x1b_Gm=0;") {
		t.Errorf("last chunk missing m=0: %s", last[:min(80, len(last))])
	}
	// Middle chunks should have m=1
	for i := 1; i < len(chunks)-1; i++ {
		if !strings.Contains(chunks[i], "\x1b_Gm=1;") {
			t.Errorf("middle chunk %d missing m=1", i)
		}
	}
}
func TestClearKittyImages(t *testing.T) {
	var buf strings.Builder
	ClearKittyImages(&buf)
	expected := "\x1b_Ga=d\x1b\\"
	if buf.String() != expected {
		t.Errorf("got %q, want %q", buf.String(), expected)
	}
}
	// 128x128 random noise image is incompressible — produces >4096 bytes of base64 even with proper LZ77
	rng := rand.New(rand.NewSource(42))
	img := image.NewGray(image.Rect(0, 0, 128, 128))
	for y := range 128 {
		for x := range 128 {
			img.SetGray(x, y, color.Gray{Y: uint8(rng.Intn(256))})
	"math/rand"

File deletion: kitty_image.go

BF:BFD[4.1] → [6.10894:10932]

BF:BFD[6.10932] → [6.4470:4470]

B:BD[6.4470] → [6.4471:4495]

B:BD[6.4530] → [6.4530:4560]

∅:D[3.404] → [6.4560:4562]

B:BD[6.4560] → [6.4560:4562]

∅:D[7.189] → [6.4562:4563]

B:BD[6.4562] → [6.4562:4563]

∅:D[8.526] → [6.4563:4647]

B:BD[6.4563] → [6.4563:4647]

∅:D[5.2362] → [6.4726:4785]

B:BD[6.4726] → [6.4726:4785]

∅:D[3.653] → [6.5205:5208]

B:BD[6.5205] → [6.5205:5208]

B:BD[6.5393] → [6.5393:5750]

B:BD[6.5750] → [9.206:256]

∅:D[9.256] → [6.5812:5860]

B:BD[6.5812] → [6.5812:5860]

∅:D[10.2417] → [6.5860:6191]

B:BD[6.5860] → [6.5860:6191]

B:BD[6.6191] → [10.2418:2490]

∅:D[10.2490] → [6.6255:6356]

B:BD[6.6255] → [6.6255:6356]

∅:D[10.2997] → [6.6356:6357]

B:BD[6.6356] → [6.6356:6357]

B:BD[6.6357] → [10.2998:3062]

B:BD[10.3062] → [9.367:423]

∅:D[9.423] → [6.6425:6609]

B:BD[6.6425] → [6.6425:6609]

B:BD[6.6631] → [6.6631:6684]

B:BD[6.6684] → [10.3063:3209]

B:BD[6.8770] → [6.8770:8777]

B:BD[6.10652] → [6.10652:10667]

B:BD[6.10891] → [6.10891:10893]

B:BD[6.6356] → [10.2491:2570]

B:BD[10.2570] → [9.308:366]

∅:D[9.366] → [10.2640:2997]

B:BD[10.2640] → [10.2640:2997]

B:BD[6.5860] → [10.1867:2241]

B:BD[10.2241] → [9.257:307]

∅:D[9.307] → [10.2303:2417]

B:BD[10.2303] → [10.2303:2417]

B:BD[6.4785] → [3.479:653]

B:BD[6.4647] → [5.2211:2298]

∅:D[2.222] → [8.323:431]

B:BD[6.4563] → [8.323:431]

∅:D[3.478] → [8.523:526]

B:BD[8.523] → [8.523:526]

B:BD[8.431] → [3.405:478]

B:BD[6.4563] → [2.98:222]

B:BD[6.4562] → [7.16:17]

∅:D[2.97] → [7.90:189]

B:BD[7.90] → [7.90:189]

B:BD[7.17] → [2.16:97]

B:BD[6.4560] → [3.327:404]

package utils
import (
	"image"
	"image/color"
	"io"
)
// WriteKittyImage writes an image to the writer using the Kitty graphics protocol.
func WriteKittyImage(img image.Image, w io.Writer) error {
}
// CreateGrayscaleImage creates an image.Image from a 2D uint8 array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateGrayscaleImage(data [][]uint8) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewGray(image.Rect(0, 0, width, height))
	for y := range height {
		for x := range width {
			img.SetGray(x, y, color.Gray{Y: data[y][x]})
		}
	}
	return img
}
// ResizeImage resizes an image using nearest-neighbor interpolation.
// For higher quality, use golang.org/x/image/draw, but this keeps dependencies minimal.
func ResizeImage(img image.Image, newWidth, newHeight int) image.Image {
	bounds := img.Bounds()
	srcWidth := bounds.Dx()
	srcHeight := bounds.Dy()
	// Detect if image is grayscale or RGB
	_, isGray := img.(*image.Gray)
	scaleX := float64(srcWidth) / float64(newWidth)
	scaleY := float64(srcHeight) / float64(newHeight)
	result := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
	for y := range newHeight {
		for x := range newWidth {
			srcX := int(float64(x) * scaleX)
			srcY := int(float64(y) * scaleY)
			if srcX >= srcWidth {
				srcX = srcWidth - 1
			}
			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}
			c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
			r, g, b, _ := c.RGBA()
			result.SetRGBA(x, y, color.RGBA{
				R: uint8(r >> 8),
				G: uint8(g >> 8),
				B: uint8(b >> 8),
				A: 255,
			})
		}
	}
	return result
}
	if isGray {
		result := image.NewGray(image.Rect(0, 0, newWidth, newHeight))
		for y := range newHeight {
			for x := range newWidth {
				srcX := int(float64(x) * scaleX)
				srcY := int(float64(y) * scaleY)
				if srcX >= srcWidth {
					srcX = srcWidth - 1
				}
				if srcY >= srcHeight {
					srcY = srcHeight - 1
				}
				c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
				gray := color.GrayModel.Convert(c).(color.Gray)
				result.SetGray(x, y, gray)
			}
		}
		return result
	}
		}
	}
	return img
}
// CreateRGBImage creates an image.Image from a 2D RGBPixel array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateRGBImage(data [][]RGBPixel) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewRGBA(image.Rect(0, 0, width, height))
	for y := range height {
		for x := range width {
			img.SetRGBA(x, y, color.RGBA{
				R: data[y][x].R,
				G: data[y][x].G,
				B: data[y][x].B,
				A: 255,
			})
	return kitty.EncodeGraphics(w, img, &kitty.Options{
		Format:       kitty.PNG,
		Action:       kitty.TransmitAndPut,
		Transmission: kitty.Direct,
		Chunk:        true,
	})
// The image is encoded as PNG, base64'd, and sent via chunked Kitty escape sequences.
// ClearKittyImages clears all previously displayed Kitty images
func ClearKittyImages(w io.Writer) error {
}
	_, err := io.WriteString(w, ansi.KittyGraphics(nil, "a=d"))
	return err
// ClampImageSize clamps a dimension to [224, 448].
func ClampImageSize(size int) int {
	return max(224, min(448, size))
}
// 448px suits Retina/HiDPI screens (224 logical pixels at 2x).
const SpectrogramDisplaySize = 448
// SpectrogramDisplaySize is the default pixel dimension for spectrogram images.
	"github.com/charmbracelet/x/ansi"
	"github.com/charmbracelet/x/ansi/kitty"

File addition: terminal_image_test.go (----------)

[4.1]

package utils
import (
	"image"
	"image/color"
	"math/rand"
	"strings"
	"testing"
)
func TestWriteKittyImage_SmallImage(t *testing.T) {
	// 2x2 image produces small base64 payload — single chunk, no m= key
	img := image.NewGray(image.Rect(0, 0, 2, 2))
	img.SetGray(0, 0, color.Gray{Y: 128})
	var buf strings.Builder
	if err := WriteKittyImage(img, &buf); err != nil {
		t.Fatalf("WriteKittyImage: %v", err)
	}
	out := buf.String()
	if !strings.HasPrefix(out, "\x1b_Gf=100,a=T;") {
		t.Error("expected single-chunk header with f=100,a=T")
	}
	if strings.Contains(out, "m=") {
		t.Error("small image should not use chunked m= key")
	}
	if !strings.HasSuffix(out, "\x1b\\") {
		t.Error("expected escape sequence terminator")
	}
}
func TestWriteKittyImage_LargeImage_Chunked(t *testing.T) {
	// 128x128 random noise image is incompressible — produces >4096 bytes of base64 even with proper LZ77
	rng := rand.New(rand.NewSource(42))
	img := image.NewGray(image.Rect(0, 0, 128, 128))
	for y := range 128 {
		for x := range 128 {
			img.SetGray(x, y, color.Gray{Y: uint8(rng.Intn(256))})
		}
	}
	var buf strings.Builder
	if err := WriteKittyImage(img, &buf); err != nil {
		t.Fatalf("WriteKittyImage: %v", err)
	}
	out := buf.String()
	// Should have multiple escape sequences
	chunks := strings.Split(out, "\x1b\\")
	// Last element is empty after final terminator
	chunks = chunks[:len(chunks)-1]
	if len(chunks) < 2 {
		t.Fatalf("expected multiple chunks, got %d", len(chunks))
	}
	// First chunk should have f=100,a=T,m=1
	if !strings.Contains(chunks[0], "f=100,a=T,m=1") {
		t.Errorf("first chunk missing f=100,a=T,m=1: %s", chunks[0][:min(80, len(chunks[0]))])
	}
	// Last chunk should have m=0
	last := chunks[len(chunks)-1]
	if !strings.Contains(last, "\x1b_Gm=0;") {
		t.Errorf("last chunk missing m=0: %s", last[:min(80, len(last))])
	}
	// Middle chunks should have m=1
	for i := 1; i < len(chunks)-1; i++ {
		if !strings.Contains(chunks[i], "\x1b_Gm=1;") {
			t.Errorf("middle chunk %d missing m=1", i)
		}
	}
}
func TestClearKittyImages(t *testing.T) {
	var buf strings.Builder
	ClearKittyImages(&buf)
	expected := "\x1b_Ga=d\x1b\\"
	if buf.String() != expected {
		t.Errorf("got %q, want %q", buf.String(), expected)
	}
}
func TestWriteSixelImage(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 6))
	for y := range 6 {
		for x := range 4 {
			img.SetGray(x, y, color.Gray{Y: uint8((x + y) * 40)})
		}
	}
	var buf strings.Builder
	if err := WriteSixelImage(img, &buf); err != nil {
		t.Fatalf("WriteSixelImage: %v", err)
	}
	out := buf.String()
	// Sixel DCS introducer
	if !strings.HasPrefix(out, "\x1bP") {
		t.Error("expected DCS prefix \\x1bP")
	}
	// String terminator
	if !strings.HasSuffix(out, "\x1b\\") {
		t.Error("expected ST suffix \\x1b\\\\")
	}
	// Should contain 'q' after DCS parameters
	if !strings.Contains(out, "q") {
		t.Error("expected 'q' in DCS sequence")
	}
}
func TestClearImages_Kitty(t *testing.T) {
	var buf strings.Builder
	ClearImages(&buf, ProtocolKitty)
	if buf.String() != "\x1b_Ga=d\x1b\\" {
		t.Errorf("got %q, want kitty clear sequence", buf.String())
	}
}
func TestClearImages_Sixel(t *testing.T) {
	var buf strings.Builder
	ClearImages(&buf, ProtocolSixel)
	if buf.String() != "" {
		t.Errorf("expected no output for sixel clear, got %q", buf.String())
	}
}
func TestWriteImage_Kitty(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 2, 2))
	var buf strings.Builder
	if err := WriteImage(img, &buf, ProtocolKitty); err != nil {
		t.Fatalf("WriteImage kitty: %v", err)
	}
	if !strings.HasPrefix(buf.String(), "\x1b_G") {
		t.Error("expected kitty escape prefix")
	}
}
func TestWriteImage_Sixel(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 6))
	var buf strings.Builder
	if err := WriteImage(img, &buf, ProtocolSixel); err != nil {
		t.Fatalf("WriteImage sixel: %v", err)
	}
	if !strings.HasPrefix(buf.String(), "\x1bP") {
		t.Error("expected sixel DCS prefix")
	}
}

File addition: terminal_image.go (----------)

[4.1]

package utils
import (
	"bytes"
	"image"
	"image/color"
	"io"
	"github.com/charmbracelet/x/ansi"
	"github.com/charmbracelet/x/ansi/kitty"
	"github.com/charmbracelet/x/ansi/sixel"
)
// ImageProtocol selects the terminal graphics protocol.
type ImageProtocol int
const (
	ProtocolKitty ImageProtocol = iota
	ProtocolSixel
)
// SpectrogramDisplaySize is the default pixel dimension for spectrogram images.
// 448px suits Retina/HiDPI screens (224 logical pixels at 2x).
const SpectrogramDisplaySize = 448
// ClampImageSize clamps a dimension to [224, 448].
func ClampImageSize(size int) int {
	return max(224, min(448, size))
}
// WriteImage writes an image using the specified terminal graphics protocol.
func WriteImage(img image.Image, w io.Writer, protocol ImageProtocol) error {
	switch protocol {
	case ProtocolSixel:
		return WriteSixelImage(img, w)
	default:
		return WriteKittyImage(img, w)
	}
}
// ClearImages clears previously displayed images. No-op for sixel (inline text).
func ClearImages(w io.Writer, protocol ImageProtocol) error {
	switch protocol {
	case ProtocolSixel:
		return nil
	default:
		return ClearKittyImages(w)
	}
}
// ClearKittyImages clears all previously displayed Kitty images
func ClearKittyImages(w io.Writer) error {
	_, err := io.WriteString(w, ansi.KittyGraphics(nil, "a=d"))
	return err
}
// WriteKittyImage writes an image to the writer using the Kitty graphics protocol.
// The image is encoded as PNG, base64'd, and sent via chunked Kitty escape sequences.
func WriteKittyImage(img image.Image, w io.Writer) error {
	return kitty.EncodeGraphics(w, img, &kitty.Options{
		Format:       kitty.PNG,
		Action:       kitty.TransmitAndPut,
		Transmission: kitty.Direct,
		Chunk:        true,
	})
}
// WriteSixelImage writes an image using the Sixel graphics protocol.
func WriteSixelImage(img image.Image, w io.Writer) error {
	var buf bytes.Buffer
	enc := &sixel.Encoder{}
	if err := enc.Encode(&buf, img); err != nil {
		return err
	}
	_, err := io.WriteString(w, ansi.SixelGraphics(0, 1, 0, buf.Bytes()))
	return err
}
// CreateGrayscaleImage creates an image.Image from a 2D uint8 array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateGrayscaleImage(data [][]uint8) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewGray(image.Rect(0, 0, width, height))
	for y := range height {
		for x := range width {
			img.SetGray(x, y, color.Gray{Y: data[y][x]})
		}
	}
	return img
}
// CreateRGBImage creates an image.Image from a 2D RGBPixel array.
// The array is organized as [rows][cols] where rows = frequency bins.
func CreateRGBImage(data [][]RGBPixel) image.Image {
	if len(data) == 0 || len(data[0]) == 0 {
		return nil
	}
	height := len(data)
	width := len(data[0])
	img := image.NewRGBA(image.Rect(0, 0, width, height))
	for y := range height {
		for x := range width {
			img.SetRGBA(x, y, color.RGBA{
				R: data[y][x].R,
				G: data[y][x].G,
				B: data[y][x].B,
				A: 255,
			})
		}
	}
	return img
}
// ResizeImage resizes an image using nearest-neighbor interpolation.
// For higher quality, use golang.org/x/image/draw, but this keeps dependencies minimal.
func ResizeImage(img image.Image, newWidth, newHeight int) image.Image {
	bounds := img.Bounds()
	srcWidth := bounds.Dx()
	srcHeight := bounds.Dy()
	// Detect if image is grayscale or RGB
	_, isGray := img.(*image.Gray)
	scaleX := float64(srcWidth) / float64(newWidth)
	scaleY := float64(srcHeight) / float64(newHeight)
	if isGray {
		result := image.NewGray(image.Rect(0, 0, newWidth, newHeight))
		for y := range newHeight {
			for x := range newWidth {
				srcX := int(float64(x) * scaleX)
				srcY := int(float64(y) * scaleY)
				if srcX >= srcWidth {
					srcX = srcWidth - 1
				}
				if srcY >= srcHeight {
					srcY = srcHeight - 1
				}
				c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
				gray := color.GrayModel.Convert(c).(color.Gray)
				result.SetGray(x, y, gray)
			}
		}
		return result
	}
	result := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
	for y := range newHeight {
		for x := range newWidth {
			srcX := int(float64(x) * scaleX)
			srcY := int(float64(y) * scaleY)
			if srcX >= srcWidth {
				srcX = srcWidth - 1
			}
			if srcY >= srcHeight {
				srcY = srcHeight - 1
			}
			c := img.At(srcX+bounds.Min.X, srcY+bounds.Min.Y)
			r, g, b, _ := c.RGBA()
			result.SetRGBA(x, y, color.RGBA{
				R: uint8(r >> 8),
				G: uint8(g >> 8),
				B: uint8(b >> 8),
				A: 255,
			})
		}
	}
	return result
}

Insertion in tui/classify.go at line 64 [11.9978]

[11.10920]

func (m Model) protocol() utils.ImageProtocol {
	if m.state.Config.Sixel {
		return utils.ProtocolSixel
	}
	return utils.ProtocolKitty
}

Replacement in tui/classify.go at line 198 [11.9978]
B:BD[8.1473] → [8.1473:1502]
```
		utils.ClearKittyImages(&b)
```
[8.1473]
[8.1502]
```
		utils.ClearImages(&b, m.protocol())
```

Replacement in tui/classify.go at line 205 [11.9978]

B:BD[8.1553] → [12.268:344]

	// Clear any kitty images from previous render
	utils.ClearKittyImages(&b)

[8.1553]

[11.13150]

	// Clear any images from previous render
	utils.ClearImages(&b, m.protocol())

Replacement in tui/classify.go at line 313 [11.9978]

B:BD[8.3042] → [12.922:986]

∅:D[12.986] → [8.3133:3168]

B:BD[8.3133] → [8.3133:3168]

	// Output via Kitty protocol (images cleared at start of View)
	utils.WriteKittyImage(resized, b)

[8.3042]

[8.3168]

	// Output via terminal graphics protocol (images cleared at start of View)
	utils.WriteImage(resized, b, m.protocol())

Insertion in tools/calls_show_images.go at line 18 [6.10934]

[2.548]

[6.11208]

	Sixel        bool   `json:"sixel" jsonschema:"Use sixel graphics protocol instead of kitty"`

Replacement in tools/calls_show_images.go at line 82 [6.10934]

B:BD[6.12868] → [6.12868:12940]

	// Generate spectrogram for each segment and output via Kitty protocol

[6.12868]

[6.12940]

	// Select graphics protocol
	protocol := utils.ProtocolKitty
	if input.Sixel {
		protocol = utils.ProtocolSixel
	}
	// Generate spectrogram for each segment and output

Replacement in tools/calls_show_images.go at line 122 [6.10934]

B:BD[6.13544] → [6.13544:13584]

B:BD[6.13665] → [6.13665:13733]

		// Write to stdout via Kitty protocol
		if err := utils.WriteKittyImage(resized, os.Stdout); err != nil {

[6.13544]

[6.13733]

		// Write to stdout via terminal graphics protocol
		if err := utils.WriteImage(resized, os.Stdout, protocol); err != nil {

Insertion in tools/calls_classify.go at line 27 [11.20592]
[2.920]
[2.920]
```
	Sixel     bool
```

Insertion in go.sum at line 13 [4.153180]

[13.919]

[4.153362]

github.com/bits-and-blooms/bitset v1.24.4 h1:95H15Og1clikBrKr/DuzMXkQzECs1M6hhoGXLwLQOZE=
github.com/bits-and-blooms/bitset v1.24.4/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=

Insertion in go.mod at line 20 [4.159737]
[4.159885]
[13.3311]
```
	github.com/bits-and-blooms/bitset v1.24.4 // indirect
```
Replacement in cmd/calls_classify.go at line 18 [11.28389]
B:BD[11.28683] → [11.28683:28699]
```
	var color bool
```
[11.28655]
[2.1013]
```
	var color, sixel bool
```
Insertion in cmd/calls_classify.go at line 64 [11.28389]
[2.1032]
[2.1032]
```
		case "--sixel":
			sixel = true
			i++
```
Insertion in cmd/calls_classify.go at line 121 [11.28389]
[2.1462]
[2.1462]
```
		Sixel:     sixel,
```

Insertion in cmd/calls.go at line 147 [14.1]

[2.1574]

[6.20233]

	sixel := fs.Bool("sixel", false, "Use sixel graphics protocol (default: kitty)")

Replacement in cmd/calls.go at line 152 [14.1]

B:BD[6.20420] → [6.20420:20505]

		fmt.Fprintf(os.Stderr, "Images are output using the Kitty graphics protocol.\n\n")

[6.20420]

[6.20505]

		fmt.Fprintf(os.Stderr, "Images are output using the Kitty graphics protocol (or Sixel with --sixel).\n\n")

Insertion in cmd/calls.go at line 175 [14.1]
[2.1601]
[6.20954]
```
		Sixel:        *sixel,
```