@pi-in-go/pigpen-ahp 0.1.0

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

@@ -0,0 +1,199 @@
+package mapper
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+)
+
+// Human-readable descriptions of what the agent is doing right now (port of src/pi/activity.ts).
+// They are display strings a client renders verbatim next to its spinner.
+
+const (
+	// ThinkingActivity and RespondingActivity are the two model-side activities.
+	ThinkingActivity   = "Thinking"
+	RespondingActivity = "Responding"
+
+	maxLength = 60
+)
+
+// shorten trims the middle rather than the end: the informative parts of a path or a shell
+// command sit at the two ends.
+func shorten(value string, limit ...int) string {
+	lim := maxLength
+	if len(limit) > 0 {
+		lim = limit[0]
+	}
+	collapsed := collapseSpace(value)
+	n := utf16Len(collapsed)
+	if n <= lim {
+		return collapsed
+	}
+	head := (lim - 1 + 1) / 2 // Math.ceil((limit-1)/2)
+	tail := (lim - 1) / 2     // Math.floor((limit-1)/2)
+	return sliceUTF16(collapsed, 0, head) + "…" + sliceUTF16(collapsed, n-tail, n)
+}
+
+// displayPath renders a path relative to the working directory when it sits underneath it.
+func displayPath(value any, workingDirectory string) (string, bool) {
+	s, ok := value.(string)
+	if !ok || s == "" {
+		return "", false
+	}
+	if workingDirectory != "" && strings.HasPrefix(s, workingDirectory+"/") {
+		s = s[len(workingDirectory)+1:]
+	}
+	return shorten(s), true
+}
+
+func argsMap(args any) map[string]any {
+	m, _ := args.(map[string]any)
+	return m
+}
+
+// DescribeToolCall describes a tool invocation. pi's built-in tools are named individually;
+// anything else falls back to its own name.
+func DescribeToolCall(toolName string, args any, workingDirectory string) string {
+	input := argsMap(args)
+	path, hasPath := displayPath(input["path"], workingDirectory)
+	switch toolName {
+	case "read":
+		if hasPath {
+			return "Reading " + path
+		}
+		return "Reading a file"
+	case "write":
+		if hasPath {
+			return "Writing " + path
+		}
+		return "Writing a file"
+	case "edit":
+		if hasPath {
+			return "Editing " + path
+		}
+		return "Editing a file"
+	case "bash":
+		if c, ok := input["command"].(string); ok {
+			if command := shorten(c); command != "" {
+				return "Running " + command
+			}
+		}
+		return "Running a command"
+	case "ls":
+		if hasPath {
+			return "Listing " + path
+		}
+		return "Listing files"
+	case "find":
+		if p, ok := input["pattern"].(string); ok {
+			if pattern := shorten(p, 30); pattern != "" {
+				return "Finding " + pattern
+			}
+		}
+		return "Finding files"
+	case "grep":
+		if p, ok := input["pattern"].(string); ok {
+			if pattern := shorten(p, 30); pattern != "" {
+				return "Searching for " + pattern
+			}
+		}
+		return "Searching"
+	default:
+		return "Running " + shorten(toolName, 40)
+	}
+}
+
+func stringArg(v any) (string, bool) {
+	s, ok := v.(string)
+	return s, ok && s != ""
+}
+
+// fullArguments is JSON.stringify(args, null, 2). Go marshals object keys in sorted order where
+// JavaScript keeps insertion order; Pi's events reach an extension already decoded, so the
+// original order is not available (documented in PORT.md).
+func fullArguments(args any) (string, bool) {
+	if args == nil {
+		return "", false
+	}
+	out, err := StringifyJSON(args, true)
+	if err != nil {
+		return "", false
+	}
+	return out, true
+}
+
+// StringifyJSON is JSON.stringify(v) (or JSON.stringify(v, null, 2) when indent is set): unlike
+// encoding/json.Marshal it leaves <, > and & unescaped.
+func StringifyJSON(v any, indent bool) (string, error) {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if indent {
+		enc.SetIndent("", "  ")
+	}
+	if err := enc.Encode(v); err != nil {
+		return "", err
+	}
+	return strings.TrimSuffix(buf.String(), "\n"), nil
+}
+
+// ToolInputFor is the one argument that says what a tool call is about. Anything without an
+// obvious subject keeps the full arguments. ok is false when there is nothing to show.
+func ToolInputFor(toolName string, args any) (string, bool) {
+	input := argsMap(args)
+	switch toolName {
+	case "bash":
+		if s, ok := stringArg(input["command"]); ok {
+			return s, true
+		}
+	case "grep", "find":
+		if s, ok := searchInput(input); ok {
+			return s, true
+		}
+	case "read", "write", "edit", "ls":
+		if s, ok := stringArg(input["path"]); ok {
+			return s, true
+		}
+	}
+	return fullArguments(args)
+}
+
+// searchInput renders a search as its pattern plus whatever narrows it. Models restate the
+// defaults (`path: "."`, a glob matching everything, `ignoreCase: false`), so only arguments that
+// actually narrow the search are shown, in the order `rg` writes them.
+func searchInput(input map[string]any) (string, bool) {
+	pattern, ok := stringArg(input["pattern"])
+	if !ok {
+		return "", false
+	}
+	parts := []string{pattern}
+	if glob, ok := stringArg(input["glob"]); ok && glob != "**/*" {
+		parts = append(parts, "--glob "+glob)
+	}
+	if ic, _ := input["ignoreCase"].(bool); ic {
+		parts = append(parts, "--ignore-case")
+	}
+	if path, ok := stringArg(input["path"]); ok && path != "." {
+		parts = append(parts, "in "+path)
+	}
+	return strings.Join(parts, " "), true
+}
+
+var pastTenseVerbs = map[string]string{
+	"Reading": "Read", "Writing": "Wrote", "Editing": "Edited", "Running": "Ran",
+	"Listing": "Listed", "Finding": "Found", "Searching": "Searched",
+}
+
+// DescribeFinishedToolCall is the same description phrased for a call that has finished: only
+// the leading verb changes, which keeps the subject identical.
+func DescribeFinishedToolCall(toolName string, args any, workingDirectory string) string {
+	description := DescribeToolCall(toolName, args, workingDirectory)
+	verb, rest, _ := strings.Cut(description, " ")
+	if past, ok := pastTenseVerbs[verb]; ok {
+		if rest == "" && !strings.Contains(description, " ") {
+			return past
+		}
+		return past + " " + rest
+	}
+	return description
+}

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

