composer

type CheckProgress struct {
	Done  int
	Total int // emails this check goes through: at most the newest limit of the range
	// Matched is how many emails the folder holds in the chosen range before the limit,
	// known once the mail is listed. It is more than Total when the limit cut the range.
	Matched    int
	ModelCalls int
	Tokens     int
	CostUSD    float64
}

type CheckRow struct {
	Ref        mail.MsgRef
	From       string
	Subject    string
	ReceivedAt int64 // 0 = unknown
	Outcome    pipeline.Outcome
}

type Composer struct {
	Store     *store.Store
	Gen       models.Generator
	Now       func() time.Time // nil = time.Now
	BodyChars int
}

type Conflict struct {
	RuleID int64  `json:"rule_id"`
	Kind   string `json:"kind"` // overlap | duplicate | shadowed
	Note   string `json:"note"`
}

type Draft struct {
	Name       string         `json:"name"`
	Said       string         `json:"said"`
	Intent     *string        `json:"intent"`
	Conditions rules.Cond     `json:"conditions"`
	Exceptions rules.Cond     `json:"exceptions"`
	Actions    []rules.Action `json:"actions"`
	// AccountID, Stack and Model are the rest of a rule, so a draft can be saved as it is.
	// The composer does not write them: a new draft is for every account, does not stack
	// and has no model of its own; a re-optimized rule keeps what it had.
	AccountID     *int64     `json:"account_id"`
	Stack         bool       `json:"stack"`
	Model         string     `json:"model"`
	MinConfidence *float64   `json:"min_confidence"`
	NewFolders    []string   `json:"new_folders"`
	Question      *string    `json:"question"`
	Conflicts     []Conflict `json:"conflicts"`
	Errors        []Problem  `json:"errors"`
	MatchCount    int        `json:"match_count"`
	// Tested is how many emails MatchCount is out of: the newest ones the draft was tested
	// on, or, for a suggestion, the emails scanned. 0 when it was not tested.
	Tested  int   `json:"tested"`
	Samples []Row `json:"samples"`
}

type FetchOptions struct {
	// NoBody reads the headers only: no text is fetched, and Summary.Body is empty.
	NoBody bool
	// BodyChars cuts the parsed text to this many characters; 0 keeps all the connector
	// read.
	BodyChars int
}

type Output struct {
	Drafts   []Draft
	Unparsed []string // parts of the text that could not be turned into a rule
}

type Problem struct {
	Path    string `json:"path"`
	Message string `json:"message"`
}

type Progress struct {
	Done       int // messages tested or passed over
	Total      int // messages the run will go through, known once the mail is listed
	ModelCalls int // model calls made so far
}

type Reader interface {
	FetchMany(ctx context.Context, refs []mail.MsgRef, maxBody int) ([]*message.Raw, error)
	FetchSince(ctx context.Context, folder string, since time.Time, limit int) ([]mail.MsgRef, int, error)
}

type Request struct {
	UserID int64
	Text   string
	// Rule, when set, is re-optimized: the model is given its original wording with Text
	// and answers with a single draft to replace it.
	Rule *rules.Rule
	// Account is the mailbox the drafts are checked against: its folders are the ones that
	// exist, and its newest mail is what the drafts are tested on. nil = no mailbox is
	// connected: the folders of every account count, and nothing is tested.
	Account *store.Account
	Mailbox Reader           // nil = the account is offline: the drafts are not tested
	Decider pipeline.Decider // decides the test run; a nil Router leaves intent drafts untested
}

type Result struct {
	Rows       []Row   `json:"results"` // newest first
	Tested     int     `json:"tested"`
	Matched    int     `json:"matched"` // a rule or sender rule would have applied
	ModelCalls int     `json:"model_calls"`
	CostUSD    float64 `json:"cost_usd"`
}

type Row struct {
	From       string         `json:"from"`
	Subject    string         `json:"subject"`
	ReceivedAt *int64         `json:"received_at"`
	Stage      string         `json:"stage"`
	RuleID     *int64         `json:"rule_id"` // null = no rule, or a draft (see rule_name)
	RuleName   string         `json:"rule_name"`
	Confidence float64        `json:"confidence"`
	Reason     string         `json:"reason"`
	Review     bool           `json:"review"` // below the threshold: it would go to Needs review
	Actions    []rules.Action `json:"actions"`
	// contains filtered or unexported fields
}

type Scanner struct {
	Store     *store.Store // the contacts index, for the is_contact and replied_before signals
	Mailbox   Reader
	AccountID int64
}

type Tester struct {
	Store     *store.Store // the contacts index, for the is_contact and replied_before signals
	Mailbox   Reader
	AccountID int64
	// Decider is the same step the live pipeline decides with. Give it routers made with
	// models.Router.For("test"), so the calls are booked as tests.
	Decider   pipeline.Decider
	BodyChars int
}