Agent tools: plant lookup, plant creation, journal entries (#55) (#69)

Co-authored-by: Steve Dudenhoeffer <[email protected]>
2026-07-21 06:05:05 +00:00
parent 5d9b10d7c7
commit a1bb8ec463
4 changed files with 555 additions and 22 deletions
@@ -2,6 +2,7 @@ package service

 import (
 	"context"
+	"sort"
 	"strings"

 	"gitea.stevedudenhoeffer.com/steve/pansy/internal/domain"
@@ -69,6 +70,124 @@ func (s *Service) ListPlants(ctx context.Context, actorID int64) ([]domain.Plant
 	return s.store.ListPlantsForActor(ctx, actorID)
 }

+// PlantMatch is a candidate from FindPlants: the plant, plus what seed the actor
+// has left of it, so an agent can say "you only have enough for half that bed"
+// instead of confidently planting seed that doesn't exist.
+type PlantMatch struct {
+	domain.Plant
+	// SeedRemaining is the total left across the actor's lots of this plant, and
+	// SeedUnit the unit they're counted in. Both are omitted when there are no
+	// lots — and also when the lots disagree about the unit, because adding
+	// grams to packets produces a number that means nothing. SeedLots still
+	// reports how many there are, so "several lots, no single total" is
+	// distinguishable from "no seed at all".
+	SeedRemaining *float64 `json:"seedRemaining,omitempty"`
+	SeedUnit      string   `json:"seedUnit,omitempty"`
+	SeedLots      int      `json:"seedLots,omitempty"`
+}
+
+// maxPlantMatches caps FindPlants. A model given fifty candidates is not being
+// helped; if the query is that broad the answer is to ask a better one.
+const maxPlantMatches = 10
+
+// FindPlants returns the plants in the actor's visible catalog (built-ins plus
+// their own) whose name or category matches the query, best match first.
+//
+// It deliberately returns SEVERAL candidates rather than one guess. "garlic"
+// against a catalog holding both "Garlic" and "German Red Garlic" is genuinely
+// ambiguous, and a caller with the surrounding conversation is far better placed
+// to disambiguate than a fuzzy-match heuristic here. An empty query returns the
+// catalog head rather than nothing, so a caller can browse.
+func (s *Service) FindPlants(ctx context.Context, actorID int64, query string) ([]PlantMatch, error) {
+	plants, err := s.store.ListPlantsForActor(ctx, actorID)
+	if err != nil {
+		return nil, err
+	}
+	q := strings.ToLower(strings.TrimSpace(query))
+
+	type scored struct {
+		plant domain.Plant
+		rank  int
+	}
+	ranked := make([]scored, 0, len(plants))
+	for _, p := range plants {
+		name := strings.ToLower(p.Name)
+		switch {
+		case q == "":
+			ranked = append(ranked, scored{p, 3})
+		case name == q:
+			ranked = append(ranked, scored{p, 0})
+		case strings.HasPrefix(name, q):
+			ranked = append(ranked, scored{p, 1})
+		case strings.Contains(name, q):
+			ranked = append(ranked, scored{p, 2})
+		case strings.Contains(strings.ToLower(p.Category), q):
+			ranked = append(ranked, scored{p, 3})
+		}
+	}
+	// Stable by rank then name, so the same query always answers the same way —
+	// a tool whose results reshuffle between calls is one a model can't reason
+	// about across turns.
+	sort.SliceStable(ranked, func(i, j int) bool {
+		if ranked[i].rank != ranked[j].rank {
+			return ranked[i].rank < ranked[j].rank
+		}
+		return ranked[i].plant.Name < ranked[j].plant.Name
+	})
+	if len(ranked) > maxPlantMatches {
+		ranked = ranked[:maxPlantMatches]
+	}
+
+	matches := make([]PlantMatch, 0, len(ranked))
+	for _, r := range ranked {
+		matches = append(matches, PlantMatch{Plant: r.plant})
+	}
+	if err := s.attachSeedRemaining(ctx, actorID, matches); err != nil {
+		return nil, err
+	}
+	return matches, nil
+}
+
+// attachSeedRemaining fills SeedRemaining/SeedUnit from the actor's lots.
+func (s *Service) attachSeedRemaining(ctx context.Context, actorID int64, matches []PlantMatch) error {
+	if len(matches) == 0 {
+		return nil
+	}
+	lots, err := s.ListSeedLots(ctx, actorID, nil)
+	if err != nil {
+		return err
+	}
+	byPlant := map[int64][]domain.SeedLot{}
+	for _, l := range lots {
+		byPlant[l.PlantID] = append(byPlant[l.PlantID], l)
+	}
+	for i := range matches {
+		ls := byPlant[matches[i].ID]
+		if len(ls) == 0 {
+			continue
+		}
+		matches[i].SeedLots = len(ls)
+		unit := ls[0].Unit
+		mixed := false
+		total := 0.0
+		for _, l := range ls {
+			total += l.Remaining
+			if l.Unit != unit {
+				mixed = true
+			}
+		}
+		if mixed {
+			// Dropping only the LABEL would leave a number that reads as a
+			// quantity and isn't one. Drop the total with it; SeedLots still says
+			// there is seed here, just not one figure for it.
+			continue
+		}
+		matches[i].SeedRemaining = &total
+		matches[i].SeedUnit = unit
+	}
+	return nil
+}
+
 // CreatePlant adds a plant owned by the actor. To "clone" a built-in the client
 // simply POSTs a copy — there is no dedicated endpoint, and the copy is owned by
 // (and editable by) the actor.
@@ -237,3 +237,138 @@ func TestDeletePlantInUseIsBlocked(t *testing.T) {
 		t.Errorf("delete freed plant: %v", err)
 	}
 }
+
+// TestFindPlantsRanksAndDisambiguates — FindPlants deliberately returns several
+// candidates rather than one guess, because "garlic" against a catalog holding
+// both "Garlic" and "German Red Garlic" is genuinely ambiguous and a caller with
+// the surrounding context is better placed to choose than a heuristic here.
+func TestFindPlantsRanksAndDisambiguates(t *testing.T) {
+	s := newTestService(t, openConfig())
+	owner := seedUser(t, s, "[email protected]")
+	ctx := context.Background()
+
+	custom, err := s.CreatePlant(ctx, owner, PlantInput{
+		Name: "German Red Garlic", Category: domain.CategoryVegetable, SpacingCM: 15,
+		Color: "#8a5a8a", Icon: "🧄",
+	})
+	if err != nil {
+		t.Fatalf("CreatePlant: %v", err)
+	}
+
+	got, err := s.FindPlants(ctx, owner, "garlic")
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	names := map[string]bool{}
+	for _, m := range got {
+		names[m.Name] = true
+	}
+	if !names["Garlic"] || !names[custom.Name] {
+		t.Errorf("got %v, want both the built-in and the custom variety", names)
+	}
+	// Exact match first, so a caller taking [0] gets the least surprising one.
+	if got[0].Name != "Garlic" {
+		t.Errorf("first match = %q, want the exact name", got[0].Name)
+	}
+
+	// Prefix beats substring: "german" should surface the custom one first.
+	pre, err := s.FindPlants(ctx, owner, "german")
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(pre) == 0 || pre[0].Name != custom.Name {
+		t.Errorf("FindPlants(german) = %+v, want the custom variety first", pre)
+	}
+
+	// Category search works, and a query matching nothing says so plainly.
+	if herbs, _ := s.FindPlants(ctx, owner, "herb"); len(herbs) == 0 {
+		t.Error("category search found nothing")
+	}
+	if none, _ := s.FindPlants(ctx, owner, "zzzzz"); len(none) != 0 {
+		t.Errorf("FindPlants(zzzzz) = %+v, want nothing", none)
+	}
+}
+
+// TestFindPlantsReportsSeedRemaining — so a caller can say "you only have enough
+// for half that bed" instead of confidently planting seed that doesn't exist.
+func TestFindPlantsReportsSeedRemaining(t *testing.T) {
+	s := newTestService(t, openConfig())
+	owner := seedUser(t, s, "[email protected]")
+	other := seedUser(t, s, "[email protected]")
+	ctx := context.Background()
+
+	plant := seedOwnPlant(t, s, owner, 15)
+	if _, err := s.CreateSeedLot(ctx, owner, SeedLotInput{
+		PlantID: plant.ID, Quantity: 100, Unit: domain.UnitSeeds,
+	}); err != nil {
+		t.Fatalf("CreateSeedLot: %v", err)
+	}
+
+	got, err := s.FindPlants(ctx, owner, plant.Name)
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(got) == 0 || got[0].SeedRemaining == nil || *got[0].SeedRemaining != 100 {
+		t.Fatalf("seedRemaining = %+v, want 100", got[0].SeedRemaining)
+	}
+	if got[0].SeedUnit != domain.UnitSeeds {
+		t.Errorf("seedUnit = %q", got[0].SeedUnit)
+	}
+
+	// A plant with no lots reports nothing rather than a misleading zero.
+	builtin, err := s.FindPlants(ctx, owner, "Garlic")
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(builtin) > 0 && builtin[0].SeedRemaining != nil {
+		t.Errorf("a plant with no lots reported %v remaining", *builtin[0].SeedRemaining)
+	}
+
+	// And lots are private: another user searching the same plant sees no seed.
+	// (They can't see the custom plant at all, so search a built-in instead.)
+	if _, err := s.CreateSeedLot(ctx, other, SeedLotInput{
+		PlantID: builtinPlantID(t, s, other), Quantity: 50, Unit: domain.UnitSeeds,
+	}); err != nil {
+		t.Fatalf("CreateSeedLot(other): %v", err)
+	}
+	mine, _ := s.FindPlants(ctx, owner, "Garlic")
+	for _, m := range mine {
+		if m.SeedRemaining != nil {
+			t.Errorf("saw another user's seed count on %q", m.Name)
+		}
+	}
+}
+
+// TestFindPlantsOmitsATotalItCannotHonestlyGive — lots in different units can't
+// be summed. Dropping only the unit LABEL would leave a number that reads as a
+// quantity and isn't one; the count of lots still says there is seed here.
+func TestFindPlantsOmitsATotalItCannotHonestlyGive(t *testing.T) {
+	s := newTestService(t, openConfig())
+	owner := seedUser(t, s, "[email protected]")
+	plant := seedOwnPlant(t, s, owner, 15)
+	ctx := context.Background()
+
+	for _, u := range []string{domain.UnitSeeds, domain.UnitGrams} {
+		if _, err := s.CreateSeedLot(ctx, owner, SeedLotInput{PlantID: plant.ID, Quantity: 50, Unit: u}); err != nil {
+			t.Fatalf("CreateSeedLot(%s): %v", u, err)
+		}
+	}
+
+	got, err := s.FindPlants(ctx, owner, plant.Name)
+	if err != nil {
+		t.Fatalf("FindPlants: %v", err)
+	}
+	if len(got) == 0 {
+		t.Fatal("plant not found")
+	}
+	if got[0].SeedRemaining != nil {
+		t.Errorf("reported %v across mismatched units; that number means nothing", *got[0].SeedRemaining)
+	}
+	if got[0].SeedUnit != "" {
+		t.Errorf("seedUnit = %q, want empty", got[0].SeedUnit)
+	}
+	// But "several lots, no single total" must stay distinguishable from "none".
+	if got[0].SeedLots != 2 {
+		t.Errorf("seedLots = %d, want 2", got[0].SeedLots)
+	}
+}