quick_ideas skill and job (Feature 18) (#146)

Co-authored-by: orchestrator-agent <20+orchestrator-agent@code.cubecraftcreations.com>

internal/ideas/ideas.go

@@ -1,10 +1,12 @@
-// Package ideas finds dinner ideas for Cook from what I have: from a list
-// of ingredients on hand, ideas_from_ingredients proposes dinners, each is
-// grounded with the recipe grounding pipeline (dropping those no recipe
-// grounds), and the ideas kept are reported as a job's result, which fills
-// as each idea grounds. A job that keeps no idea, or fails, shows no idea:
-// nothing is made up instead (D-017). Ideas are not stored as dinners: the
-// household acts on one later.
+// Package ideas finds dinner ideas for Cook from what I have and Quick
+// dinners: from a list of ingredients on hand, ideas_from_ingredients
+// proposes dinners, and for a kind of Quick dinner, quick_ideas does; each
+// is grounded with the recipe grounding pipeline (dropping those no recipe
+// grounds, and Quick dinners whose grounded recipe is not of the kind), and
+// the ideas kept are reported as a job's result, which fills as each idea
+// grounds. A job that keeps no idea, or fails, shows no idea: nothing is
+// made up instead (D-017). Ideas are not stored as dinners: the household
+// acts on one later.
 package ideas
 
 import (
@@ -14,15 +16,27 @@ import (
 	"fmt"
 	"log/slog"
 	"slices"
+	"time"
 
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
 )
 
-// KindFromIngredients is the job that finds ideas from ingredients.
-const KindFromIngredients = "ideas_from_ingredients"
+// Job kinds.
+const (
+	// KindFromIngredients is the job that finds ideas from ingredients.
+	KindFromIngredients = "ideas_from_ingredients"
+	// KindQuick is the job that finds a page of Quick dinner ideas.
+	KindQuick = "quick_ideas"
+)
+
+// ContextBudget is the character budget of the household context
+// quick_ideas is given (see harness.BuildContext).
+const ContextBudget = 16000
 
 // QuickMinutes is the most minutes from prep to table of a Quick dinner
 // not cooked in a crock pot.
@@ -38,25 +52,26 @@ const (
 // Reasons the job failed, stored as its failure code. Any other failure,
 // such as the database's, is the runner's internal_error.
 const (
-	// ReasonAIFailed: ideas_from_ingredients, or normalize_recipe while
-	// grounding, failed; no idea is made up instead (D-017).
+	// ReasonAIFailed: ideas_from_ingredients or quick_ideas, or
+	// normalize_recipe while grounding, failed; no idea is made up instead
+	// (D-017).
 	ReasonAIFailed = "ai_failed"
 	// ReasonSearchNotConfigured: recipe search is not set up.
 	ReasonSearchNotConfigured = "search_not_configured"
 	// ReasonSearchFailed: the search provider failed.
 	ReasonSearchFailed = "search_failed"
-	// ReasonNoIdeasFound: every idea was dropped, by
-	// ideas_from_ingredients' rules, because no recipe grounds it, or, for
-	// a Quick only request, because its grounded recipe is not a Quick
-	// dinner.
+	// ReasonNoIdeasFound: every idea was dropped, by the skill's rules,
+	// because no recipe grounds it, or because its grounded recipe is not
+	// a Quick dinner (a Quick only request) or not of the kind asked for (a
+	// Quick dinners request).
 	ReasonNoIdeasFound = "no_ideas_found"
 )
 
-// Reasons are every failure reason of the job.
+// Reasons are every failure reason of both jobs.
 var Reasons = []string{ReasonAIFailed, ReasonSearchNotConfigured, ReasonSearchFailed, ReasonNoIdeasFound}
 
 // InvalidError is a request the household must correct, such as an empty
-// ingredient list.
+// ingredient list or an unknown kind of Quick dinner.
 type InvalidError struct {
 	Message string
 }
@@ -68,42 +83,68 @@ func (e *InvalidError) Error() string { return e.Message }
 // with the household's harness.Config.
 type Generator func(ctx context.Context, scope string, in skills.IdeasRequest) (skills.Ideas, error)
 
+// QuickGenerator runs quick_ideas on in; scope is skills.QuickIdeasScope(in).
+// In production it is skills.QuickIdeas with the household's
+// harness.Config.
+type QuickGenerator func(ctx context.Context, scope string, in skills.QuickIdeasRequest) (skills.QuickIdeaList, error)
+
 // Service starts and runs idea jobs.
 type Service struct {
+	st       *store.Store
 	grounder *recipes.Grounder
 	generate Generator
+	quick    QuickGenerator
 	logger   *slog.Logger
 	job      *jobs.Kind[FromIngredientsJob]
+	quickJob *jobs.Kind[QuickJob]
 }
 
-// NewService returns a service that finds ideas with generate, grounds
-// them with grounder and registers the KindFromIngredients job on runner,
-// which must not have started yet. The job is started only by
-// StartFromIngredients, which checks the ingredient list first.
-func NewService(grounder *recipes.Grounder, generate Generator, runner *jobs.Runner, logger *slog.Logger) (*Service, error) {
+// NewService returns a service that reads the household context from st,
+// finds ideas with generate and Quick dinner ideas with quick, grounds
+// them with grounder and registers the KindFromIngredients and KindQuick
+// jobs on runner, which must not have started yet. The jobs are started
+// only by StartFromIngredients and StartQuick, which check the request
+// first.
+func NewService(st *store.Store, grounder *recipes.Grounder, generate Generator, quick QuickGenerator, runner *jobs.Runner, logger *slog.Logger) (*Service, error) {
 	switch {
+	case st == nil:
+		return nil, errors.New("ideas: nil store")
 	case grounder == nil:
 		return nil, errors.New("ideas: nil grounder")
 	case generate == nil:
 		return nil, errors.New("ideas: nil generator")
+	case quick == nil:
+		return nil, errors.New("ideas: nil quick generator")
 	case runner == nil:
 		return nil, errors.New("ideas: nil job runner")
 	case logger == nil:
 		return nil, errors.New("ideas: nil logger")
 	}
-	s := &Service{grounder: grounder, generate: generate, logger: logger}
-	kind, err := jobs.Register(runner, KindFromIngredients, s.run, Reasons...)
+	s := &Service{st: st, grounder: grounder, generate: generate, quick: quick, logger: logger}
+	var err error
+	if s.job, err = register(runner, KindFromIngredients, s.run, withoutIdeas[Result]); err != nil {
+		return nil, err
+	}
+	if s.quickJob, err = register(runner, KindQuick, s.runQuick, withoutIdeas[QuickResult]); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+// register registers the service-only job name, run by run, whose failed
+// jobs show their result through failed.
+func register[P any, R jobs.Public](runner *jobs.Runner, name string, run jobs.Handler[P, R], failed func(json.RawMessage) (json.RawMessage, error)) (*jobs.Kind[P], error) {
+	kind, err := jobs.Register(runner, name, run, Reasons...)
 	if err != nil {
 		return nil, err
 	}
 	if err := kind.ServiceOnly(); err != nil {
 		return nil, err
 	}
-	if err := kind.FailedResult(withoutIdeas); err != nil {
+	if err := kind.FailedResult(failed); err != nil {
 		return nil, err
 	}
-	s.job = kind
-	return s, nil
+	return kind, nil
 }
 
 // FromIngredientsJob is the KindFromIngredients payload: the ingredients
@@ -195,31 +236,54 @@ func IsQuick(method string, minutes *int) bool {
 // other grounding failure fails the job, as does ideas_from_ingredients
 // failing, with no idea made up instead. The result is published at each
 // stage and again as each idea is kept, so it fills as the ideas ground.
-// Before the job fails, its result is published again with no ideas, to
-// tidy the stored result. That write is not what keeps a failed job from
-// showing ideas, since it may fail and a job interrupted by restart never
-// makes it: withoutIdeas, applied whenever a failed job is read, is.
+// Before the job fails, its result is published again with no ideas (see
+// finish).
 func (s *Service) run(ctx context.Context, p FromIngredientsJob, publish func(Result) error) (Result, error) {
 	res, err := s.fill(ctx, p, publish)
-	if err != nil {
-		if ctx.Err() != nil {
-			return Result{}, err
-		}
-		var failure *jobs.Failure
-		if errors.As(err, &failure) {
-			// Only the code is logged: the error may quote a model's or
-			// search provider's response.
-			s.logger.InfoContext(ctx, "ideas from ingredients failed", "reason", failure.Code)
-		}
-		if len(res.Ideas) > 0 {
-			res.Ideas = []Idea{}
-			if perr := publish(res); perr != nil {
-				return Result{}, fmt.Errorf("ideas: clear failed job's ideas: %w", perr)
-			}
-		}
-		return Result{}, err
+	return finish(ctx, s.logger, "ideas from ingredients", res, err, publish)
+}
+
+// shownResult is a job result that shows ideas.
+type shownResult[R any] interface {
+	jobs.Public
+	// shown is how many ideas the result shows.
+	shown() int
+	// cleared is the result showing no ideas.
+	cleared() R
+}
+
+func (r Result) shown() int { return len(r.Ideas) }
+
+func (r Result) cleared() Result {
+	r.Ideas = []Idea{}
+	return r
+}
+
+// finish ends a job whose work returned res and err. A job that failed
+// has its result published again with no ideas, to tidy the stored
+// result. That write is not what keeps a failed job from showing ideas,
+// since it may fail and a job interrupted by restart never makes it:
+// withoutIdeas, applied whenever a failed job is read, is.
+func finish[R shownResult[R]](ctx context.Context, logger *slog.Logger, what string, res R, err error, publish func(R) error) (R, error) {
+	var zero R
+	if err == nil {
+		return res, nil
 	}
-	return res, nil
+	if ctx.Err() != nil {
+		return zero, err
+	}
+	var failure *jobs.Failure
+	if errors.As(err, &failure) {
+		// Only the code is logged: the error may quote a model's or
+		// search provider's response.
+		logger.InfoContext(ctx, what+" failed", "reason", failure.Code)
+	}
+	if res.shown() > 0 {
+		if perr := publish(res.cleared()); perr != nil {
+			return zero, fmt.Errorf("ideas: clear failed job's ideas: %w", perr)
+		}
+	}
+	return zero, err
 }
 
 // fill does run's work, returning a *jobs.Failure for a failure the
@@ -243,34 +307,16 @@ func (s *Service) fill(ctx context.Context, p FromIngredientsJob, publish func(R
 	if err := publish(res); err != nil {
 		return res, err
 	}
-	// order[k] is the index in out.Ideas of res.Ideas[k], so each idea is
-	// put in its place in the model's order as it grounds.
-	var order []int
-	for next := 0; len(res.Ideas) < skills.IdeasKept && next < len(out.Ideas); {
-		first := next
-		round := out.Ideas[first:min(first+skills.IdeasKept-len(res.Ideas), len(out.Ideas))]
-		next += len(round)
-		err := s.ground(ctx, round, func(i int, gr *recipes.Grounded) error {
-			if gr == nil {
-				res.Dropped++
-				return nil
-			}
-			idea := ideaOf(round[i], *gr)
-			if p.QuickOnly && !idea.Quick {
-				res.Dropped++
-				return nil
-			}
-			at := len(order)
-			for at > 0 && order[at-1] > first+i {
-				at--
-			}
-			order = slices.Insert(order, at, first+i)
-			res.Ideas = slices.Insert(res.Ideas, at, idea)
-			return publish(res)
-		})
-		if err != nil {
-			return res, err
-		}
+	reqs := make([]recipes.GroundRequest, len(out.Ideas))
+	for i, idea := range out.Ideas {
+		reqs[i] = recipes.GroundRequest{DishName: idea.Name, Query: idea.SearchQuery}
+	}
+	err = keepGrounded(ctx, s.grounder, reqs, skills.IdeasKept, &res.Ideas, &res.Dropped, func(i int, gr recipes.Grounded) (Idea, bool) {
+		idea := ideaOf(out.Ideas[i], gr)
+		return idea, !p.QuickOnly || idea.Quick
+	}, func() error { return publish(res) })
+	if err != nil {
+		return res, err
 	}
 	if len(res.Ideas) == 0 {
 		return res, &jobs.Failure{Code: ReasonNoIdeasFound}
@@ -279,20 +325,58 @@ func (s *Service) fill(ctx context.Context, p FromIngredientsJob, publish func(R
 	return res, nil
 }
 
-// ground grounds ideas by their search queries and calls kept, one call at
-// a time, as each idea grounds, with its index in ideas and its
-// grounding, or nil when no recipe grounds it. Any other grounding
-// failure, or kept failing, stops the groundings still running and is
-// returned, as a *jobs.Failure when the household may see it.
-func (s *Service) ground(ctx context.Context, ideas []skills.Idea, kept func(i int, gr *recipes.Grounded) error) error {
+// keepGrounded grounds reqs with g in their order, at most the number
+// still wanted at a time, until want ideas are shown or none are left. As
+// each grounds, keep makes its idea from request i's grounding and says
+// whether it is kept: a kept idea is put in *shown in its place in reqs'
+// order (an idea that grounds sooner than one before it is shown first,
+// and the earlier one is put back in its place when it grounds) and
+// publish is called. An idea no recipe grounds, or that keep refuses,
+// counts in *dropped. Any other grounding failure, or publish failing, is
+// returned (see ground).
+func keepGrounded[T any](ctx context.Context, g *recipes.Grounder, reqs []recipes.GroundRequest, want int, shown *[]T, dropped *int, keep func(i int, gr recipes.Grounded) (T, bool), publish func() error) error {
+	// order[k] is the index in reqs of (*shown)[k], so each idea is put in
+	// its place in reqs' order as it grounds.
+	var order []int
+	for next := 0; len(*shown) < want && next < len(reqs); {
+		first := next
+		round := reqs[first:min(first+want-len(*shown), len(reqs))]
+		next += len(round)
+		err := ground(ctx, g, round, func(i int, gr *recipes.Grounded) error {
+			if gr == nil {
+				*dropped++
+				return nil
+			}
+			idea, ok := keep(first+i, *gr)
+			if !ok {
+				*dropped++
+				return nil
+			}
+			at := len(order)
+			for at > 0 && order[at-1] > first+i {
+				at--
+			}
+			order = slices.Insert(order, at, first+i)
+			*shown = slices.Insert(*shown, at, idea)
+			return publish()
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ground grounds reqs with g and calls kept, one call at a time, as each
+// request grounds, with its index in reqs and its grounding, or nil when
+// no recipe grounds it. Any other grounding failure, or kept failing,
+// stops the groundings still running and is returned, as a *jobs.Failure
+// when the household may see it.
+func ground(ctx context.Context, g *recipes.Grounder, reqs []recipes.GroundRequest, kept func(i int, gr *recipes.Grounded) error) error {
 	groundCtx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	reqs := make([]recipes.GroundRequest, len(ideas))
-	for i, idea := range ideas {
-		reqs[i] = recipes.GroundRequest{DishName: idea.Name, Query: idea.SearchQuery}
-	}
 	var failed error
-	s.grounder.GroundEach(groundCtx, reqs, func(i int, r recipes.GroundResult) {
+	g.GroundEach(groundCtx, reqs, func(i int, r recipes.GroundResult) {
 		if failed != nil {
 			return
 		}
@@ -309,7 +393,7 @@ func (s *Service) ground(ctx context.Context, ideas []skills.Idea, kept func(i i
 		case errors.Is(r.Err, recipes.ErrNormalizeFailed):
 			failed = &jobs.Failure{Code: ReasonAIFailed}
 		default:
-			failed = fmt.Errorf("ideas: ground %q: %w", ideas[i].Name, r.Err)
+			failed = fmt.Errorf("ideas: ground %q: %w", reqs[i].DishName, r.Err)
 		}
 		if failed != nil {
 			cancel()
@@ -324,13 +408,12 @@ func (s *Service) ground(ctx context.Context, ideas []skills.Idea, kept func(i i
 // withoutIdeas is a failed job's stored result as the job shows it: with no
 // ideas, however the job failed, so a failed job never shows ideas kept
 // before the failure.
-func withoutIdeas(stored json.RawMessage) (json.RawMessage, error) {
-	var res Result
+func withoutIdeas[R shownResult[R]](stored json.RawMessage) (json.RawMessage, error) {
+	var res R
 	if err := json.Unmarshal(stored, &res); err != nil {
 		return nil, fmt.Errorf("ideas: decode failed job's result: %w", err)
 	}
-	res.Ideas = []Idea{}
-	return res.PublicJSON()
+	return res.cleared().PublicJSON()
 }
 
 // ideaOf is idea as grounded by gr.
@@ -350,3 +433,159 @@ func ideaOf(idea skills.Idea, gr recipes.Grounded) Idea {
 		SiteName:     gr.SiteName,
 	}
 }
+
+// QuickJob is the KindQuick payload: the kind of Quick dinner wanted,
+// skills.QuickCrockpot or skills.QuickUnder30, and the names already shown
+// to the household, as skills.CleanExclude returns them.
+type QuickJob struct {
+	Kind    string   `json:"kind"`
+	Exclude []string `json:"exclude"`
+}
+
+// StartQuick enqueues a KindQuick job for a page of Quick dinner ideas of
+// kind, none repeating a name in exclude, and returns its id. A kind
+// skills.CheckQuickKind refuses, with no default, or an exclude list
+// skills.CleanExclude refuses, is an *InvalidError, and starts nothing.
+func (s *Service) StartQuick(ctx context.Context, kind string, exclude []string) (Started, error) {
+	if err := skills.CheckQuickKind(kind); err != nil {
+		return Started{}, &InvalidError{Message: "kind: " + err.Error()}
+	}
+	names, err := skills.CleanExclude(exclude)
+	if err != nil {
+		return Started{}, &InvalidError{Message: "exclude: " + err.Error()}
+	}
+	id, err := s.quickJob.Enqueue(ctx, QuickJob{Kind: kind, Exclude: names})
+	if err != nil {
+		return Started{}, fmt.Errorf("ideas: enqueue: %w", err)
+	}
+	return Started{JobID: id}, nil
+}
+
+// QuickIdea is a grounded Quick dinner idea as the job's result shows it.
+// Method, MinutesTotal and Difficulty are the grounded recipe's, never the
+// model's estimates, and always make it of the kind asked for (see
+// OfQuickKind).
+type QuickIdea struct {
+	Name string `json:"name"`
+	// Method is stovetop, oven, crockpot, grill or other: crockpot for
+	// skills.QuickCrockpot.
+	Method string `json:"method"`
+	// MinutesTotal is prep to table, null when the recipe does not say:
+	// never null, and at most QuickMinutes, for skills.QuickUnder30.
+	MinutesTotal *int `json:"minutes_total"`
+	// Difficulty is easy, medium or hard.
+	Difficulty string `json:"difficulty"`
+	RecipeID   string `json:"recipe_id"`
+	PhotoURL   string `json:"photo_url"`
+	SourceURL  string `json:"source_url"`
+	SiteName   string `json:"site_name"`
+}
+
+// QuickResult is the KindQuick result, published as the job goes: its
+// stage, the request, the ideas grounded so far in the model's order (as
+// in Result), and how many ideas were dropped, by quick_ideas' rules
+// (repeating a name already shown or an earlier idea), because no recipe
+// grounds them, or because the grounded recipe is not of the kind.
+type QuickResult struct {
+	Stage   string      `json:"stage"`
+	Kind    string      `json:"kind"`
+	Exclude []string    `json:"exclude"`
+	Ideas   []QuickIdea `json:"ideas"`
+	Dropped int         `json:"dropped"`
+}
+
+func (r QuickResult) PublicJSON() ([]byte, error) { return json.Marshal(r) }
+
+func (r QuickResult) shown() int { return len(r.Ideas) }
+
+func (r QuickResult) cleared() QuickResult {
+	r.Ideas = []QuickIdea{}
+	return r
+}
+
+// OfQuickKind reports whether a recipe cooked by method in minutes (nil
+// when unknown) is a Quick dinner of kind: for skills.QuickCrockpot,
+// cooked in a crock pot (normalize_recipe writes a slow cooker as
+// crockpot); for skills.QuickUnder30, known to be 30 minutes or less from
+// prep to table. Any other kind is none.
+func OfQuickKind(kind, method string, minutes *int) bool {
+	switch kind {
+	case skills.QuickCrockpot:
+		return method == "crockpot"
+	case skills.QuickUnder30:
+		return minutes != nil && *minutes <= QuickMinutes
+	}
+	return false
+}
+
+// runQuick runs a KindQuick job: from the household context, it asks
+// quick_ideas for skills.QuickIdeasRequested ideas of the kind, more than
+// a page holds, then grounds them in the model's order, at most the number
+// still wanted at a time, until skills.QuickIdeasKept are kept or none are
+// left. An idea no recipe grounds is dropped, and so is one whose grounded
+// recipe is not of the kind (OfQuickKind): the model's estimate never
+// keeps an idea. When fewer than skills.QuickIdeasKept survive, the page
+// shows only those: fewer is honest, and it is never padded with an idea
+// not of the kind. When every idea is dropped the job fails with
+// ReasonNoIdeasFound. Any other grounding failure fails the job, as does
+// quick_ideas failing, with no idea made up instead. The result is
+// published at each stage and again as each idea is kept, and a failed job
+// shows no ideas, as for KindFromIngredients (see finish).
+func (s *Service) runQuick(ctx context.Context, p QuickJob, publish func(QuickResult) error) (QuickResult, error) {
+	res, err := s.fillQuick(ctx, p, publish)
+	return finish(ctx, s.logger, "quick ideas", res, err, publish)
+}
+
+// fillQuick does runQuick's work as fill does run's.
+func (s *Service) fillQuick(ctx context.Context, p QuickJob, publish func(QuickResult) error) (QuickResult, error) {
+	res := QuickResult{Stage: StageSuggesting, Kind: p.Kind, Exclude: p.Exclude, Ideas: []QuickIdea{}}
+	if err := publish(res); err != nil {
+		return res, err
+	}
+	hctx, err := harness.BuildContext(ctx, s.st, time.Now(), ContextBudget)
+	if err != nil {
+		return res, fmt.Errorf("ideas: %w", err)
+	}
+	in := skills.QuickIdeasRequest{Context: hctx, Kind: p.Kind, Exclude: p.Exclude}
+	out, err := s.quick(ctx, skills.QuickIdeasScope(in), in)
+	if err != nil {
+		if ctx.Err() != nil {
+			return res, ctx.Err()
+		}
+		return res, &jobs.Failure{Code: ReasonAIFailed}
+	}
+	res.Stage = StageGrounding
+	res.Dropped = len(out.Dropped)
+	if err := publish(res); err != nil {
+		return res, err
+	}
+	reqs := make([]recipes.GroundRequest, len(out.Ideas))
+	for i, idea := range out.Ideas {
+		reqs[i] = recipes.GroundRequest{DishName: idea.Name, Query: idea.SearchQuery}
+	}
+	err = keepGrounded(ctx, s.grounder, reqs, skills.QuickIdeasKept, &res.Ideas, &res.Dropped, func(i int, gr recipes.Grounded) (QuickIdea, bool) {
+		return quickIdeaOf(out.Ideas[i], gr), OfQuickKind(p.Kind, gr.Method, gr.MinutesTotal)
+	}, func() error { return publish(res) })
+	if err != nil {
+		return res, err
+	}
+	if len(res.Ideas) == 0 {
+		return res, &jobs.Failure{Code: ReasonNoIdeasFound}
+	}
+	res.Stage = StageDone
+	return res, nil
+}
+
+// quickIdeaOf is idea as grounded by gr.
+func quickIdeaOf(idea skills.QuickIdea, gr recipes.Grounded) QuickIdea {
+	return QuickIdea{
+		Name:         idea.Name,
+		Method:       gr.Method,
+		MinutesTotal: gr.MinutesTotal,
+		Difficulty:   gr.Difficulty,
+		RecipeID:     gr.RecipeID,
+		PhotoURL:     dinners.PhotoURL(gr.PhotoID),
+		SourceURL:    gr.SourceURL,
+		SiteName:     gr.SiteName,
+	}
+}

internal/ideas/ideas_test.go

@@ -16,6 +16,7 @@ import (
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/llm"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes"
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/recipes/recipestest"
@@ -32,17 +33,21 @@ type env struct {
 	search *recipestest.Search
 	pages  *recipestest.Pages
 	images *recipestest.Images
-	// model answers ideas_from_ingredients; normalize answers
-	// normalize_recipe while grounding.
+	// model answers ideas_from_ingredients and quick_ideas; normalize
+	// answers normalize_recipe while grounding.
 	model     *llm.Fake
 	normalize *llm.Fake
-	// fail, when set, fails ideas_from_ingredients without a model call.
+	// fail, when set, fails ideas_from_ingredients and quick_ideas without
+	// a model call.
 	fail error
+	st   *store.Store
 }
 
-// newEnv returns an ideas service over a migrated store and an unstarted
+// newEnv returns an ideas service over a migrated store with the
+// household's settings seeded and an unstarted
 // job runner. It finds ideas through the real harness and
-// ideas_from_ingredients with the scripted e.model, and grounds with fake
+// ideas_from_ingredients or quick_ideas with the scripted e.model, and
+// grounds with fake
 // search, pages and images and the scripted e.normalize.
 func newEnv(t *testing.T) *env {
 	t.Helper()
@@ -60,12 +65,16 @@ func newEnv(t *testing.T) *env {
 	if err := store.Migrate(ctx, st.Writer, migrations.FS); err != nil {
 		t.Fatal(err)
 	}
+	if err := household.SeedSettings(ctx, st, "America/New_York"); err != nil {
+		t.Fatal(err)
+	}
 	e := &env{
 		search:    &recipestest.Search{Results: map[string][]recipes.Candidate{}},
 		pages:     &recipestest.Pages{Bodies: map[string][]byte{}},
 		images:    &recipestest.Images{JPEGs: map[string][]byte{}},
 		model:     &llm.Fake{},
 		normalize: &llm.Fake{},
+		st:        st,
 	}
 	g := recipestest.NewGrounder(t, st, dataDir, e.search, e.pages, e.images, e.normalize)
 	guard, err := harness.NewGuard(harness.DefaultMaxCalls)
@@ -84,12 +93,18 @@ func newEnv(t *testing.T) *env {
 		}
 		return skills.IdeasFromIngredients(ctx, cfg, scope, in)
 	}
+	quick := func(ctx context.Context, scope string, in skills.QuickIdeasRequest) (skills.QuickIdeaList, error) {
+		if e.fail != nil {
+			return skills.QuickIdeaList{}, e.fail
+		}
+		return skills.QuickIdeas(ctx, cfg, scope, in)
+	}
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	e.runner, err = jobs.NewRunner(st, logger, 1)
 	if err != nil {
 		t.Fatal(err)
 	}
-	e.svc, err = NewService(g, generate, e.runner, logger)
+	e.svc, err = NewService(st, g, generate, quick, e.runner, logger)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/ideas/quick_test.go

@@ -0,0 +1,400 @@
+package ideas
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"slices"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/skills"
+	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/jobs"
+)
+
+// quickIdea renders one idea of a quick_ideas reply whose search query is
+// its name.
+func quickIdea(name, method string, minutes int) string {
+	return fmt.Sprintf(`{"name":%q,"est_minutes":%d,"method":%q,"difficulty":"easy","search_query":%q}`,
+		name, minutes, method, name)
+}
+
+// quickRecorder collects every result a quick job publishes.
+type quickRecorder struct {
+	mu        sync.Mutex
+	published []QuickResult
+}
+
+func (r *quickRecorder) latest() (QuickResult, bool) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if len(r.published) == 0 {
+		return QuickResult{}, false
+	}
+	return r.published[len(r.published)-1], true
+}
+
+func (r *quickRecorder) publish(res QuickResult) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	res.Ideas = append([]QuickIdea(nil), res.Ideas...)
+	r.published = append(r.published, res)
+	return nil
+}
+
+// runQuick runs the quick job's handler directly, recording each publish.
+func (e *env) runQuick(t *testing.T, kind string, exclude ...string) (QuickResult, []QuickResult, error) {
+	t.Helper()
+	names, err := skills.CleanExclude(exclude)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rec quickRecorder
+	res, err := e.svc.runQuick(t.Context(), QuickJob{Kind: kind, Exclude: names}, rec.publish)
+	return res, rec.published, err
+}
+
+func quickNames(list []QuickIdea) []string {
+	out := []string{}
+	for _, i := range list {
+		out = append(out, i.Name)
+	}
+	return out
+}
+
+func TestUnder30DropsIdeasOverThirtyMinutes(t *testing.T) {
+	e := newEnv(t)
+	// The model estimates every idea under 30 minutes; the grounded
+	// recipes decide.
+	e.recipe(t, "Chicken Fried Rice", "Chicken Fried Rice", 25)
+	e.recipe(t, "Beef Stroganoff", "Beef Stroganoff", 45)
+	e.recipe(t, "Shrimp Scampi", "Shrimp Scampi", 30)
+	e.recipe(t, "Chicken Chili", "Slow Cooker Chicken Chili", 240)
+	e.reply(
+		quickIdea("Chicken Fried Rice", "stovetop", 20),
+		quickIdea("Beef Stroganoff", "stovetop", 25),
+		quickIdea("Shrimp Scampi", "stovetop", 20),
+		quickIdea("Chicken Chili", "crockpot", 25),
+	)
+	res, _, err := e.runQuick(t, skills.QuickUnder30)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := quickNames(res.Ideas), []string{"Chicken Fried Rice", "Shrimp Scampi"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("ideas = %q, want %q: the 45-minute and the crock pot ideas dropped", got, want)
+	}
+	if res.Dropped != 2 || res.Stage != StageDone || res.Kind != skills.QuickUnder30 {
+		t.Fatalf("result = %+v, want done with 2 dropped", res)
+	}
+	for _, i := range res.Ideas {
+		if i.MinutesTotal == nil || *i.MinutesTotal > QuickMinutes || i.RecipeID == "" || i.PhotoURL == "" {
+			t.Errorf("idea %+v is not a grounded dinner of 30 minutes or less", i)
+		}
+	}
+}
+
+func TestCrockpotDropsStovetopIdeas(t *testing.T) {
+	e := newEnv(t)
+	// The model calls every idea a crock pot dinner; only the recipes
+	// cooked in a slow cooker are.
+	e.recipe(t, "Pulled Pork", "Slow Cooker Pulled Pork", 480)
+	e.recipe(t, "Beef Stew", "Beef Stew", 150)
+	e.recipe(t, "Chicken Tortilla Soup", "Crock Pot Chicken Tortilla Soup", 375)
+	e.recipe(t, "Chicken Fried Rice", "Chicken Fried Rice", 25)
+	e.reply(
+		quickIdea("Pulled Pork", "crockpot", 480),
+		quickIdea("Beef Stew", "crockpot", 360),
+		quickIdea("Chicken Tortilla Soup", "crockpot", 375),
+		quickIdea("Chicken Fried Rice", "crockpot", 240),
+	)
+	res, _, err := e.runQuick(t, skills.QuickCrockpot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := quickNames(res.Ideas), []string{"Pulled Pork", "Chicken Tortilla Soup"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("ideas = %q, want %q: the stovetop ideas dropped", got, want)
+	}
+	if res.Dropped != 2 {
+		t.Fatalf("dropped %d, want 2", res.Dropped)
+	}
+	for _, i := range res.Ideas {
+		if i.Method != "crockpot" {
+			t.Errorf("idea %q method %s, want the grounded crockpot", i.Name, i.Method)
+		}
+	}
+	if m := res.Ideas[0].MinutesTotal; m == nil || *m != 480 {
+		t.Errorf("Pulled Pork minutes_total = %v, want the recipe's 480", m)
+	}
+}
+
+func TestExcludedNamesAreNeverReturned(t *testing.T) {
+	e := newEnv(t)
+	// Every idea has a recipe that would ground it as a Quick dinner.
+	for _, name := range []string{"Easy Chicken Fried Rice", "shrimp-tacos", "Garlic Shrimp Pasta"} {
+		e.recipe(t, name, name, 20)
+	}
+	e.reply(
+		quickIdea("Easy Chicken Fried Rice", "stovetop", 20),
+		quickIdea("shrimp-tacos", "stovetop", 15),
+		quickIdea("Garlic Shrimp Pasta", "stovetop", 25),
+	)
+	res, _, err := e.runQuick(t, skills.QuickUnder30, "Chicken Fried Rice", "Shrimp Tacos")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := quickNames(res.Ideas); !reflect.DeepEqual(got, []string{"Garlic Shrimp Pasta"}) || res.Dropped != 2 {
+		t.Fatalf("ideas = %q dropped %d, want only Garlic Shrimp Pasta with 2 dropped", got, res.Dropped)
+	}
+	if got := e.search.Queries(); !reflect.DeepEqual(got, []string{"Garlic Shrimp Pasta"}) {
+		t.Errorf("searched %q, want the excluded names never grounded", got)
+	}
+	if !reflect.DeepEqual(res.Exclude, []string{"Chicken Fried Rice", "Shrimp Tacos"}) {
+		t.Errorf("result exclude = %q", res.Exclude)
+	}
+	// The model was told what was already shown.
+	if system := e.model.Requests()[0].System; !strings.Contains(system, "### Already shown\n- Chicken Fried Rice\n- Shrimp Tacos") {
+		t.Errorf("prompt does not list the names already shown:\n%s", system)
+	}
+}
+
+func TestQuickPageStopsAtSixAndShowsFewerHonestly(t *testing.T) {
+	t.Run("twelve ideas, six shown", func(t *testing.T) {
+		e := newEnv(t)
+		var reply []string
+		for i := range skills.QuickIdeasRequested {
+			name := fmt.Sprintf("Skillet Dish %c", 'A'+i)
+			e.recipe(t, name, name, 20)
+			reply = append(reply, quickIdea(name, "stovetop", 20))
+		}
+		e.reply(reply...)
+		res, _, err := e.runQuick(t, skills.QuickUnder30)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(res.Ideas) != skills.QuickIdeasKept || res.Dropped != 0 {
+			t.Fatalf("ideas = %q dropped %d, want %d", quickNames(res.Ideas), res.Dropped, skills.QuickIdeasKept)
+		}
+		if got := e.search.Queries(); len(got) != skills.QuickIdeasKept {
+			t.Errorf("searched %d ideas, want only the %d a page holds", len(got), skills.QuickIdeasKept)
+		}
+	})
+	t.Run("over-generated ideas replace dropped ones", func(t *testing.T) {
+		e := newEnv(t)
+		var reply []string
+		// The first six ground too slow, so the next six are grounded to
+		// fill the page; only three of those are quick.
+		for i := range skills.QuickIdeasRequested {
+			name := fmt.Sprintf("Skillet Dish %c", 'A'+i)
+			minutes := 20
+			if i < 6 || i%2 == 1 {
+				minutes = 50
+			}
+			e.recipe(t, name, name, minutes)
+			reply = append(reply, quickIdea(name, "stovetop", 20))
+		}
+		e.reply(reply...)
+		res, _, err := e.runQuick(t, skills.QuickUnder30)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Fewer than six survive: the page shows three, never padded.
+		if got, want := quickNames(res.Ideas), []string{"Skillet Dish G", "Skillet Dish I", "Skillet Dish K"}; !reflect.DeepEqual(got, want) || res.Dropped != 9 || res.Stage != StageDone {
+			t.Fatalf("result %s ideas %q dropped %d, want done with %q and 9 dropped", res.Stage, got, res.Dropped, want)
+		}
+	})
+}
+
+func TestQuickResultFillsAsEachIdeaGrounds(t *testing.T) {
+	e := newEnv(t)
+	for _, name := range []string{"Chicken Fried Rice", "Shrimp Scampi", "Garlic Shrimp Pasta"} {
+		e.recipe(t, name, name, 25)
+	}
+	// The first idea's search waits, so the two after it ground first.
+	gate := make(chan struct{})
+	e.search.Gates = map[string]chan struct{}{"Chicken Fried Rice": gate}
+	e.reply(
+		quickIdea("Chicken Fried Rice", "stovetop", 20),
+		quickIdea("Shrimp Scampi", "stovetop", 20),
+		quickIdea("Garlic Shrimp Pasta", "stovetop", 25),
+	)
+	var rec quickRecorder
+	type outcome struct {
+		res QuickResult
+		err error
+	}
+	done := make(chan outcome, 1)
+	go func() {
+		res, err := e.svc.runQuick(t.Context(), QuickJob{Kind: skills.QuickUnder30, Exclude: []string{}}, rec.publish)
+		done <- outcome{res, err}
+	}()
+
+	deadline := time.Now().Add(10 * time.Second)
+	for {
+		if latest, ok := rec.latest(); ok && len(latest.Ideas) == 2 {
+			if got := quickNames(latest.Ideas); !reflect.DeepEqual(got, []string{"Shrimp Scampi", "Garlic Shrimp Pasta"}) {
+				t.Fatalf("while the first idea grounds, ideas = %q, want the two grounded", got)
+			}
+			if latest.Stage != StageGrounding {
+				t.Fatalf("stage = %s, want grounding", latest.Stage)
+			}
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatal("the ideas that grounded were not shown while the first idea was still grounding")
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	close(gate)
+	out := <-done
+	if out.err != nil {
+		t.Fatal(out.err)
+	}
+	want := []string{"Chicken Fried Rice", "Shrimp Scampi", "Garlic Shrimp Pasta"}
+	if got := quickNames(out.res.Ideas); !reflect.DeepEqual(got, want) || out.res.Stage != StageDone {
+		t.Fatalf("result = %s %q, want done with %q in the model's order", out.res.Stage, got, want)
+	}
+
+	var stages []string
+	var counts []int
+	for _, p := range rec.published {
+		stages = append(stages, p.Stage)
+		counts = append(counts, len(p.Ideas))
+	}
+	if !reflect.DeepEqual(stages, []string{StageSuggesting, StageGrounding, StageGrounding, StageGrounding, StageGrounding}) || !reflect.DeepEqual(counts, []int{0, 0, 1, 2, 3}) {
+		t.Fatalf("published stages %q with %v ideas, want suggesting, then grounding with 0, 1, 2, 3", stages, counts)
+	}
+}
+
+func TestQuickFailures(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		setup func(t *testing.T, e *env)
+		code  string
+	}{
+		{"ai fails", func(t *testing.T, e *env) { e.fail = errors.New("provider down") }, ReasonAIFailed},
+		{"no idea is of the kind", func(t *testing.T, e *env) {
+			e.recipe(t, "Beef Stew", "Beef Stew", 150)
+			e.reply(quickIdea("Beef Stew", "crockpot", 360))
+		}, ReasonNoIdeasFound},
+		{"every idea already shown", func(t *testing.T, e *env) {
+			e.reply(quickIdea("Pulled Pork", "crockpot", 480))
+		}, ReasonNoIdeasFound},
+		{"a later round fails after ideas were shown", func(t *testing.T, e *env) {
+			e.recipe(t, "Chicken Chili", "Slow Cooker Chicken Chili", 240)
+			e.recipe(t, "Beef Stew", "Beef Stew", 150)
+			e.search.Fail = map[string]error{"Lentil Soup": errors.New("boom")}
+			reply := []string{quickIdea("Chicken Chili", "crockpot", 240)}
+			for i := range 5 {
+				name := fmt.Sprintf("Mystery Stew %d", i+1)
+				reply = append(reply, quickIdea(name, "crockpot", 300))
+			}
+			e.reply(append(reply, quickIdea("Lentil Soup", "crockpot", 300))...)
+		}, ReasonSearchFailed},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			e := newEnv(t)
+			tc.setup(t, e)
+			_, published, err := e.runQuick(t, skills.QuickCrockpot, "Pulled Pork")
+			var failure *jobs.Failure
+			if !errors.As(err, &failure) || failure.Code != tc.code {
+				t.Fatalf("err = %v, want failure %s", err, tc.code)
+			}
+			if last := published[len(published)-1]; len(last.Ideas) != 0 || last.Stage == StageDone {
+				t.Fatalf("last publish of a failed job = %+v, want no ideas", last)
+			}
+		})
+	}
+}
+
+func TestStartQuickRunsTheJob(t *testing.T) {
+	e := newEnv(t)
+	e.recipe(t, "Pulled Pork", "Slow Cooker Pulled Pork", 480)
+	e.reply(quickIdea("Pulled Pork", "crockpot", 480))
+	ctx, cancel := context.WithCancel(context.Background())
+	if err := e.runner.Start(ctx); err != nil {
+		cancel()
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		cancel()
+		e.runner.Wait()
+	})
+
+	for _, tc := range []struct {
+		kind    string
+		exclude []string
+		want    string
+	}{
+		{"", nil, `kind: kind "" is not one of crockpot, under30`},
+		{"quick", nil, `kind: kind "quick" is not one of crockpot, under30`},
+		{skills.QuickCrockpot, []string{"Beef Stew", "beef stew"}, `exclude: excluded name 2, "beef stew", repeats "Beef Stew"`},
+	} {
+		_, err := e.svc.StartQuick(t.Context(), tc.kind, tc.exclude)
+		var invalid *InvalidError
+		if !errors.As(err, &invalid) || invalid.Message != tc.want {
+			t.Errorf("StartQuick(%q, %q) = %v, want %q", tc.kind, tc.exclude, err, tc.want)
+		}
+	}
+
+	started, err := e.svc.StartQuick(t.Context(), skills.QuickCrockpot, []string{" Beef  Stew "})
+	if err != nil {
+		t.Fatal(err)
+	}
+	deadline := time.Now().Add(10 * time.Second)
+	var job jobs.Job
+	for {
+		job, err = e.runner.Get(t.Context(), started.JobID)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if job.Status == jobs.StatusSucceeded || job.Status == jobs.StatusFailed {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("job still %s", job.Status)
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	if job.Status != jobs.StatusSucceeded || job.Kind != KindQuick {
+		t.Fatalf("job = %+v", job)
+	}
+	var res QuickResult
+	if err := json.Unmarshal(job.Result, &res); err != nil {
+		t.Fatal(err)
+	}
+	if res.Stage != StageDone || res.Kind != skills.QuickCrockpot || !reflect.DeepEqual(res.Exclude, []string{"Beef Stew"}) || len(res.Ideas) != 1 {
+		t.Fatalf("result = %+v", res)
+	}
+	if got := res.Ideas[0]; got.Name != "Pulled Pork" || got.Method != "crockpot" || got.SiteName != "R Kitchen" {
+		t.Errorf("idea = %+v", got)
+	}
+}
+
+func TestOfQuickKind(t *testing.T) {
+	m := func(n int) *int { return &n }
+	for _, tc := range []struct {
+		kind, method string
+		minutes      *int
+		want         bool
+	}{
+		{skills.QuickCrockpot, "crockpot", m(480), true},
+		{skills.QuickCrockpot, "crockpot", nil, true},
+		{skills.QuickCrockpot, "stovetop", m(20), false},
+		{skills.QuickUnder30, "stovetop", m(30), true},
+		{skills.QuickUnder30, "oven", m(31), false},
+		{skills.QuickUnder30, "stovetop", nil, false},
+		{skills.QuickUnder30, "crockpot", m(240), false},
+		{"quick", "crockpot", m(20), false},
+	} {
+		if got := OfQuickKind(tc.kind, tc.method, tc.minutes); got != tc.want {
+			t.Errorf("OfQuickKind(%s, %s, %v) = %v, want %v", tc.kind, tc.method, tc.minutes, got, tc.want)
+		}
+	}
+	if !slices.Equal(skills.QuickKinds, []string{skills.QuickCrockpot, skills.QuickUnder30}) {
+		t.Errorf("kinds = %q", skills.QuickKinds)
+	}
+}