dreamer

type Added struct {
	SliceID   string     `json:"slice_id"`
	Source    SourceName `json:"source"`
	Key       string     `json:"key"`
	Rank      int        `json:"rank"`
	Score     float64    `json:"score"`
	TicketURL string     `json:"ticket_url"`
	Title     string     `json:"title"`
}

type Candidate struct {
	Source SourceName `json:"source"`
	// Key is the work's stable identity; the slice identifier derives from
	// it, so the same work is never added twice.
	Key   string `json:"key"`
	Title string `json:"title"`
	// TicketURL is the existing ticket the work delivers; empty when the
	// dreamer opens one.
	TicketURL string `json:"ticket_url,omitempty"`
	// Frequency is how many times a week the problem occurs, with how that
	// was measured.
	Frequency           float64 `json:"frequency"`
	FrequencyDerivation string  `json:"frequency_derivation"`
	// Fixed and Attempted are the measured outcomes of earlier work on the
	// same class: finished attempts and those that delivered.
	Fixed     int `json:"fixed"`
	Attempted int `json:"attempted"`
	// Known is true when earlier work on the class exists: exploration does
	// not weigh it.
	Known      bool     `json:"known"`
	Evidence   []string `json:"evidence"`
	Acceptance []string `json:"acceptance"`
}

type Collector struct {
	// contains filtered or unexported fields
}

type Comparison struct {
	ComputedAt time.Time `json:"computed_at"`
	Week       string    `json:"week"`
	All        Partition `json:"all"`
	InSample   Partition `json:"in_sample"`
	HeldOut    Partition `json:"held_out"`
	// Explore is one plus the trailing complete weeks whose held-out rate
	// did not fall below the week before.
	Explore           float64 `json:"explore"`
	ExploreDerivation string  `json:"explore_derivation"`
}

type Control struct {
	Action ControlAction `json:"action"`
	Reason string        `json:"reason"`
}

type ControlAction string

type ControlInput struct {
	Reason string `json:"reason" jsonschema:"why, recorded with the control"`
}

type Decision struct {
	Outcome  Outcome          `json:"outcome"`
	Reason   string           `json:"reason"`
	Target   Target           `json:"target"`
	Limits   []dispatch.Limit `json:"limits,omitempty"`
	Explore  float64          `json:"explore"`
	Ranked   []Ranked         `json:"ranked,omitempty"`
	Total    int              `json:"candidates"`
	Added    []Added          `json:"added,omitempty"`
	Released []string         `json:"released,omitempty"`
	// Findings are the sources that failed and anything skipped, each with
	// why.
	Findings []string `json:"findings,omitempty"`
}

type DreamInput struct{}

type Dreamer struct {
	// contains filtered or unexported fields
}

type GitHubBacklog struct {
	// contains filtered or unexported fields
}

type IBacklog interface {
	OpenIssue(ctx context.Context, title string, body string) (string, error)
}

type IDispatcher interface {
	CurrentSnapshot(ctx context.Context, input dispatch.SnapshotInput) (dispatch.Snapshot, error)
	List(ctx context.Context, request *dispatchv1.ListSlicesRequest) (*dispatchv1.ListSlicesResponse, error)
	AddSlice(ctx context.Context, input dispatch.AddSliceInput) (dispatch.SliceView, error)
	Release(ctx context.Context, input dispatch.SliceControlInput) (dispatch.Snapshot, error)
}

type Issue struct {
	Number int64
	Title  string
	URL    string
	Body   string
	Labels []string
}

type Option func(dreamer *Dreamer) error

type Outcome string

type Outcomes struct {
	Fixed     int `json:"fixed"`
	Attempted int `json:"attempted"`
}

type Partition struct {
	Name   string           `json:"name"`
	Runs   int              `json:"runs"`
	Weeks  []ouroboros.Rate `json:"weeks"`
	Factor ouroboros.Trend  `json:"factor"`
}

type Ranked struct {
	Candidate
	Fixability           float64 `json:"fixability"`
	FixabilityDerivation string  `json:"fixability_derivation"`
	Explore              float64 `json:"explore"`
	Score                float64 `json:"score"`
	Rank                 int     `json:"rank"`
}

type Record struct {
	At       time.Time   `json:"at"`
	Kind     RecordKind  `json:"kind"`
	Decision *Decision   `json:"decision,omitempty"`
	Control  *Control    `json:"control,omitempty"`
	Strategy *Comparison `json:"strategy,omitempty"`
}

type RecordKind string

type RecordSink func(record Record) error

type Snapshot struct {
	At          time.Time          `json:"at"`
	Paused      bool               `json:"paused"`
	PauseReason string             `json:"pause_reason,omitempty"`
	Explore     float64            `json:"explore"`
	Strategy    *Comparison        `json:"strategy,omitempty"`
	Generated   map[SourceName]int `json:"generated"`
	Decisions   []Record           `json:"decisions"`
}

type SnapshotInput struct{}

type SnapshotSink func(snapshot Snapshot) error

type Source struct {
	Name     string
	Fallback bool
	Find     func(ctx context.Context, world World) ([]Candidate, error)
}

type SourceName string

type StrategizeInput struct{}

type Target struct {
	Ready    int `json:"ready"`
	Target   int `json:"target"`
	Capacity int `json:"capacity"`
	Running  int `json:"running"`
	// Completions is how many running sessions are expected to finish before
	// the next pass.
	Completions int `json:"completions"`
	// Measured is how many merged slices the median duration is over.
	Measured      int     `json:"measured"`
	MedianSeconds float64 `json:"median_seconds"`
	Derivation    string  `json:"derivation"`
}

type World struct {
	Now    time.Time
	Slices []*dispatchv1.SliceNode
}