@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/mapper/message_input_test.go

@@ -0,0 +1,196 @@
+package mapper_test
+
+import (
+	"encoding/base64"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+const onePixelJPEG = "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8QEBD/wAALCAABAAEBAREA/8QAFAABAAAAAAAAAAAAAAAAAAAACf/EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAD8AVN//2Q=="
+
+func message(attachments []any, text ...string) obj {
+	t := "question"
+	if len(text) > 0 {
+		t = text[0]
+	}
+	return obj{"text": t, "origin": obj{"kind": "user"}, "attachments": attachments}
+}
+
+func embedded(data any, extra obj) obj {
+	a := obj{"type": "embeddedResource", "label": "notes.txt", "contentType": "text/plain", "data": data}
+	for k, v := range extra {
+		if v == nil {
+			delete(a, k)
+		} else {
+			a[k] = v
+		}
+	}
+	return a
+}
+
+func embeddedImage(data string, contentType string) obj {
+	return embedded(data, obj{"label": "screenshot.png", "contentType": contentType, "displayKind": "image"})
+}
+
+func b64(s string) string { return base64.StdEncoding.EncodeToString([]byte(s)) }
+
+func rng(sl, sc, el, ec int) obj {
+	return obj{"range": obj{"start": obj{"line": sl, "character": sc}, "end": obj{"line": el, "character": ec}}}
+}
+
+func mustText(t *testing.T, m obj) string {
+	t.Helper()
+	got, err := mapper.MessageTextForPi(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return got
+}
+
+// Twins of upstream test/message-input.test.ts.
+func TestMessageInput(t *testing.T) {
+
+	twin.Run(t, "message-input", "appends a file resource as a path with its selection", func(t *testing.T) {
+		in := message([]any{obj{"type": "resource", "label": "outside.ts", "uri": "file:///outside.ts", "selection": rng(4, 2, 8, 0)}})
+		if r := mapper.MessageRejectionReason(in); r != "" {
+			t.Fatal(r)
+		}
+		path, _ := wire.FileURIToPath("file:///outside.ts")
+		if got := mustText(t, in); got != "question\n\n"+path+":5:3-9:1" {
+			t.Fatalf("%q", got)
+		}
+	})
+
+	twin.Run(t, "message-input", "appends attachment representations in order", func(t *testing.T) {
+		in := message([]any{
+			obj{"type": "simple", "label": "first", "modelRepresentation": "first context"},
+			obj{"type": "resource", "label": "path", "uri": "file:///path.ts"},
+			obj{"type": "simple", "label": "second", "modelRepresentation": "second context"},
+		})
+		path, _ := wire.FileURIToPath("file:///path.ts")
+		if got := mustText(t, in); got != "question\n\nfirst context\n\n"+path+"\n\nsecond context" {
+			t.Fatalf("%q", got)
+		}
+	})
+
+	twin.Run(t, "message-input", "preserves resource URIs whose schemes may carry their own routing", func(t *testing.T) {
+		for _, uri := range []string{"https://example.com/context.txt", "virtual://client/context.txt?revision=1"} {
+			in := message([]any{obj{"type": "resource", "label": "remote", "uri": uri}})
+			if got := mustText(t, in); got != "question\n\n"+uri {
+				t.Fatalf("%q", got)
+			}
+		}
+	})
+
+	twin.Run(t, "message-input", "preserves a VS Code-wrapped resource without guessing which host owns it", func(t *testing.T) {
+		wrapped := "vscode-agent-host://another-host/Users/user/project/some%20file.ts?_ah%3DeyJzY2hlbWUiOiJmaWxlIn0"
+		in := message([]any{obj{"type": "resource", "label": "some file.ts", "uri": wrapped}})
+		if got := mustText(t, in); got != "question\n\n"+wrapped {
+			t.Fatalf("%q", got)
+		}
+	})
+
+	twin.Run(t, "message-input", "requires client-created simple attachments to carry a model representation", func(t *testing.T) {
+		// JSON null and an absent key are both "not a string".
+		for _, a := range []obj{
+			{"type": "simple", "label": "missing", "modelRepresentation": nil},
+			{"type": "simple", "label": "missing"},
+		} {
+			in := message([]any{a})
+			if got := mapper.MessageRejectionReason(in); got != "A simple attachment requires modelRepresentation" {
+				t.Fatalf("reason = %q", got)
+			}
+			if _, err := mapper.MessageTextForPi(in); err == nil || !strings.Contains(err.Error(), "requires modelRepresentation") {
+				t.Fatalf("err = %v", err)
+			}
+		}
+	})
+
+	twin.Run(t, "message-input", "separates embedded images from the text prompt", func(t *testing.T) {
+		in := message([]any{
+			obj{"type": "simple", "label": "context", "modelRepresentation": "selected context"},
+			embeddedImage(onePixelJPEG, "IMAGE/JPG; name=screenshot.jpg"),
+		})
+		got, err := mapper.MessageInputForPi(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		equal(t, got, mapper.MessageInput{
+			Text:   "question\n\nselected context",
+			Images: []mapper.Image{{Type: "image", Data: onePixelJPEG, MimeType: "image/jpeg"}},
+		}, "input")
+	})
+
+	twin.Run(t, "message-input", "rejects an empty embedded image", func(t *testing.T) {
+		if got := mapper.MessageRejectionReason(message([]any{embeddedImage("", "image/png")})); got != "Embedded image screenshot.png is empty" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "message-input", "appends UTF-8 embedded text without interpreting its MIME type", func(t *testing.T) {
+		in := message([]any{embedded(b64("const answer = 42;"), obj{"contentType": "application/x-uncommon-text"})})
+		if got := mustText(t, in); got != "question\n\nconst answer = 42;" {
+			t.Fatalf("%q", got)
+		}
+	})
+
+	twin.Run(t, "message-input", "keeps embedded payload under its original 1-based selection marker", func(t *testing.T) {
+		in := message([]any{embedded(b64("selected text"), obj{"selection": rng(20, 3, 20, 16)})})
+		if got := mustText(t, in); got != "question\n\n[selection 21:4-21:17]\nselected text" {
+			t.Fatalf("%q", got)
+		}
+	})
+
+	twin.Run(t, "message-input", "rejects malformed or non-text embedded payloads", func(t *testing.T) {
+		cases := []struct {
+			a      obj
+			reason string
+		}{
+			{embedded("%%%", nil), "valid base64"},
+			{embedded(nil, nil), "valid base64"},
+			{embedded(base64.StdEncoding.EncodeToString([]byte{0xc3, 0x28}), nil), "valid UTF-8"},
+		}
+		for _, c := range cases {
+			if got := mapper.MessageRejectionReason(message([]any{c.a})); !strings.Contains(got, c.reason) {
+				t.Fatalf("reason %q lacks %q", got, c.reason)
+			}
+		}
+	})
+
+	twin.Run(t, "message-input", "rejects malformed message and selection shapes without throwing", func(t *testing.T) {
+		cases := []struct {
+			in     any
+			reason string
+		}{
+			{nil, `requires text and an origin`},
+			{obj{"text": 42, "origin": obj{"kind": "user"}}, `requires text and an origin`},
+			{obj{"text": "x", "origin": obj{"kind": "user"}, "attachments": obj{}}, `must be an array`},
+			{message([]any{nil}), `requires a type and label`},
+			{message([]any{obj{"type": "resource", "label": "bad range", "uri": "file:///bad",
+				"selection": obj{"range": obj{"start": obj{"line": -1, "character": 0}, "end": obj{"line": 0, "character": 0}}}}}), `invalid text selection`},
+			{message([]any{embedded("", obj{"contentType": nil})}), `requires a content type`},
+		}
+		for i, c := range cases {
+			got := mapper.MessageRejectionReason(c.in)
+			if !regexp.MustCompile(c.reason).MatchString(got) {
+				t.Fatalf("case %d: reason %q does not match %q", i, got, c.reason)
+			}
+		}
+	})
+
+	twin.Run(t, "message-input", "rejects annotations and chat attachments", func(t *testing.T) {
+		for _, a := range []obj{
+			{"type": "annotations", "label": "diagnostics", "resource": "ahp-annotations:/fixture"},
+			{"type": "chat", "label": "other chat", "resource": "ahp-chat:/fixture"},
+		} {
+			if got := mapper.MessageRejectionReason(message([]any{a})); !strings.Contains(got, "does not support") {
+				t.Fatalf("reason = %q", got)
+			}
+		}
+	})
+}

package/extensions/ahp/internal/mapper/messageinput.go

@@ -0,0 +1,272 @@
+package mapper
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"math"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// Image is a pi image-content block.
+type Image struct {
+	Type     string `json:"type"`
+	Data     string `json:"data"`
+	MimeType string `json:"mimeType"`
+}
+
+// MessageInput is pi's prompt shape: text plus optional images.
+type MessageInput struct {
+	Text   string  `json:"text"`
+	Images []Image `json:"images,omitempty"`
+}
+
+// The port of src/pi/message-input.ts. A message arrives as decoded JSON straight from a client,
+// so every shape is checked: a malformed value is rejected with a reason, never a panic. Resource
+// references become paths or URIs, simple attachments contribute their model representation,
+// embedded text is decoded as UTF-8, embedded images become pi image blocks; other attachment
+// kinds are unsupported.
+
+func isRecord(v any) (map[string]any, bool) {
+	m, ok := v.(map[string]any)
+	return m, ok
+}
+
+func isNonNegativeInteger(v any) bool {
+	f, ok := num(v)
+	return ok && f >= 0 && f == math.Trunc(f) && f <= 1<<53-1
+}
+
+func isTextRange(v any) bool {
+	rng, ok := isRecord(v)
+	if !ok {
+		return false
+	}
+	start, ok1 := isRecord(rng["start"])
+	end, ok2 := isRecord(rng["end"])
+	if !ok1 || !ok2 {
+		return false
+	}
+	return isNonNegativeInteger(start["line"]) && isNonNegativeInteger(start["character"]) &&
+		isNonNegativeInteger(end["line"]) && isNonNegativeInteger(end["character"])
+}
+
+var base64Shape = regexp.MustCompile(`^[A-Za-z0-9+/]*={0,2}$`)
+
+func decodeBase64(v any) ([]byte, bool) {
+	data, ok := v.(string)
+	if !ok || !base64Shape.MatchString(data) || len(data)%4 == 1 {
+		return nil, false
+	}
+	if padding := strings.IndexByte(data, '='); padding != -1 && (padding < len(data)-2 || len(data)%4 != 0) {
+		return nil, false
+	}
+	trimmed := strings.TrimRight(data, "=")
+	decoded, err := base64.RawStdEncoding.DecodeString(trimmed)
+	if err != nil {
+		return nil, false
+	}
+	// Canonical form only: the bytes must re-encode to the same text.
+	if base64.RawStdEncoding.EncodeToString(decoded) != trimmed {
+		return nil, false
+	}
+	return decoded, true
+}
+
+func rangeText(rng map[string]any) string {
+	start, _ := isRecord(rng["start"])
+	end, _ := isRecord(rng["end"])
+	return fmt.Sprintf("%d:%d-%d:%d", intOr(start["line"], 0)+1, intOr(start["character"], 0)+1, intOr(end["line"], 0)+1, intOr(end["character"], 0)+1)
+}
+
+func selectionRange(attachment map[string]any) (map[string]any, bool) {
+	sel, ok := isRecord(attachment["selection"])
+	if !ok {
+		return nil, false
+	}
+	r, ok := isRecord(sel["range"])
+	return r, ok
+}
+
+func baseContentType(contentType string) string {
+	base, _, _ := strings.Cut(contentType, ";")
+	return strings.ToLower(trimJS(base))
+}
+
+type rejection string
+
+// embeddedContent returns text or an image, or a rejection reason.
+func embeddedContent(att map[string]any) (text string, image *Image, reject rejection) {
+	label, _ := att["label"].(string)
+	ct, ok := att["contentType"].(string)
+	if !ok {
+		return "", nil, rejection(fmt.Sprintf("Embedded resource %s requires a content type", label))
+	}
+	contentType := baseContentType(ct)
+	if contentType == "" {
+		return "", nil, rejection(fmt.Sprintf("Embedded resource %s requires a content type", label))
+	}
+	bytesData, ok := decodeBase64(att["data"])
+	if !ok {
+		return "", nil, rejection(fmt.Sprintf("Embedded resource %s is not valid base64", label))
+	}
+	if mime := NormalizeImageMimeType(contentType); mime != "" {
+		if len(bytesData) == 0 {
+			return "", nil, rejection(fmt.Sprintf("Embedded image %s is empty", label))
+		}
+		return "", &Image{Type: "image", Data: base64.StdEncoding.EncodeToString(bytesData), MimeType: mime}, ""
+	}
+	// MIME is advisory for non-images: successful UTF-8 decoding decides whether an embedded
+	// resource can safely join pi's text prompt.
+	if !utf8.Valid(bytesData) {
+		return "", nil, rejection(fmt.Sprintf("Embedded resource %s is not valid UTF-8", label))
+	}
+	decoded := string(bytesData)
+	if r, ok := selectionRange(att); ok {
+		return fmt.Sprintf("[selection %s]\n%s", rangeText(r), decoded), nil, ""
+	}
+	return decoded, nil, ""
+}
+
+func resourceText(att map[string]any) (string, rejection) {
+	uri, ok := att["uri"].(string)
+	if !ok {
+		return "", "A resource attachment requires a URI"
+	}
+	reference := uri
+	if len(reference) >= 5 && strings.EqualFold(reference[:5], "file:") {
+		// A remote or malformed file URI stays as it was rather than being guessed into a path.
+		if p, err := wire.FileURIToPath(reference); err == nil {
+			reference = p
+		}
+	}
+	if r, ok := selectionRange(att); ok {
+		reference += ":" + rangeText(r)
+	}
+	return reference, ""
+}
+
+type prepared struct {
+	input  MessageInput
+	reject rejection
+}
+
+func prepareMessage(value any) prepared {
+	rej := func(s string) prepared { return prepared{reject: rejection(s)} }
+	m, ok := isRecord(value)
+	if !ok {
+		return rej("A message requires text and an origin")
+	}
+	text, okText := m["text"].(string)
+	origin, okOrigin := isRecord(m["origin"])
+	if !okText || !okOrigin {
+		return rej("A message requires text and an origin")
+	}
+	if _, ok := origin["kind"].(string); !ok {
+		return rej("A message requires text and an origin")
+	}
+	var attachments []any
+	if raw, present := m["attachments"]; present && raw != nil {
+		arr, ok := raw.([]any)
+		if !ok {
+			return rej("Message attachments must be an array")
+		}
+		attachments = arr
+	}
+	if model, present := m["model"]; present && model != nil {
+		mm, ok := isRecord(model)
+		if !ok {
+			return rej("A message model requires an id")
+		}
+		if _, ok := mm["id"].(string); !ok {
+			return rej("A message model requires an id")
+		}
+	}
+	if agent, present := m["agent"]; present && agent != nil {
+		return rej("This host does not support custom agents")
+	}
+
+	representations := []string{}
+	var images []Image
+	for _, raw := range attachments {
+		att, ok := isRecord(raw)
+		if !ok {
+			return rej("Every message attachment requires a type and label")
+		}
+		typ, okType := att["type"].(string)
+		label, okLabel := att["label"].(string)
+		if !okType || !okLabel {
+			return rej("Every message attachment requires a type and label")
+		}
+		if r, present := att["range"]; present && r != nil && !isTextRange(r) {
+			return rej(fmt.Sprintf("Attachment %s has an invalid text range", label))
+		}
+		if sel, present := att["selection"]; present && sel != nil {
+			sm, ok := isRecord(sel)
+			if !ok || !isTextRange(sm["range"]) {
+				return rej(fmt.Sprintf("Attachment %s has an invalid text selection", label))
+			}
+		}
+		switch typ {
+		case "resource":
+			s, r := resourceText(att)
+			if r != "" {
+				return prepared{reject: r}
+			}
+			representations = append(representations, s)
+		case "simple":
+			rep, ok := att["modelRepresentation"].(string)
+			if !ok {
+				return rej("A simple attachment requires modelRepresentation")
+			}
+			if rep != "" {
+				representations = append(representations, rep)
+			}
+		case "embeddedResource":
+			s, img, r := embeddedContent(att)
+			if r != "" {
+				return prepared{reject: r}
+			}
+			if img != nil {
+				images = append(images, *img)
+			} else {
+				representations = append(representations, s)
+			}
+		default:
+			return rej(fmt.Sprintf("This host does not support %s attachments", typ))
+		}
+	}
+
+	parts := []string{}
+	for _, p := range append([]string{text}, representations...) {
+		if p != "" {
+			parts = append(parts, p)
+		}
+	}
+	return prepared{input: MessageInput{Text: strings.Join(parts, "\n\n"), Images: images}}
+}
+
+// MessageRejectionReason says why a client message cannot become a pi prompt ("" when it can).
+func MessageRejectionReason(message any) string {
+	return string(prepareMessage(message).reject)
+}
+
+// MessageInputForPi converts an AHP message to pi's prompt shape; the error carries the
+// rejection reason.
+func MessageInputForPi(message any) (MessageInput, error) {
+	p := prepareMessage(message)
+	if p.reject != "" {
+		return MessageInput{}, errors.New(string(p.reject))
+	}
+	return p.input, nil
+}
+
+// MessageTextForPi is the text of MessageInputForPi.
+func MessageTextForPi(message any) (string, error) {
+	in, err := MessageInputForPi(message)
+	return in.Text, err
+}

package/extensions/ahp/internal/mapper/schema_helpers_test.go

@@ -0,0 +1,5 @@
+package mapper_test
+
+import "github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+
+func checkAction(a any) error { return testkit.CheckSchema("actions", "StateAction", a) }

package/extensions/ahp/internal/mapper/testdata/LICENSE-pi-ahp

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bang Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.