Add the day plan she can recite when asked (#128)
The plan answers "какие планы на сегодня?" by putting one day in order: calendar events (with #126's ambient provenance carried through and hedged), pending reminders, and one line per morning routine that still has items outstanding. "что дальше?" trims what has already passed. It lives in internal/morning, not in a parallel system, because it is the same question the checklist asks at a different scale — the routine knows what is missing from a window, the plan knows what the whole day holds, and both read the same facts and the same idea of "today". BuildPlan is pure; tickLoop.dayPlan is the impure half that reads the store. It is not a nag. Nothing here fires, schedules or announces: the plan is built only when asked, over IPC (day_plan) or on the existing /morning page. Unprompted delivery stays with the morning nudge and the dispatcher's policy. The query source sits before "calendar" in querySources because both match "…на сегодня" and the plan's matcher is the more specific one; IsDayPlanQuery matches whole words so "планёрка" (a meeting) is not read as a request for the plan, and refuses any utterance naming another day, since the plan is built for the clock's own day only. Verified: make build and make test both exit 0; new tests cover plan ordering, the checklist-only-what-is-left rule, other-day rejection, the RU rendering against the persona checks, rest-of-day trimming, the source ordering, and the matcher's refusals.
This commit is contained in:
kami
@@ -0,0 +1,165 @@
|
||||
package morning
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/kami/maven/internal/store"
|
||||
)
|
||||
|
||||
// The day plan (Vikunja #128).
|
||||
//
|
||||
// It lives here, with the morning routine engine, because it is the same
|
||||
// question asked at a different scale: the routine knows what is still missing
|
||||
// from a window, the plan knows what the whole day holds. A parallel system
|
||||
// would have to re-read the same facts and re-decide what "today" means.
|
||||
//
|
||||
// It is pure, like the rest of this package: the daemon reads the calendar,
|
||||
// the reminders and the checklist facts, and BuildPlan puts them in order.
|
||||
//
|
||||
// It is also NOT a nag. A plan she can recite when asked is the whole feature;
|
||||
// nothing here fires, schedules or announces. Unprompted delivery stays with
|
||||
// the existing morning nudge and the dispatcher's policy.
|
||||
|
||||
// PlanKind — where a plan line came from. It survives into the reply and the
|
||||
// web view because the three read differently: an event is something happening
|
||||
// to the owner, a reminder is something he asked for, a checklist item is
|
||||
// something he has not done yet.
|
||||
type PlanKind string
|
||||
|
||||
const (
|
||||
PlanEvent PlanKind = "event"
|
||||
PlanReminder PlanKind = "reminder"
|
||||
PlanChecklist PlanKind = "checklist"
|
||||
)
|
||||
|
||||
// PlanEntry — one timed thing on the day, as the daemon read it out of the
|
||||
// store. Text is rendered verbatim; the plan does not rephrase.
|
||||
//
|
||||
// Uncertain marks provenance below a full-confidence read — a work meeting
|
||||
// relayed off a phone notification (#126). It travels through to the reply so
|
||||
// she hedges instead of reciting a guess as fact.
|
||||
type PlanEntry struct {
|
||||
At time.Time
|
||||
Text string
|
||||
Kind PlanKind
|
||||
Uncertain bool
|
||||
}
|
||||
|
||||
// Plan — the ordered day. Date is the calendar day it describes.
|
||||
type Plan struct {
|
||||
Date time.Time
|
||||
Items []PlanEntry
|
||||
}
|
||||
|
||||
// BuildPlan orders everything known about the day Now falls on: calendar
|
||||
// events, pending reminders, and one line per morning routine that still has
|
||||
// unfinished items.
|
||||
//
|
||||
// Entries outside that calendar day are dropped — a plan for today that
|
||||
// includes tomorrow's meeting is wrong in a way that is worse than terse.
|
||||
// Ordering is by time, then by kind, then by text, so the same day always reads
|
||||
// the same way.
|
||||
func BuildPlan(routines []Routine, facts map[string]store.Fact, events, reminders []PlanEntry, now time.Time) Plan {
|
||||
y, m, d := now.Date()
|
||||
dayStart := time.Date(y, m, d, 0, 0, 0, 0, now.Location())
|
||||
dayEnd := dayStart.AddDate(0, 0, 1)
|
||||
|
||||
p := Plan{Date: dayStart}
|
||||
for _, group := range [][]PlanEntry{events, reminders} {
|
||||
for _, e := range group {
|
||||
at := e.At.In(now.Location())
|
||||
if at.Before(dayStart) || !at.Before(dayEnd) {
|
||||
continue
|
||||
}
|
||||
if strings.TrimSpace(e.Text) == "" {
|
||||
continue
|
||||
}
|
||||
e.At = at
|
||||
p.Items = append(p.Items, e)
|
||||
}
|
||||
}
|
||||
p.Items = append(p.Items, checklistEntries(routines, facts, now)...)
|
||||
|
||||
sort.SliceStable(p.Items, func(i, j int) bool {
|
||||
a, b := p.Items[i], p.Items[j]
|
||||
if !a.At.Equal(b.At) {
|
||||
return a.At.Before(b.At)
|
||||
}
|
||||
if a.Kind != b.Kind {
|
||||
return a.Kind < b.Kind
|
||||
}
|
||||
return a.Text < b.Text
|
||||
})
|
||||
return p
|
||||
}
|
||||
|
||||
// checklistEntries renders one line per routine with work left in it, placed at
|
||||
// the routine's nudge time — where the checklist actually matters in the day.
|
||||
// A routine that does not apply today, is not in its window, or is already
|
||||
// complete contributes nothing: the plan says what is left, not what was done.
|
||||
func checklistEntries(routines []Routine, facts map[string]store.Fact, now time.Time) []PlanEntry {
|
||||
var out []PlanEntry
|
||||
for _, r := range routines {
|
||||
st := Evaluate(r, facts, now)
|
||||
if !st.Active || len(st.Missing) == 0 {
|
||||
continue
|
||||
}
|
||||
labels := make([]string, 0, len(st.Missing))
|
||||
for _, it := range st.Missing {
|
||||
label := it.Label
|
||||
if label == "" {
|
||||
label = it.Key
|
||||
}
|
||||
labels = append(labels, label)
|
||||
}
|
||||
at := r.NudgeAt
|
||||
if at == "" {
|
||||
at = r.WindowEnd
|
||||
}
|
||||
when, ok := todayAt(at, now)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
out = append(out, PlanEntry{
|
||||
At: when,
|
||||
Text: fmt.Sprintf("%s — осталось: %s", r.Name, strings.Join(labels, ", ")),
|
||||
Kind: PlanChecklist,
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// After returns the part of the plan that has not happened yet — the answer to
|
||||
// "что дальше?" as opposed to "какие планы на сегодня?". The Date is kept, so an
|
||||
// empty result still knows which day it is empty for.
|
||||
func (p Plan) After(now time.Time) Plan {
|
||||
out := Plan{Date: p.Date}
|
||||
for _, it := range p.Items {
|
||||
if it.At.Before(now) {
|
||||
continue
|
||||
}
|
||||
out.Items = append(out.Items, it)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// FormatRU renders the plan as maven says it. Feminine self-reference,
|
||||
// informal address, no pet names — and no exhortation: she reads the day back,
|
||||
// she does not tell him to get on with it.
|
||||
func (p Plan) FormatRU() string {
|
||||
if len(p.Items) == 0 {
|
||||
return fmt.Sprintf("на %s ничего не запланировано.", p.Date.Format("02.01.2006"))
|
||||
}
|
||||
parts := make([]string, len(p.Items))
|
||||
for i, it := range p.Items {
|
||||
line := fmt.Sprintf("%s — %s", it.At.Format("15:04"), it.Text)
|
||||
if it.Uncertain {
|
||||
line = "похоже, " + line
|
||||
}
|
||||
parts[i] = line
|
||||
}
|
||||
return fmt.Sprintf("план на %s: %s.", p.Date.Format("02.01.2006"), strings.Join(parts, "; "))
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
package morning
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/kami/maven/internal/store"
|
||||
)
|
||||
|
||||
// planAt is at() for the plan tests' day (2026-08-03, a Monday); the existing
|
||||
// at() in morning_test.go is pinned to a different date.
|
||||
func planAt(now time.Time, hh, mm int) time.Time {
|
||||
y, m, d := now.Date()
|
||||
return time.Date(y, m, d, hh, mm, 0, 0, now.Location())
|
||||
}
|
||||
|
||||
func planFixture(t *testing.T) (Plan, time.Time) {
|
||||
t.Helper()
|
||||
now := time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC)
|
||||
routines := []Routine{{
|
||||
Name: "утро",
|
||||
WindowStart: "07:00",
|
||||
WindowEnd: "11:00",
|
||||
NudgeAt: "10:30",
|
||||
Items: []Item{
|
||||
{Key: "water", FactKey: "drank_water", Label: "выпить воды"},
|
||||
{Key: "pills", FactKey: "took_pills", Label: "витамины"},
|
||||
},
|
||||
}}
|
||||
facts := map[string]store.Fact{
|
||||
"drank_water": {Ts: planAt(now, 8, 0)},
|
||||
}
|
||||
events := []PlanEntry{
|
||||
{At: planAt(now, 14, 0), Text: "Планёрка @ 14:00-14:30", Kind: PlanEvent, Uncertain: true},
|
||||
{At: planAt(now, 10, 0), Text: "Standup @ 10:00-10:30", Kind: PlanEvent},
|
||||
}
|
||||
reminders := []PlanEntry{
|
||||
{At: planAt(now, 18, 30), Text: "позвонить маме", Kind: PlanReminder},
|
||||
}
|
||||
return BuildPlan(routines, facts, events, reminders, now), now
|
||||
}
|
||||
|
||||
func TestBuildPlanOrdersTheDay(t *testing.T) {
|
||||
p, now := planFixture(t)
|
||||
|
||||
if !p.Date.Equal(planAt(now, 0, 0)) {
|
||||
t.Errorf("Date = %v, want midnight of now's day", p.Date)
|
||||
}
|
||||
want := []struct {
|
||||
hhmm string
|
||||
kind PlanKind
|
||||
}{
|
||||
{"10:00", PlanEvent},
|
||||
{"10:30", PlanChecklist},
|
||||
{"14:00", PlanEvent},
|
||||
{"18:30", PlanReminder},
|
||||
}
|
||||
if len(p.Items) != len(want) {
|
||||
t.Fatalf("got %d items, want %d: %+v", len(p.Items), len(want), p.Items)
|
||||
}
|
||||
for i, w := range want {
|
||||
if got := p.Items[i].At.Format("15:04"); got != w.hhmm {
|
||||
t.Errorf("item %d at %s, want %s", i, got, w.hhmm)
|
||||
}
|
||||
if p.Items[i].Kind != w.kind {
|
||||
t.Errorf("item %d kind %q, want %q", i, p.Items[i].Kind, w.kind)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The checklist line says what is LEFT. An item already evidenced today must
|
||||
// not be read back as outstanding.
|
||||
func TestBuildPlanChecklistListsOnlyMissing(t *testing.T) {
|
||||
p, _ := planFixture(t)
|
||||
var line string
|
||||
for _, it := range p.Items {
|
||||
if it.Kind == PlanChecklist {
|
||||
line = it.Text
|
||||
}
|
||||
}
|
||||
if line == "" {
|
||||
t.Fatal("no checklist line in the plan")
|
||||
}
|
||||
if !strings.Contains(line, "витамины") {
|
||||
t.Errorf("missing item not listed: %q", line)
|
||||
}
|
||||
if strings.Contains(line, "выпить воды") {
|
||||
t.Errorf("a completed item must not be read back as outstanding: %q", line)
|
||||
}
|
||||
if !strings.HasPrefix(line, "утро — осталось:") {
|
||||
t.Errorf("line = %q", line)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildPlanSkipsCompleteAndInactiveRoutines(t *testing.T) {
|
||||
now := time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC)
|
||||
routines := []Routine{
|
||||
{
|
||||
Name: "утро", WindowStart: "07:00", WindowEnd: "11:00",
|
||||
Items: []Item{{Key: "water", FactKey: "drank_water", Label: "выпить воды"}},
|
||||
},
|
||||
{
|
||||
// Not in its window at 09:00.
|
||||
Name: "вечер", WindowStart: "20:00", WindowEnd: "23:00",
|
||||
Items: []Item{{Key: "walk", FactKey: "walked", Label: "прогулка"}},
|
||||
},
|
||||
}
|
||||
facts := map[string]store.Fact{"drank_water": {Ts: planAt(now, 8, 0)}}
|
||||
p := BuildPlan(routines, facts, nil, nil, now)
|
||||
if len(p.Items) != 0 {
|
||||
t.Fatalf("a complete routine and an out-of-window one must contribute nothing: %+v", p.Items)
|
||||
}
|
||||
if got, want := p.FormatRU(), "на 03.08.2026 ничего не запланировано."; got != want {
|
||||
t.Errorf("got %q\nwant %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// A plan for today that includes tomorrow's meeting is worse than terse.
|
||||
func TestBuildPlanDropsOtherDays(t *testing.T) {
|
||||
now := time.Date(2026, 8, 3, 9, 0, 0, 0, time.UTC)
|
||||
events := []PlanEntry{
|
||||
{At: planAt(now, 10, 0), Text: "today", Kind: PlanEvent},
|
||||
{At: planAt(now, 10, 0).AddDate(0, 0, 1), Text: "tomorrow", Kind: PlanEvent},
|
||||
{At: planAt(now, 10, 0).AddDate(0, 0, -1), Text: "yesterday", Kind: PlanEvent},
|
||||
{At: planAt(now, 12, 0), Text: " ", Kind: PlanEvent},
|
||||
}
|
||||
p := BuildPlan(nil, nil, events, nil, now)
|
||||
if len(p.Items) != 1 || p.Items[0].Text != "today" {
|
||||
t.Fatalf("got %+v", p.Items)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPlanFormatRU(t *testing.T) {
|
||||
p, _ := planFixture(t)
|
||||
got := p.FormatRU()
|
||||
want := "план на 03.08.2026: 10:00 — Standup @ 10:00-10:30; " +
|
||||
"10:30 — утро — осталось: витамины; " +
|
||||
"похоже, 14:00 — Планёрка @ 14:00-14:30; " +
|
||||
"18:30 — позвонить маме."
|
||||
if got != want {
|
||||
t.Errorf("got %q\nwant %q", got, want)
|
||||
}
|
||||
// Persona: she recites, she does not exhort, and she never speaks of
|
||||
// herself in the masculine or addresses him formally.
|
||||
for _, bad := range []string{"рад ", "понял", "вы ", "ваш", "милый", "дорогой", "давай же", "не забудь"} {
|
||||
if strings.Contains(strings.ToLower(got), bad) {
|
||||
t.Errorf("plan text contains %q: %q", bad, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPlanAfter(t *testing.T) {
|
||||
p, now := planFixture(t)
|
||||
rest := p.After(planAt(now, 11, 0))
|
||||
if len(rest.Items) != 2 {
|
||||
t.Fatalf("got %d items, want the 14:00 and 18:30 ones: %+v", len(rest.Items), rest.Items)
|
||||
}
|
||||
if !rest.Date.Equal(p.Date) {
|
||||
t.Error("After must keep the date, so an empty rest-of-day still knows which day")
|
||||
}
|
||||
empty := p.After(planAt(now, 23, 0))
|
||||
if len(empty.Items) != 0 {
|
||||
t.Errorf("got %+v", empty.Items)
|
||||
}
|
||||
if !strings.Contains(empty.FormatRU(), "ничего не запланировано") {
|
||||
t.Errorf("empty plan reads %q", empty.FormatRU())
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user