@@ -0,0 +1,188 @@
+package mapper_test
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+	"unicode/utf16"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahp"
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/channels"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+)
+
+func utf16Len(s string) int { return len(utf16.Encode([]rune(s))) }
+
+// Twins of upstream test/activity.test.ts, describe "activity descriptions".
+func TestActivityDescriptions(t *testing.T) {
+	describe := func(name string, args any, cwd string) string { return mapper.DescribeToolCall(name, args, cwd) }
+
+	twin.Run(t, "activity", "names the file a read touches", func(t *testing.T) {
+		if got := describe("read", obj{"path": "/ws/src/main.ts"}, "/ws"); got != "Reading src/main.ts" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "activity", "renders paths relative to the workspace", func(t *testing.T) {
+		// An absolute path is mostly noise the user already knows.
+		if got := describe("edit", obj{"path": "/ws/a/b.ts"}, "/ws"); got != "Editing a/b.ts" {
+			t.Fatal(got)
+		}
+		if got := describe("edit", obj{"path": "/elsewhere/b.ts"}, "/ws"); got != "Editing /elsewhere/b.ts" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "activity", "shows the command a bash call runs", func(t *testing.T) {
+		if got := describe("bash", obj{"command": "npm test"}, ""); got != "Running npm test" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "activity", "shortens the middle, keeping both informative ends", func(t *testing.T) {
+		long := describe("bash", obj{"command": "git log " + strings.Repeat("x", 200) + " --oneline"}, "")
+		if utf16Len(long) >= 80 {
+			t.Fatalf("not shortened: %d units", utf16Len(long))
+		}
+		if !regexp.MustCompile(`^Running git log`).MatchString(long) || !strings.HasSuffix(long, "--oneline") {
+			t.Fatal(long)
+		}
+	})
+
+	twin.Run(t, "activity", "falls back to the tool's own name", func(t *testing.T) {
+		// Extension and custom tools still say something useful.
+		if got := describe("my_custom_tool", obj{}, ""); got != "Running my_custom_tool" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "activity", "copes with missing arguments", func(t *testing.T) {
+		if got := describe("read", nil, ""); got != "Reading a file" {
+			t.Fatal(got)
+		}
+		if got := describe("bash", obj{}, ""); got != "Running a command" {
+			t.Fatal(got)
+		}
+	})
+}
+
+func runActivity(t testing.TB, events []obj) replayed {
+	t.Helper()
+	m := mapper.NewTurnMapper("t", 0, mapper.Options{WorkingDirectory: "/ws"})
+	actions := []ahptypes.StateAction{mapper.UserTurnStarted("t", "go", "1970-01-01T00:00:00.000Z")}
+	for _, e := range events {
+		actions = append(actions, m.Handle(e)...)
+	}
+	state := channels.InitialChatState("ahp-chat:/a", "chat", nil)
+	for _, a := range actions {
+		ahp.ApplyActionToChat(state, a)
+	}
+	return replayed{actions: actions, state: toObj(t, state)}
+}
+
+// activities lists each chat/activityChanged action's activity, "<cleared>" when it has none.
+func activities(actions []ahptypes.StateAction) []string {
+	out := []string{}
+	for _, a := range ofType(actions, "chat/activityChanged") {
+		if s, ok := a["activity"].(string); ok {
+			out = append(out, s)
+		} else {
+			out = append(out, "<cleared>")
+		}
+	}
+	return out
+}
+
+func toolStartEvent(id, name string, args any) obj {
+	return obj{"type": "tool_execution_start", "toolCallId": id, "toolName": name, "args": args}
+}
+
+// Twins of upstream test/activity.test.ts, describe "activity over a turn".
+func TestActivityOverATurn(t *testing.T) {
+	msgStart := obj{"type": "message_start", "message": obj{"role": "assistant"}}
+
+	twin.Run(t, "activity", "tracks thinking, tools, and responding in order", func(t *testing.T) {
+		r := runActivity(t, []obj{
+			pi.agentStart(), msgStart,
+			toolStartEvent("tc1", "read", obj{"path": "/ws/a.ts"}),
+			{"type": "tool_execution_end", "toolCallId": "tc1", "toolName": "read", "result": obj{}, "isError": false},
+			pi.text(0, "done"), pi.settled(),
+		})
+		equal(t, activities(r.actions), []string{mapper.ThinkingActivity, "Reading a.ts", mapper.ThinkingActivity, mapper.RespondingActivity, "<cleared>"}, "activities")
+	})
+
+	twin.Run(t, "activity", "clears the description when the turn ends", func(t *testing.T) {
+		// A stale one would leave the client showing "Reading ..." against an idle chat.
+		r := runActivity(t, []obj{pi.agentStart(), toolStartEvent("tc1", "bash", obj{"command": "ls"}), pi.settled()})
+		if r.state["activity"] != nil {
+			t.Fatalf("activity = %v", r.state["activity"])
+		}
+	})
+
+	twin.Run(t, "activity", "clears it on a cancelled turn too", func(t *testing.T) {
+		m := mapper.NewTurnMapper("t", 0)
+		m.Handle(pi.agentStart())
+		equal(t, activities(m.Finish(mapper.OutcomeCancelled, "")), []string{"<cleared>"}, "activities")
+	})
+
+	twin.Run(t, "activity", "does not re-send an unchanged description", func(t *testing.T) {
+		// Every delta of one response is still "Responding"; re-sending would burn a serverSeq per token.
+		events := []obj{pi.agentStart(), msgStart}
+		for _, d := range []string{"a", "b", "c", "d"} {
+			events = append(events, pi.text(0, d))
+		}
+		events = append(events, pi.settled())
+		r := runActivity(t, events)
+		equal(t, activities(r.actions), []string{mapper.ThinkingActivity, mapper.RespondingActivity, "<cleared>"}, "activities")
+	})
+
+	twin.Run(t, "activity", "emits schema-conforming actions", func(t *testing.T) {
+		r := runActivity(t, []obj{pi.agentStart(), toolStartEvent("tc1", "grep", obj{"pattern": "TODO"}), pi.settled()})
+		for _, a := range r.actions {
+			if actionType(a) == "chat/activityChanged" {
+				assertActionsValid(t, []ahptypes.StateAction{a}, "activity")
+			}
+		}
+	})
+}
+
+// Twins of upstream test/activity.test.ts, describe "toolInputFor".
+func TestToolInputFor(t *testing.T) {
+	input := func(name string, args any) string {
+		s, ok := mapper.ToolInputFor(name, args)
+		if !ok {
+			t.Fatalf("no input for %s", name)
+		}
+		return s
+	}
+
+	twin.Run(t, "activity", "shows the one argument a call is about", func(t *testing.T) {
+		if got := input("bash", obj{"command": "ls -la", "timeout": 5}); got != "ls -la" {
+			t.Fatal(got)
+		}
+		if got := input("read", obj{"path": "a.ts", "offset": 1, "limit": 50}); got != "a.ts" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "activity", "keeps a search's scope, and drops the defaults models restate", func(t *testing.T) {
+		// Every one of these is what a capture actually contained: the model fills in the defaults.
+		if got := input("grep", obj{"pattern": "BEACON", "path": ".", "glob": "**/*", "ignoreCase": false, "limit": 100}); got != "BEACON" {
+			t.Fatal(got)
+		}
+		if got := input("grep", obj{"pattern": "TODO", "path": "src", "glob": "*.ts", "ignoreCase": true}); got != "TODO --glob *.ts --ignore-case in src" {
+			t.Fatal(got)
+		}
+	})
+
+	twin.Run(t, "activity", "falls back to the arguments for a tool it does not know", func(t *testing.T) {
+		// An extension's tool has no argument this code can single out; its arguments are still the
+		// most informative thing available for it.
+		if got := input("some-extension-tool", obj{"a": 1}); got != "{\n  \"a\": 1\n}" {
+			t.Fatalf("%q", got)
+		}
+	})
+}

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

@@ -0,0 +1,38 @@
+package mapper_test
+
+import (
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+)
+
+// One streamed text delta through the turn mapper: this runs for every token batch of a turn while a remote
+// client is attached (the listener is off, and nothing here runs, unless it is configured).
+//
+//	go test -run xxx -bench . -benchmem
+func BenchmarkMapTextDelta(b *testing.B) {
+	m := mapper.NewTurnMapper("turn-1", 0)
+	m.Handle(pi.agentStart())
+	m.Handle(pi.assistantStart())
+	delta := pi.text(0, "some streamed text from the model ")
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		m.Handle(delta)
+	}
+}
+
+func BenchmarkMapToolExecution(b *testing.B) {
+	m := mapper.NewTurnMapper("turn-1", 0)
+	m.Handle(pi.agentStart())
+	m.Handle(pi.assistantStart())
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		m.Handle(pi.toolStart(1, "call-1", "bash"))
+		m.Handle(pi.toolDelta(1, `{"command":"go test ./..."}`))
+		m.Handle(pi.toolEnd(1, "call-1", "bash", map[string]any{"command": "go test ./..."}))
+		m.Handle(pi.execUpdate("call-1", "bash", "ok  \tpkg\t0.1s\n"))
+		m.Handle(pi.execEnd("call-1", "bash", "ok  \tpkg\t0.1s\n", false))
+	}
+}