diff --git a/cmd/codeaf/chatv3.go b/cmd/codeaf/chatv3.go index ea05abd537..471ccd1e65 100644 --- a/cmd/codeaf/chatv3.go +++ b/cmd/codeaf/chatv3.go @@ -1979,18 +1979,22 @@ func v3PolicyMode(workspace, profileDir, mode string) (*approval.Policy, error) // - Pure reads of this machine — read, grep, find, ls. Nothing here changes a // file, so the blanket mode's prompt is free to land where it matters, on // bash, edit and write. +// // - jobs, whose list and output are reads of processes the person already // started. Its kill is not on the floor: it inherits the blanket mode, // which asks. +// // - The agent's own bookkeeping — remember, track and recall. These write to // and read from the memories and working state it keeps for itself // (internal/session's memory.go and state.go); no hand outside this process // reads them, and asking somebody to approve the agent writing itself a // reminder is asking about the wrong thing. +// // - manual, which reads pages compiled into this binary and touches no disk // at all (internal/session's tools_manual.go). A person who asks "what can // you do" and is answered with a permission prompt has been asked to // approve the program looking up its own documentation. +// // - settings, which reads the person's own settings rows back through the // registry (internal/session's tools_settings.go). It is manual's shape one // file over — the answer to "what is my daily budget" is a lookup, and the @@ -1998,6 +2002,17 @@ func v3PolicyMode(workspace, profileDir, mode string) (*approval.Policy, error) // ([config.Setting.Secret]), so there is nothing here a prompt would be // protecting. // +// - The team verbs that stay inside a team the person made +// (internal/session's tools_team.go): a manager reading its members' +// states and pages, sending them a line, ending a member's turn the way +// the person's own Stop does, and a member posting to its room. Every one +// of them is a line in the team's own traffic log, which the person watches +// on the manager's rail, and none of them reaches a permission prompt. +// +// team_start is DELIBERATELY NOT HERE. It opens a new conversation that spends +// money for as long as it runs, so the blanket mode asks, the way it asks about +// propose_task. +// // commit is DELIBERATELY NOT HERE, and it is the interesting half of the split. // It is the fifth hand on the same working state, but it is the only one that // declares a tracked subgoal FINISHED, and a session that can mark its own work @@ -2020,6 +2035,15 @@ func v3BuiltinApprovals() map[string]any { "jobs": "allow", "remember": "allow", "track": "allow", "recall": "allow", "manual": "allow", "settings": "allow", + "team_status": "allow", "team_read": "allow", "team_send": "allow", + "team_stop": "allow", "team_post": "allow", + // A manager deciding or sending up a packet waiting on it, and bringing + // the person its closing report: each is a line in the team's own + // record, and none spends or starts anything. + "team_decide": "allow", "team_escalate": "allow", "team_close_report": "allow", + // A conflict raised to the manager above the parties: a packet and a + // line of Traffic, and nothing spent or started. + "team_raise": "allow", } } diff --git a/cmd/codeaf/chatv3_approvalfloor_test.go b/cmd/codeaf/chatv3_approvalfloor_test.go index 9ea760882d..abcfc4dced 100644 --- a/cmd/codeaf/chatv3_approvalfloor_test.go +++ b/cmd/codeaf/chatv3_approvalfloor_test.go @@ -205,3 +205,18 @@ func TestTheFloorDoesNotWidenAnySafetyFloor(t *testing.T) { // And a bash call whose command cannot be read degrades rather than runs. wantAction(t, policy, "bash", `{}`, approval.ActionPrompt) } + +// THE TEAM VERBS SPLIT READ AND MESSAGE FROM START (internal/session's +// tools_team.go). A manager looking at its team, sending it a line, ending a +// member's turn and a member posting to its room stay inside the team the person +// made and are logged in its traffic, so they sit on the floor; a new member is a +// new conversation that spends money, so team_start is the blanket mode's and +// asks under the shipped default. +func TestTheTeamVerbsAreAllowedAndTeamStartAsks(t *testing.T) { + dir := v3Profile(t, map[string]any{"tools.approvalMode": "prompt"}) + policy := gateOf(t, dir) + for _, tool := range []string{"team_status", "team_read", "team_send", "team_stop", "team_post", "team_decide", "team_escalate", "team_close_report", "team_raise"} { + wantAction(t, policy, tool, `{"to":"web","text":"x","handle":"web"}`, approval.ActionAllow) + } + wantAction(t, policy, "team_start", `{"handle":"docs","brief":"write the README"}`, approval.ActionPrompt) +} diff --git a/cmd/codeaf/chatv3_host.go b/cmd/codeaf/chatv3_host.go index 7e9b8c6257..f991ce2246 100644 --- a/cmd/codeaf/chatv3_host.go +++ b/cmd/codeaf/chatv3_host.go @@ -736,6 +736,12 @@ func hostOptions(fleet *engineFleet, welcome remote.Welcome, pick bool) (tui3.Op // which is not an optimization but the seam's stated law, because that // segment is asked on the frame. Save travels synchronously: it is a // keystroke, it is rare, and somebody is waiting for its answer. + // THE TEAMS, AS THE ENGINE MACHINE KEEPS THEM. The far session's team + // tools write the teams file and each team's Traffic into the engine's + // profile, so the window reads and writes those, over the wire + // ([hostTeams]); an engine without the doors hands no seam and the + // surface turns teams off rather than keeping them on this laptop. + Teams: hostTeamsSeam(far, welcome), Standing: tui3.StandingSeam{ Items: stands.list, Save: stands.save, diff --git a/cmd/codeaf/chatv3_host_teams.go b/cmd/codeaf/chatv3_host_teams.go new file mode 100644 index 0000000000..2905e76b41 --- /dev/null +++ b/cmd/codeaf/chatv3_host_teams.go @@ -0,0 +1,277 @@ +package main + +import ( + "errors" + "sync" + + "github.com/Agent-Field/codeaf/internal/remote" + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui3" +) + +// hostTeams is [tui3.TeamsSeam] over the wire: the ENGINE machine's teams file +// and Traffic logs, which are where the far session's team tools keep them +// (internal/remote's wire_teams.go). +// +// IT IS BUILT LIKE [hostStanding], for the one call the surface makes on its +// loop. [tui3.TeamsSeam.Load] is asked at an opening and must not block, so it +// answers what is held and nothing else; when nothing is held yet it says so, +// and the surface asks [tui3.TeamsSeam.ReadSince] off its loop, once, which +// fills what is held. Every other door here is called from a command and may +// take a round trip: the Traffic clock's turn, and the write an edit queued. +// There is no clock of its own: the surface's Traffic clock is the only thing +// that asks again, and it runs only while a managed team is held. +// +// NOTHING HERE READS THIS LAPTOP'S PROFILE. The teams a window over --host +// draws are the far machine's, or none: an engine without the doors gets no +// seam at all ([hostTeamsSeam]), and the surface turns teams off rather than +// falling back to the file on this disk, which the far session never reads. +type hostTeams struct { + // read, write and traffic are the three wire doors, as closures for + // [hostStanding]'s reason: a test hands them a conflict without a pipe. + read func(stamp string, reserved []float64) (remote.TeamsReading, error) + write func(base string, teams []teamstore.Team) (remote.TeamsReading, error) + traffic func(team, after string, limit int) (remote.TeamsTraffic, error) + + // The delegation doors, nil when the engine does not answer them + // ([remote.Welcome.Delegation]); the seam then hands the surface none. + defaults func() (teamstore.Defaults, error) + // applyDefault writes one `teams.` row ([remote.Welcome.TeamSettings]). + // Nil leaves the settings Teams tab read-only. + applyDefault func(key, raw string) (teamstore.Defaults, error) + packets func(scope, stamp string) (remote.PacketsReading, error) + raise func(p teamstore.Packet) (teamstore.Packet, error) + decide func(id, by, decision, reason string) (teamstore.Packet, error) + escalate func(id, by, to, reason string) (teamstore.Packet, error) + spend func(team, day, stamp string) (remote.SpendReading, error) + deleteOne func(team string) (remote.DeleteTeamReply, error) + // The wrap-up's two doors, nil when the engine does not answer them + // ([remote.Welcome.WrapUp]). + wrapUp func(team, text string) error + acceptClosing func(id string) (remote.AcceptClosingReply, error) + + mu sync.Mutex + // teams and stamp are the last list the engine answered with and the + // file's stamp it was at; known says there has been one. + teams []teamstore.Team + stamp string + known bool + // reserved is the palette's reserved hues as the surface last passed + // them, for a read this seam makes on its own. + reserved []float64 +} + +// hostTeamsTries is how many times a write that met another writer is made +// again from a fresh read before it gives up and says so. +const hostTeamsTries = 3 + +// errHostTeamsBusy is a write that met another writer on every try. +var errHostTeamsBusy = errors.New("the teams on the far machine kept changing while this was written; try again") + +func newHostTeams(far hostFar, delegation, wrapUp, settings bool) *hostTeams { + h := &hostTeams{ + read: far.client.TeamsRead, + write: far.client.TeamsUpdate, + traffic: far.client.TeamsTraffic, + } + if delegation { + c := far.client + h.defaults, h.packets, h.raise = c.TeamsDefaults, c.TeamsPackets, c.TeamsRaise + h.decide, h.escalate, h.spend, h.deleteOne = c.TeamsDecide, c.TeamsEscalate, c.TeamsSpend, c.TeamsDelete + if wrapUp { + h.wrapUp, h.acceptClosing = c.TeamsWrapUp, c.TeamsAcceptClosing + } + } + if settings && far.client != nil { + h.applyDefault = far.client.TeamsApplyDefault + } + return h +} + +// hostTeamsSeam is the seam the --host door hands the surface: the far +// machine's teams when the engine answers the teams doors, and the zero seam +// when it does not or there is no connection. The zero seam over --host is +// teams off (internal/tui3's [app.teamsOff]), never this laptop's file. +func hostTeamsSeam(far hostFar, welcome remote.Welcome) tui3.TeamsSeam { + if far.client == nil || !welcome.Teams { + return tui3.TeamsSeam{} + } + return newHostTeams(far, welcome.Delegation, welcome.WrapUp, welcome.TeamSettings).seam() +} + +// seam is h as the surface's functions. The delegation doors are handed only +// when the engine answers them, so an older engine's window has a seam whose +// delegation doors are nil, which the surface says rather than guesses at. +func (h *hostTeams) seam() tui3.TeamsSeam { + s := tui3.TeamsSeam{Load: h.load, ReadSince: h.readSince, Update: h.update, Traffic: h.readTraffic} + if h.applyDefault != nil { + s.ApplyDefault = h.applyDefault + } + if h.defaults == nil { + return s + } + s.Defaults, s.Raise, s.Decide, s.Escalate = h.defaults, h.raise, h.decide, h.escalate + s.Packets, s.Spend, s.Delete = h.readPackets, h.readSpend, h.forget + if h.wrapUp != nil && h.acceptClosing != nil { + s.WrapUp, s.AcceptClosing = h.wrapUp, h.closeOnReport + } + return s +} + +// closeOnReport is [tui3.TeamsSeam.AcceptClosing]: the engine closes the team +// on its report, and the list held here is read again, because the file moved. +func (h *hostTeams) closeOnReport(id string) (bool, error) { + reply, err := h.acceptClosing(id) + if err != nil { + return false, err + } + if reply.Closed { + if _, _, _, err := h.readSince("", h.reservedHues()); err != nil { + return true, err + } + } + return reply.Closed, nil +} + +// readPackets is [tui3.TeamsSeam.Packets]: one round trip, a few bytes when +// the engine's packet files have not moved. +func (h *hostTeams) readPackets(scope, since string) ([]teamstore.Packet, string, bool, error) { + got, err := h.packets(scope, since) + if err != nil { + return nil, "", false, err + } + return got.Packets, got.Stamp, got.Same, nil +} + +// readSpend is [tui3.TeamsSeam.Spend]: one round trip, a few bytes when +// neither the engine's teams file nor its ledger moved. +func (h *hostTeams) readSpend(team, day, since string) (teamstore.Spend, string, bool, error) { + got, err := h.spend(team, day, since) + if err != nil { + return teamstore.Spend{}, "", false, err + } + if got.Same { + return teamstore.Spend{}, got.Stamp, true, nil + } + if got.Spend == nil { + return teamstore.Spend{Team: team, Day: day}, got.Stamp, false, nil + } + return *got.Spend, got.Stamp, false, nil +} + +// forget is [tui3.TeamsSeam.Delete]: the engine forgets the team and its +// files, and the list held here is read again, because the file moved. +func (h *hostTeams) forget(team string) ([]string, error) { + reply, err := h.deleteOne(team) + if err != nil { + return nil, err + } + if _, _, _, err := h.readSince("", h.reservedHues()); err != nil { + return reply.Gone, err + } + return reply.Gone, nil +} + +// load is [tui3.TeamsSeam.Load]: what is held, now, and never the wire. +func (h *hostTeams) load(reserved []float64) ([]teamstore.Team, string, bool) { + return h.held(reserved) +} + +// held is the list held, a copy, and remembers the reserved hues asked with. +func (h *hostTeams) held(reserved []float64) ([]teamstore.Team, string, bool) { + h.mu.Lock() + defer h.mu.Unlock() + if reserved != nil { + h.reserved = append([]float64(nil), reserved...) + } + return cloneTeams(h.teams), h.stamp, h.known +} + +// keep holds a list the engine answered with. +func (h *hostTeams) keep(teams []teamstore.Team, stamp string) { + h.mu.Lock() + defer h.mu.Unlock() + h.teams, h.stamp, h.known = cloneTeams(teams), stamp, true +} + +// readSince is [tui3.TeamsSeam.ReadSince]: one round trip, whose answer is a +// few bytes when the file is still at since. +func (h *hostTeams) readSince(since string, reserved []float64) ([]teamstore.Team, string, bool, error) { + reading, err := h.read(since, reserved) + if err != nil { + return nil, "", false, err + } + if reading.Same { + return nil, reading.Stamp, true, nil + } + h.keep(reading.Teams, reading.Stamp) + return reading.Teams, reading.Stamp, false, nil +} + +// update is [tui3.TeamsSeam.Update] as a compare-and-swap over the wire. +// +// THE LOCK CANNOT CROSS THE WIRE, SO THE WRITE IS CONDITIONAL. The change is +// made to the list held (or read now, when none is), and the whole list goes +// back with the stamp it was made from; the engine writes it only if its file +// is still at that stamp (internal/teams' ChangeIf). A file that moved in +// between (the far session made a manager, set a handle, started a member) +// answers Stale, and the list is read again and the change made again on top +// of it, up to [hostTeamsTries] times. So what another writer did is kept, as +// the local store's read-modify-write keeps it, and nothing is ever written +// over a list this window did not see. +func (h *hostTeams) update(change func(*teamstore.File) error) ([]teamstore.Team, string, error) { + teams, stamp, known := h.held(nil) + for try := 0; try < hostTeamsTries; try++ { + if !known || try > 0 { + reserved := h.reservedHues() + fresh, at, _, err := h.readSince("", reserved) + if err != nil { + return nil, "", err + } + teams, stamp = fresh, at + } + f := &teamstore.File{Version: teamstore.Version, Teams: cloneTeams(teams)} + if err := change(f); err != nil { + return nil, "", err + } + reply, err := h.write(stamp, f.Teams) + if err != nil { + return nil, "", err + } + if reply.Stale { + continue + } + h.keep(reply.Teams, reply.Stamp) + return reply.Teams, reply.Stamp, nil + } + return nil, "", errHostTeamsBusy +} + +// reservedHues is the palette's reserved hues as last passed. +func (h *hostTeams) reservedHues() []float64 { + h.mu.Lock() + defer h.mu.Unlock() + return append([]float64(nil), h.reserved...) +} + +// readTraffic is [tui3.TeamsSeam.Traffic]: one round trip, answered from a +// stat on the engine when the log has not moved. +func (h *hostTeams) readTraffic(team, after string, limit int) ([]teamstore.Entry, error) { + got, err := h.traffic(team, after, limit) + if err != nil { + return nil, err + } + return got.Entries, nil +} + +// cloneTeams is a copy of teams that shares nothing with it. +func cloneTeams(teams []teamstore.Team) []teamstore.Team { + if teams == nil { + return nil + } + out := make([]teamstore.Team, len(teams)) + for i, t := range teams { + out[i] = t.Clone() + } + return out +} diff --git a/cmd/codeaf/chatv3_host_teams_test.go b/cmd/codeaf/chatv3_host_teams_test.go new file mode 100644 index 0000000000..611318ef31 --- /dev/null +++ b/cmd/codeaf/chatv3_host_teams_test.go @@ -0,0 +1,223 @@ +package main + +import ( + "errors" + "testing" + + "github.com/Agent-Field/codeaf/internal/remote" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// A WRITE THAT MEETS ANOTHER WRITER IS MADE AGAIN ON TOP OF IT. The window made +// its change to the list it held; the far session set a manager in between, so +// the engine answers Stale. The seam reads the file again, makes the change +// again on the fresh list, and the second write carries both: the rename and +// the manager nobody here saw. +func TestHostTeamsRetriesAStaleWriteOnTopOfTheOtherWriter(t *testing.T) { + far := []teamstore.Team{{ID: "0a0a0a0a0a0a", Name: "harbor", Members: []teamstore.Member{{Key: "k1"}}}} + stamp, reads := "1.1", 0 + var wrote [][]teamstore.Team + h := &hostTeams{ + read: func(since string, _ []float64) (remote.TeamsReading, error) { + reads++ + if since == stamp { + return remote.TeamsReading{Stamp: stamp, Same: true}, nil + } + return remote.TeamsReading{Stamp: stamp, Teams: cloneTeams(far)}, nil + }, + write: func(base string, teams []teamstore.Team) (remote.TeamsReading, error) { + wrote = append(wrote, cloneTeams(teams)) + if base != stamp { + return remote.TeamsReading{Stamp: stamp, Stale: true}, nil + } + far, stamp = cloneTeams(teams), "2.2" + return remote.TeamsReading{Stamp: stamp, Teams: cloneTeams(far)}, nil + }, + } + if _, _, known := h.load(nil); known { + t.Fatal("a seam that has read nothing says it holds something") + } + if _, _, _, err := h.readSince("", nil); err != nil { + t.Fatal(err) + } + // The far session writes after the window read. + far[0].Manager, stamp = "k1", "1.5" + + calls := 0 + teams, at, err := h.update(func(f *teamstore.File) error { + calls++ + f.Teams[0].Name = "dock" + return nil + }) + if err != nil { + t.Fatal(err) + } + if calls != 2 || len(wrote) != 2 || reads != 2 { + t.Fatalf("the change was made %d times, written %d times, read %d times", calls, len(wrote), reads) + } + if at != "2.2" || teams[0].Name != "dock" || teams[0].Manager != "k1" { + t.Fatalf("the second write lost something: %+v at %q", teams, at) + } + if held, heldAt, known := h.load(nil); !known || heldAt != "2.2" || held[0].Manager != "k1" { + t.Fatalf("the seam holds %+v at %q", held, heldAt) + } +} + +// A WRITER THAT NEVER STOPS WINS, AND THE WINDOW IS TOLD. Three stale answers +// in a row are an error the surface says, not a write made over the top. +func TestHostTeamsGivesUpAfterThreeStaleWrites(t *testing.T) { + writes := 0 + h := &hostTeams{ + read: func(string, []float64) (remote.TeamsReading, error) { + return remote.TeamsReading{Stamp: "1.1"}, nil + }, + write: func(string, []teamstore.Team) (remote.TeamsReading, error) { + writes++ + return remote.TeamsReading{Stamp: "9.9", Stale: true}, nil + }, + } + if _, _, err := h.update(func(*teamstore.File) error { return nil }); !errors.Is(err, errHostTeamsBusy) || writes != hostTeamsTries { + t.Fatalf("after %d stale writes: %v", writes, err) + } +} + +// AN ENGINE WITHOUT THE TEAMS DOORS GETS NO SEAM. The welcome of an older +// engine carries no Teams, and the door hands the surface the zero seam, which +// over --host is teams off; it never hands one onto this laptop's profile. +func TestAnOlderEngineGetsNoTeamsSeam(t *testing.T) { + loop, err := remote.Loopback(remote.Hello{Version: remote.Version}, remote.Options{Boot: func(remote.Hello) (*remote.Engine, error) { + return &remote.Engine{Agent: &quietAgent{}, ProfileDir: t.TempDir()}, nil + }}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = loop.Close() }) + far := hostFar{client: loop.Client} + welcome := loop.Client.Welcome() + if seam := hostTeamsSeam(far, welcome); seam.Load == nil || seam.Update == nil || seam.Traffic == nil || seam.ReadSince == nil { + t.Fatal("an engine with the teams doors got no seam") + } + welcome.Teams = false + if seam := hostTeamsSeam(far, welcome); seam.Load != nil || seam.Update != nil { + t.Fatal("an older engine got a teams seam") + } + if seam := hostTeamsSeam(hostFar{}, remote.Welcome{Teams: true}); seam.Load != nil { + t.Fatal("no connection got a teams seam") + } +} + +// THE DELEGATION DOORS CROSS --host, AND AN ENGINE WITHOUT THEM GETS A SEAM +// WITHOUT THEM. This build's engine says Delegation: the seam carries every +// door, and a packet raised and a decision made through it land in the +// ENGINE's profile, not this machine's. An engine that has the teams doors +// and not these (Teams true, Delegation false) gets the teams seam with the +// delegation doors nil, which the surface reads as "not over this +// connection"; it is never handed doors onto this laptop's files. +func TestTheDelegationDoorsCrossHostOnlyWhenTheEngineSaysSo(t *testing.T) { + far := t.TempDir() + loop, err := remote.Loopback(remote.Hello{Version: remote.Version}, remote.Options{Boot: func(remote.Hello) (*remote.Engine, error) { + return &remote.Engine{Agent: &quietAgent{}, ProfileDir: far}, nil + }}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = loop.Close() }) + if err := teamstore.Save(far, []teamstore.Team{{ID: "0a0a0a0a0a0a", Name: "harbor", Manager: "hm", + Members: []teamstore.Member{{Key: "hm", Handle: "boss"}, {Key: "k1", Handle: "web"}}}}); err != nil { + t.Fatal(err) + } + welcome := loop.Client.Welcome() + seam := hostTeamsSeam(hostFar{client: loop.Client}, welcome) + if seam.Defaults == nil || seam.Packets == nil || seam.Raise == nil || seam.Decide == nil || + seam.Escalate == nil || seam.Spend == nil || seam.Delete == nil { + t.Fatal("an engine with the delegation doors got a seam without them") + } + p, err := seam.Raise(teamstore.Packet{Team: "0a0a0a0a0a0a", Kind: teamstore.PacketQuestion, + RaisedBy: "web", Question: "which port?"}) + if err != nil { + t.Fatal(err) + } + open, stamp, same, err := seam.Packets("0a0a0a0a0a0a", "") + if err != nil || same || len(open) != 1 || open[0].ID != p.ID { + t.Fatalf("packets over the seam: %+v %v %v", open, same, err) + } + if _, _, same, _ := seam.Packets("0a0a0a0a0a0a", stamp); !same { + t.Fatal("a quiet packet read over the seam was not same") + } + if _, err := seam.Decide(p.ID, "boss", "8080", "the default"); err != nil { + t.Fatal(err) + } + if got, err := teamstore.PacketByID(far, p.ID); err != nil || got.Decision != "8080" { + t.Fatalf("the decision is not in the engine's profile: %+v %v", got, err) + } + + welcome.Delegation = false + older := hostTeamsSeam(hostFar{client: loop.Client}, welcome) + if older.Load == nil || older.Update == nil { + t.Fatal("an engine with the teams doors and not the delegation doors lost its teams seam") + } + if older.Defaults != nil || older.Packets != nil || older.Raise != nil || older.Decide != nil || + older.Escalate != nil || older.Spend != nil || older.Delete != nil { + t.Fatal("an engine without the delegation doors was handed them") + } +} + +// THE WRAP-UP'S TWO DOORS CROSS --host WHEN THE ENGINE SAYS SO (DESIGN.md +// 8.8): `Wrap up first` lands the one request line in the ENGINE's Traffic, +// and accepting a closing report closes the team in the engine's profile. An +// engine that does not say WrapUp hands no such doors, and the close card +// offers `Close now` only. +func TestTheWrapUpDoorsCrossHostOnlyWhenTheEngineSaysSo(t *testing.T) { + far := t.TempDir() + loop, err := remote.Loopback(remote.Hello{Version: remote.Version}, remote.Options{Boot: func(remote.Hello) (*remote.Engine, error) { + return &remote.Engine{Agent: &quietAgent{}, ProfileDir: far}, nil + }}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = loop.Close() }) + const harbor = "0a0a0a0a0a0a" + if err := teamstore.Save(far, []teamstore.Team{{ID: harbor, Name: "harbor", Manager: "hm", + Members: []teamstore.Member{{Key: "hm", Handle: "boss"}, {Key: "k1", Handle: "web"}}}}); err != nil { + t.Fatal(err) + } + welcome := loop.Client.Welcome() + seam := hostTeamsSeam(hostFar{client: loop.Client}, welcome) + if seam.WrapUp == nil || seam.AcceptClosing == nil { + t.Fatal("an engine with the wrap-up doors got a seam without them") + } + if err := seam.WrapUp(harbor, ""); err != nil { + t.Fatal(err) + } + log, err := teamstore.ReadTraffic(far, harbor, "", 10) + if err != nil || len(log) != 1 || !teamstore.IsWrapUp(log[0]) { + t.Fatalf("the engine's Traffic after a wrap-up: %+v %v", log, err) + } + p, err := seam.Raise(teamstore.Packet{Team: teamstore.Person, Origin: harbor, Kind: teamstore.PacketClosing, + RaisedBy: teamstore.FromManager, Question: "close harbor?", + Options: []teamstore.Option{{ID: teamstore.OptionClose, Label: "Close", Consequence: "the team closes"}, + {ID: teamstore.OptionKeepGoing, Label: "Keep going", Consequence: "the team goes on"}}, + Report: &teamstore.ClosingReport{Done: "the parser"}}) + if err != nil { + t.Fatal(err) + } + if _, err := seam.Decide(p.ID, teamstore.Person, teamstore.OptionClose, ""); err != nil { + t.Fatal(err) + } + if closed, err := seam.AcceptClosing(p.ID); err != nil || !closed { + t.Fatalf("accepting the report over --host: %v %v", closed, err) + } + f, err := teamstore.Load(far) + if err != nil { + t.Fatal(err) + } + if got, ok := f.Team(harbor); !ok || !got.Closed() { + t.Fatalf("the engine's harbor is not closed: %+v", got) + } + + welcome.WrapUp = false + older := hostTeamsSeam(hostFar{client: loop.Client}, welcome) + if older.Decide == nil || older.WrapUp != nil || older.AcceptClosing != nil { + t.Fatal("an engine without the wrap-up doors was handed them, or lost the others") + } +} diff --git a/cmd/codeaf/engine.go b/cmd/codeaf/engine.go index 2a91faebeb..211a7bd060 100644 --- a/cmd/codeaf/engine.go +++ b/cmd/codeaf/engine.go @@ -109,6 +109,10 @@ func runRemoteEngine(args []string) error { return fmt.Errorf("usage: codeaf engine [--workspace path] [--session path] [--no-host] [--status] [--status-all] [--stop] [--stop-all]") } + // AN ENGINE CAN OPEN A TEAM CONVERSATION NOBODY HOLDS, so team traffic can + // wake it (team_resume.go). Only the two roads below that serve sessions + // ever use the door; the splice between them serves none. + armTeamResume() if *daemon { return runEngineHost(*workspace, *file) } diff --git a/cmd/codeaf/host_team_settings_test.go b/cmd/codeaf/host_team_settings_test.go new file mode 100644 index 0000000000..6eb9818b29 --- /dev/null +++ b/cmd/codeaf/host_team_settings_test.go @@ -0,0 +1,42 @@ +package main + +import ( + "testing" + + "github.com/Agent-Field/codeaf/internal/remote" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// THE SETTINGS WRITE CROSSES WHEN THE ENGINE SAYS SO. An edit through the +// seam lands in the engine's profile. An engine that does not say +// TeamSettings keeps the door nil, which is the Teams tab staying read-only. +func TestHostTeamsCarriesASettingsWriteOnlyWhenTheEngineSaysSo(t *testing.T) { + far := t.TempDir() + loop, err := remote.Loopback(remote.Hello{Version: remote.Version}, remote.Options{Boot: func(remote.Hello) (*remote.Engine, error) { + return &remote.Engine{Agent: &quietAgent{}, ProfileDir: far}, nil + }}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = loop.Close() }) + welcome := loop.Client.Welcome() + seam := hostTeamsSeam(hostFar{client: loop.Client}, welcome) + if seam.ApplyDefault == nil || seam.Defaults == nil { + t.Fatal("this engine's seam cannot read or change team defaults") + } + d, err := seam.ApplyDefault("teams.cap_usd_day", "6") + if err != nil || d.CapUSDDay != 6 { + t.Fatalf("apply: %+v, %v", d, err) + } + if teamstore.DefaultsAt(far).CapUSDDay != 6 { + t.Fatal("the engine profile did not take the cap") + } + welcome.TeamSettings = false + older := hostTeamsSeam(hostFar{client: loop.Client}, welcome) + if older.ApplyDefault != nil { + t.Fatal("an older engine was handed the settings write") + } + if older.Defaults == nil { + t.Fatal("an engine with the delegation doors lost the read") + } +} diff --git a/cmd/codeaf/team_conflict_test.go b/cmd/codeaf/team_conflict_test.go new file mode 100644 index 0000000000..de3bea3671 --- /dev/null +++ b/cmd/codeaf/team_conflict_test.go @@ -0,0 +1,202 @@ +package main + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "path/filepath" + "regexp" + "strings" + "sync" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/remote" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// A CONFLICT BETWEEN MEMBERS OF TWO SIBLING SUB-TEAMS LANDS AT THEIR COMMON +// PARENT'S MANAGER, WHICH RULES, AND BOTH PARTIES RECEIVE THE RULING, end to +// end through the engine's own [bootEngine], with nothing set that a person +// does not set. Three conversations run on the engine: @web in the sub-team +// front, @api in its sibling back, and @boss, the manager of harbor, which +// both sit under (each sub-team's own manager is a conversation nobody has +// open). The model endpoint is scripted to do what each would: @web raises the +// conflict with `team_raise`; @boss, woken by the packet, rules on it with +// `team_decide`. Nobody types to @boss or @api, and the person is never +// asked: both parties are woken by the ruling, marked as one. +func TestTeamConflictBetweenSiblingSubTeamsIsRuledByTheirCommonManager(t *testing.T) { + root := resolvedTempDir(t) + _, workspace := wakeEnvironment(t, root) + script := newConflictModel(t) + t.Setenv("CODEAF_BASE_URL", script.server.URL) + + boot := func() (*remote.Engine, string) { + t.Helper() + engine, err := bootEngine(remote.Hello{Version: remote.Version, Workspace: workspace, New: true}, "", "") + if err != nil { + t.Fatalf("the engine door did not open: %v", err) + } + t.Cleanup(func() { _ = engine.Agent.Close() }) + file := strings.TrimSpace(engine.SessionFile) + if file == "" { + t.Fatal("the engine named no transcript") + } + return engine, file + } + web, webFile := boot() + _, apiFile := boot() + _, bossFile := boot() + if webFile == apiFile || apiFile == bossFile { + t.Fatal("the engine handed two hellos one conversation") + } + + lead := filepath.Join(root, "elsewhere", "lead.jsonl") + chief := filepath.Join(root, "elsewhere", "chief.jsonl") + harbor, front, back := teams.NewID(), teams.NewID(), teams.NewID() + member := func(file, word, handle string) teams.Member { + return teams.Member{Key: filepath.Clean(file), File: file, Where: workspace, Word: word, Handle: handle} + } + err := teams.Update("", func(f *teams.File) error { + f.Teams = append(f.Teams, + teams.Team{ID: harbor, Name: "harbor"}, + teams.Team{ID: front, Name: "front", Parent: harbor}, + teams.Team{ID: back, Name: "back", Parent: harbor}) + for _, add := range []struct { + team string + members []teams.Member + manager string + }{ + {harbor, []teams.Member{member(bossFile, "harbor manager", "boss"), member(lead, "front lead", "lead"), member(chief, "back chief", "chief")}, bossFile}, + {front, []teams.Member{member(lead, "front lead", "lead"), member(webFile, "web frontend", "web")}, lead}, + {back, []teams.Member{member(chief, "back chief", "chief"), member(apiFile, "signup api", "api")}, chief}, + } { + for _, m := range add.members { + if err := f.AddMember(add.team, m); err != nil { + return err + } + } + if err := f.SetManager(add.team, filepath.Clean(add.manager)); err != nil { + return err + } + } + return nil + }) + if err != nil { + t.Fatalf("make the teams: %v", err) + } + + events, err := web.Agent.Submit(t.Context(), "RAISE the conflict over the signup form") + if err != nil { + t.Fatalf("the turn did not start: %v", err) + } + for range events { + } + + waiting, _, err := teams.OpenPackets("", harbor) + if err != nil || len(waiting) != 1 { + t.Fatalf("no conflict waits on harbor's manager: %+v %v\nthe model saw:\n%s", waiting, err, script.last()) + } + p := waiting[0] + if p.Kind != teams.PacketConflict || p.Origin != front || len(p.Parties) != 2 || p.Parties[1].Team != back { + t.Fatalf("the packet: %+v", p) + } + if mine, _, _ := teams.OpenPackets("", teams.Person); len(mine) != 0 { + t.Fatalf("the conflict reached the person: %+v", mine) + } + + // @boss is woken by the packet and rules; the script decides option 1. + deadline := time.Now().Add(40 * time.Second) + for { + got, err := teams.PacketByID("", p.ID) + if err == nil && got.State == teams.PacketDecided { + if got.DecidedBy != "boss" || got.Decision != "1" { + t.Fatalf("decided %+v", got) + } + break + } + if time.Now().After(deadline) { + t.Fatalf("harbor's manager never ruled; the model last saw:\n%s", script.last()) + } + time.Sleep(50 * time.Millisecond) + } + + // Both parties are woken with the ruling, each in its own team. + script.waitForBoth(t, `Team traffic in "front" for you (@web)`, "◆ ruling on the conflict "+p.ID, 30*time.Second) + script.waitForBoth(t, `Team traffic in "back" for you (@api)`, "◆ ruling on the conflict "+p.ID, 30*time.Second) + script.waitForBoth(t, `Team traffic in "back" for you (@api)`, "JSON: the handler changes", time.Second) +} + +// conflictModel answers @web's turn with `team_raise`, @boss's woken turn with +// `team_decide` on the packet it was handed, and everything else with "ok". +type conflictModel struct { + server *httptest.Server + mu sync.Mutex + seen []recordedRequest +} + +var conflictPacketID = regexp.MustCompile(`◆ conflict (p[0-9a-f]{12}) from @web, waiting on you`) + +func newConflictModel(t *testing.T) *conflictModel { + t.Helper() + m := &conflictModel{} + raise := `{"question":"which shape does the signup form send?","parties":["back/@api"],"context":"the form posts JSON",` + + `"options":[{"label":"JSON","consequence":"the handler changes"},{"label":"form data","consequence":"the form changes"}],"recommend":"1","reason":"the other endpoints take JSON"}` + m.server = httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) { + if !strings.HasSuffix(request.URL.Path, "/chat/completions") { + http.Error(writer, "no catalog for a test", http.StatusServiceUnavailable) + return + } + raw, _ := io.ReadAll(request.Body) + var envelope recordedRequest + if err := json.Unmarshal(raw, &envelope); err != nil { + http.Error(writer, err.Error(), http.StatusBadRequest) + return + } + m.mu.Lock() + m.seen = append(m.seen, envelope) + m.mu.Unlock() + all := strings.Join(envelope.texts(), "\n") + switch { + case len(envelope.Tools) == 0: + writeText(writer, envelope.Stream, "ok") + case strings.Contains(all, "RAISE the conflict") && !strings.Contains(all, "Raised conflict") && !strings.Contains(all, "could not be raised"): + writeToolCall(writer, envelope.Stream, "r1", "team_raise", raise) + case conflictPacketID.MatchString(all) && !strings.Contains(all, "Decided p"): + id := conflictPacketID.FindStringSubmatch(all)[1] + writeToolCall(writer, envelope.Stream, "d1", "team_decide", `{"packet":"`+id+`","answer":"1","reason":"the other endpoints take JSON"}`) + default: + writeText(writer, envelope.Stream, "ok") + } + })) + t.Cleanup(m.server.Close) + return m +} + +// waitForBoth waits until one request carried both a and b. +func (m *conflictModel) waitForBoth(t *testing.T, a, b string, within time.Duration) { + t.Helper() + deadline := time.Now().Add(within) + for time.Now().Before(deadline) { + m.mu.Lock() + for _, request := range m.seen { + if request.messageContaining(a) != "" && request.messageContaining(b) != "" { + m.mu.Unlock() + return + } + } + m.mu.Unlock() + time.Sleep(20 * time.Millisecond) + } + t.Fatalf("no request carried both %q and %q; the last was:\n%s", a, b, m.last()) +} + +func (m *conflictModel) last() string { + m.mu.Lock() + defer m.mu.Unlock() + if len(m.seen) == 0 { + return "(nothing)" + } + return m.seen[len(m.seen)-1].allText() +} diff --git a/cmd/codeaf/team_launch_test.go b/cmd/codeaf/team_launch_test.go new file mode 100644 index 0000000000..7ebc180463 --- /dev/null +++ b/cmd/codeaf/team_launch_test.go @@ -0,0 +1,263 @@ +package main + +import ( + "context" + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/config" + "github.com/Agent-Field/codeaf/internal/home" + "github.com/Agent-Field/codeaf/internal/remote" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// A CONVERSATION MADE A TEAM'S MANAGER ON THE ORDINARY LAUNCH KNOWS IT IS ONE. +// +// Every team test in internal/session built its agent with Config.ProfileDir +// set to a temporary directory, and every one of them passed while the feature +// was dead for everybody: the ordinary launch exports no CODEAF_PROFILE_DIR, so +// the engine daemon that builds the session hands it an empty ProfileDir, and +// the session read the empty string as "no profile, no team". The manager's +// transcript on the machine where it was found carried no team note, no team +// verb and no cursor file, and asked what was happening it described the home +// folder. +// +// So this test goes through the door the product goes through, with nothing +// set that a person does not set: an empty CODEAF_PROFILE_DIR, the engine's own +// [bootEngine] building the conversation, a model endpoint that only records +// what it is sent, and a teams.json where the ordinary launch keeps it (the +// state root, which this test moves to a directory of its own so the person's +// real teams are never read). It asserts on the wire: the first request of the +// first turn carries the manager's verbs and the manager's role, stated as +// codeaf's instruction rather than as a fact beside the work. +func TestTheOrdinaryLaunchTellsAManagerItIsOne(t *testing.T) { + root := resolvedTempDir(t) + t.Setenv("HOME", filepath.Join(root, "home")) + t.Setenv(home.EnvVar, filepath.Join(root, "state")) + t.Setenv(config.ProfileDirEnv, "") + t.Setenv("OPENROUTER_API_KEY", "test-key") + model := newRecordingModel(t) + t.Setenv("CODEAF_BASE_URL", model.server.URL) + workspace := filepath.Join(root, "work") + if err := os.MkdirAll(workspace, 0o700); err != nil { + t.Fatal(err) + } + t.Chdir(workspace) + freshEngineProcess(t) + + engine, err := bootEngine(remote.Hello{Version: remote.Version, Workspace: workspace}, "", "") + if err != nil { + t.Fatalf("the engine door did not open: %v", err) + } + defer func() { _ = engine.Agent.Close() }() + transcript := strings.TrimSpace(engine.SessionFile) + if transcript == "" { + t.Fatal("the engine named no transcript, so there is no key to make a manager of") + } + + // THE TEAM, WRITTEN WHERE THE INTERFACE WRITES IT ON THE ORDINARY LAUNCH: + // an empty profile directory, which internal/teams resolves to the state + // root this test chose. + teamID := teams.NewID() + manager := filepath.Clean(transcript) + web := filepath.Join(root, "elsewhere", "transcript.jsonl") + err = teams.Update("", func(file *teams.File) error { + file.Teams = append(file.Teams, teams.Team{ID: teamID, Name: "harbor"}) + for _, member := range []teams.Member{ + {Key: manager, File: manager, Word: "harbor manager"}, + {Key: web, File: web, Word: "web frontend", Handle: "web"}, + } { + if err := file.AddMember(teamID, member); err != nil { + return err + } + } + return file.SetManager(teamID, manager) + }) + if err != nil { + t.Fatalf("make the team: %v", err) + } + + ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + defer cancel() + events, err := engine.Agent.Submit(ctx, "can you tell me what's happening here?") + if err != nil { + t.Fatalf("the turn did not start: %v", err) + } + for range events { + } + + first, ok := model.firstTurnRequest() + if !ok { + t.Fatal("the model was never asked anything with a belt, so there is no turn to read") + } + for _, verb := range []string{"team_status", "team_read", "team_send", "team_stop", "team_start"} { + if !first.carriesTool(verb) { + t.Errorf("the manager's first request carried no %s", verb) + } + } + role := first.messageContaining(`manager of the team "harbor"`) + if role == "" { + t.Fatalf("the manager's first request never told it it manages harbor:\n%s", first.allText()) + } + if !strings.Contains(role, "@web") { + t.Errorf("the manager's role does not name its member @web:\n%s", role) + } + if !strings.HasPrefix(role, "Instructions from codeaf") || strings.Contains(role, "Facts, not requests") { + t.Errorf("the manager's role rode as a fact note, not as codeaf's instruction:\n%s", role) + } +} + +// resolvedTempDir is t.TempDir with its symlinks resolved, so the path a +// conversation keys itself by and the path this test writes into teams.json +// are one spelling on a Mac, where /var is /private/var. +func resolvedTempDir(t *testing.T) string { + t.Helper() + dir, err := filepath.EvalSymlinks(t.TempDir()) + if err != nil { + t.Fatal(err) + } + return dir +} + +// freshEngineProcess empties the engine's once-per-process memo for this test +// and again after it, because the memo holds the process of whichever test +// booted an engine first, with that test's model endpoint and profile. +func freshEngineProcess(t *testing.T) { + t.Helper() + reset := func() { + closeEngineProcess() + engineProcess.once = sync.Once{} + engineProcess.proc = nil + engineProcess.err = nil + } + reset() + t.Cleanup(reset) +} + +// recordingModel is an OpenAI-shaped endpoint that answers every completion +// with "done" and keeps every request it was sent. +type recordingModel struct { + server *httptest.Server + mu sync.Mutex + requests []recordedRequest +} + +type recordedRequest struct { + Messages []struct { + Role string `json:"role"` + Content json.RawMessage `json:"content"` + } `json:"messages"` + Tools []struct { + Function struct { + Name string `json:"name"` + } `json:"function"` + } `json:"tools"` + Stream bool `json:"stream"` +} + +func newRecordingModel(t *testing.T) *recordingModel { + t.Helper() + model := &recordingModel{} + model.server = httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) { + if !strings.HasSuffix(request.URL.Path, "/chat/completions") { + http.Error(writer, "no catalog for a test", http.StatusServiceUnavailable) + return + } + raw, _ := io.ReadAll(request.Body) + var envelope recordedRequest + if err := json.Unmarshal(raw, &envelope); err != nil { + http.Error(writer, err.Error(), http.StatusBadRequest) + return + } + model.record(envelope) + if envelope.Stream { + writer.Header().Set("Content-Type", "text/event-stream") + _, _ = writer.Write([]byte(`data: {"id":"team-probe","choices":[{"index":0,"delta":{"role":"assistant","content":"done"},"finish_reason":"stop"}]}` + "\n\ndata: [DONE]\n\n")) + return + } + _, _ = writer.Write([]byte(`{"choices":[{"index":0,"message":{"role":"assistant","content":"done"},"finish_reason":"stop"}]}`)) + })) + t.Cleanup(model.server.Close) + return model +} + +func (m *recordingModel) record(request recordedRequest) { + m.mu.Lock() + defer m.mu.Unlock() + m.requests = append(m.requests, request) +} + +// firstTurnRequest is the first request sent with a belt: a turn's, and not a +// title's or a namer's, which carry no tools. +func (m *recordingModel) firstTurnRequest() (recordedRequest, bool) { + m.mu.Lock() + defer m.mu.Unlock() + for _, request := range m.requests { + if len(request.Tools) > 0 { + return request, true + } + } + return recordedRequest{}, false +} + +func (r recordedRequest) carriesTool(name string) bool { + for _, tool := range r.Tools { + if tool.Function.Name == name { + return true + } + } + return false +} + +// texts is every message's text, whether its content is a string or parts. +func (r recordedRequest) texts() []string { + var out []string + for _, message := range r.Messages { + var plain string + if json.Unmarshal(message.Content, &plain) == nil { + out = append(out, plain) + continue + } + var parts []struct { + Text string `json:"text"` + } + if json.Unmarshal(message.Content, &parts) == nil { + var joined []string + for _, part := range parts { + joined = append(joined, part.Text) + } + out = append(out, strings.Join(joined, "")) + } + } + return out +} + +func (r recordedRequest) messageContaining(want string) string { + for _, text := range r.texts() { + if strings.Contains(text, want) { + return text + } + } + return "" +} + +func (r recordedRequest) allText() string { + var b strings.Builder + for _, text := range r.texts() { + b.WriteString("--- message\n") + if len(text) > 600 { + text = text[:600] + "…" + } + b.WriteString(text) + b.WriteString("\n") + } + return b.String() +} diff --git a/cmd/codeaf/team_questions_test.go b/cmd/codeaf/team_questions_test.go new file mode 100644 index 0000000000..08385be12b --- /dev/null +++ b/cmd/codeaf/team_questions_test.go @@ -0,0 +1,161 @@ +package main + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strconv" + "strings" + "sync" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/remote" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// A MEMBER'S QUESTION GOES UP TO ITS MANAGER AND THE ANSWER COMES BACK, on the +// ordinary launch and on the engine a window over --host talks to: the +// engine's own [bootEngine] builds the member with nothing set that a person +// does not set, the team is written where the ordinary launch keeps it, and the +// model endpoint is scripted to do what a member does, load the questions +// group and `ask`. Nothing reaches the person: the question is a packet for the +// manager, the member is told so, and when the manager decides it the member +// is woken with the answer marked `◆ answered`. +func TestTeamQuestionsUpTheOrdinaryLaunchSendsAMembersQuestionToItsManager(t *testing.T) { + root := resolvedTempDir(t) + model, workspace := wakeEnvironment(t, root) + script := newScriptedModel(t) + t.Setenv("CODEAF_BASE_URL", script.server.URL) + _ = model + + engine, err := bootEngine(remote.Hello{Version: remote.Version, Workspace: workspace}, "", "") + if err != nil { + t.Fatalf("the engine door did not open: %v", err) + } + defer func() { _ = engine.Agent.Close() }() + member := strings.TrimSpace(engine.SessionFile) + if member == "" { + t.Fatal("the engine named no transcript") + } + teamID := managedTeamWith(t, root, member, workspace) + + events, err := engine.Agent.Submit(t.Context(), "build the signup form") + if err != nil { + t.Fatalf("the turn did not start: %v", err) + } + for range events { + } + + waiting, _, err := teams.OpenPackets("", teamID) + if err != nil || len(waiting) != 1 { + t.Fatalf("no packet waits on the manager: %+v %v\nthe model saw:\n%s", waiting, err, script.transcript()) + } + p := waiting[0] + if p.Kind != teams.PacketQuestion || p.RaisedBy != "web" || p.Question != "JSON or form data?" { + t.Fatalf("the packet: %+v", p) + } + if mine, _, _ := teams.OpenPackets("", teams.Person); len(mine) != 0 { + t.Fatalf("the member's question reached the person: %+v", mine) + } + script.waitFor(t, "went to your manager (@boss", 10*time.Second) + + if _, err := teams.Decide("", p.ID, teams.FromManager, "1", "the other endpoints take JSON"); err != nil { + t.Fatalf("the manager could not decide: %v", err) + } + script.waitFor(t, "◆ answered: JSON (by ◆ @boss, because the other endpoints take JSON)", 20*time.Second) +} + +// scriptedModel is an OpenAI-shaped endpoint that answers a member's first +// turn with two tool calls (load the questions group, then `ask`) and every +// other request with "ok", recording what it was sent. +type scriptedModel struct { + server *httptest.Server + mu sync.Mutex + turn int + seen []recordedRequest +} + +func newScriptedModel(t *testing.T) *scriptedModel { + t.Helper() + m := &scriptedModel{} + ask := `{"head":"JSON or form data?","kind":"clarification","reason":"the handler and the form disagree","stakes":"reversible",` + + `"options":[{"key":"1","label":"JSON","consequence":"the handler changes"},{"key":"2","label":"form data","consequence":"the form changes"}]}` + m.server = httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) { + if !strings.HasSuffix(request.URL.Path, "/chat/completions") { + http.Error(writer, "no catalog for a test", http.StatusServiceUnavailable) + return + } + raw, _ := io.ReadAll(request.Body) + var envelope recordedRequest + if err := json.Unmarshal(raw, &envelope); err != nil { + http.Error(writer, err.Error(), http.StatusBadRequest) + return + } + m.mu.Lock() + m.seen = append(m.seen, envelope) + step := -1 + if len(envelope.Tools) > 0 { + step = m.turn + m.turn++ + } + m.mu.Unlock() + switch step { + case 0: + writeToolCall(writer, envelope.Stream, "c1", "load_capability", `{"group":"questions"}`) + case 1: + writeToolCall(writer, envelope.Stream, "c2", "ask", ask) + default: + writeText(writer, envelope.Stream, "ok") + } + })) + t.Cleanup(m.server.Close) + return m +} + +func writeText(writer http.ResponseWriter, stream bool, text string) { + if stream { + writer.Header().Set("Content-Type", "text/event-stream") + _, _ = writer.Write([]byte(`data: {"id":"q","choices":[{"index":0,"delta":{"role":"assistant","content":` + strconv.Quote(text) + `},"finish_reason":"stop"}]}` + "\n\ndata: [DONE]\n\n")) + return + } + _, _ = writer.Write([]byte(`{"choices":[{"index":0,"message":{"role":"assistant","content":` + strconv.Quote(text) + `},"finish_reason":"stop"}]}`)) +} + +func writeToolCall(writer http.ResponseWriter, stream bool, id, name, arguments string) { + call := `{"index":0,"id":"` + id + `","type":"function","function":{"name":"` + name + `","arguments":` + strconv.Quote(arguments) + `}}` + if stream { + writer.Header().Set("Content-Type", "text/event-stream") + _, _ = writer.Write([]byte(`data: {"id":"q","choices":[{"index":0,"delta":{"role":"assistant","tool_calls":[` + call + `]},"finish_reason":"tool_calls"}]}` + "\n\ndata: [DONE]\n\n")) + return + } + _, _ = writer.Write([]byte(`{"choices":[{"index":0,"message":{"role":"assistant","content":"","tool_calls":[` + call + `]},"finish_reason":"tool_calls"}]}`)) +} + +// waitFor waits until some request carried a message holding want. +func (m *scriptedModel) waitFor(t *testing.T, want string, within time.Duration) { + t.Helper() + deadline := time.Now().Add(within) + for time.Now().Before(deadline) { + m.mu.Lock() + for _, request := range m.seen { + if request.messageContaining(want) != "" { + m.mu.Unlock() + return + } + } + m.mu.Unlock() + time.Sleep(20 * time.Millisecond) + } + t.Fatalf("the model was never sent %q; it saw:\n%s", want, m.transcript()) +} + +func (m *scriptedModel) transcript() string { + m.mu.Lock() + defer m.mu.Unlock() + if len(m.seen) == 0 { + return "(nothing)" + } + return m.seen[len(m.seen)-1].allText() +} diff --git a/cmd/codeaf/team_resume.go b/cmd/codeaf/team_resume.go new file mode 100644 index 0000000000..66281e6923 --- /dev/null +++ b/cmd/codeaf/team_resume.go @@ -0,0 +1,73 @@ +package main + +import ( + "errors" + "net" + "strings" + "time" + + "github.com/Agent-Field/codeaf/internal/remote" + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── A TEAM CONVERSATION NOBODY HOLDS IS OPENED BY ITS HOST ────────────────── +// +// Team traffic wakes the conversation it is for (internal/session's +// team_wakewatch.go), and a conversation wakes only if some process holds it: a +// directive to a member whose window closed an hour ago, and whose host let it +// go, would wake nobody. So the session asks the engine, through +// [session.SetTeamResume], to open that conversation where it lives, and this +// is the engine's answer: a hello to the session host of the member's folder, +// naming its transcript, exactly as a window opening it would send, and then +// the connection is let go. +// +// THE HOST KEEPS WHAT A HELLO OPENED. A conversation with no surface is kept +// while it does anything at all (internal/enginehost's idle policy), so the +// member opened here runs its woken turn with nobody attached, and a window +// that opens it later is handed that same running conversation rather than a +// second one onto its journal. +// +// IT IS SET ONLY WHERE A PROCESS IS AN ENGINE: the host daemon and the pipe +// engine ([runRemoteEngine]), which is every conversation on the ordinary road +// and every one over --host, since the far `codeaf engine` is one of those two. +// A launch that keeps its conversation in the terminal's own process +// (--no-host, --once) has no door, and the session says in the Traffic that it +// could not wake a member rather than pretending it did. + +// teamResumeHello is how long the hello may take: a host may have to start, +// and the conversation has to be loaded before the welcome comes back. +const teamResumeHello = 45 * time.Second + +// armTeamResume gives this engine process the door. +func armTeamResume() { + session.SetTeamResume(func(file, workspace string) error { + return resumeTeamConversation(file, workspace, attachEngineHost) + }) +} + +// resumeTeamConversation opens one conversation in its folder's host, over +// attach (the host dialled, and started when it is not running). +func resumeTeamConversation(file, workspace string, attach func(string) (net.Conn, error)) error { + file, workspace = strings.TrimSpace(file), strings.TrimSpace(workspace) + if file == "" { + return errors.New("no transcript to open") + } + if workspace == "" { + return errors.New("the team has no folder recorded for it") + } + folder, err := engineWorkspace(workspace) + if err != nil { + return err + } + conn, err := attach(folder) + if err != nil { + return err + } + _ = conn.SetDeadline(time.Now().Add(teamResumeHello)) + client, err := remote.Dial(conn, "", remote.Hello{Workspace: folder, Session: file}) + if err != nil { + _ = conn.Close() + return err + } + return client.Close() +} diff --git a/cmd/codeaf/team_wake_test.go b/cmd/codeaf/team_wake_test.go new file mode 100644 index 0000000000..f24a362ae3 --- /dev/null +++ b/cmd/codeaf/team_wake_test.go @@ -0,0 +1,229 @@ +package main + +import ( + "net" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/config" + "github.com/Agent-Field/codeaf/internal/enginehost" + "github.com/Agent-Field/codeaf/internal/home" + "github.com/Agent-Field/codeaf/internal/remote" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// TEAM TRAFFIC WAKES A CONVERSATION ON THE ENGINE, through the doors the +// product goes through: the engine's own [bootEngine] builds the conversation +// with nothing set that a person does not set, the team is written where the +// ordinary launch keeps it, and the model endpoint only records what it is +// sent. The engine is what a window over --host talks to as well, so what is +// asserted here is the engine side of both roads. + +// wakeRoot is a short state root for a test that listens on a socket, whose +// path has to fit in a socket name. +func wakeRoot(t *testing.T) string { + t.Helper() + root, err := os.MkdirTemp("/tmp", "af-wake-") + if err != nil { + return resolvedTempDir(t) + } + t.Cleanup(func() { _ = os.RemoveAll(root) }) + if real, err := filepath.EvalSymlinks(root); err == nil { + root = real + } + return root +} + +// wakeEnvironment is the ordinary launch's environment under root, a recording +// model, and a workspace; it returns the model and the workspace. +func wakeEnvironment(t *testing.T, root string) (*recordingModel, string) { + t.Helper() + t.Setenv("HOME", filepath.Join(root, "home")) + t.Setenv(home.EnvVar, filepath.Join(root, "state")) + t.Setenv(config.ProfileDirEnv, "") + t.Setenv("OPENROUTER_API_KEY", "test-key") + model := newRecordingModel(t) + t.Setenv("CODEAF_BASE_URL", model.server.URL) + workspace := filepath.Join(root, "work") + if err := os.MkdirAll(workspace, 0o700); err != nil { + t.Fatal(err) + } + t.Chdir(workspace) + freshEngineProcess(t) + return model, workspace +} + +// managedTeamWith writes a team whose manager is a conversation nobody has +// open and whose one member, @web, is the transcript given. +func managedTeamWith(t *testing.T, root, member, workspace string) string { + t.Helper() + teamID := teams.NewID() + manager := filepath.Join(root, "elsewhere", "manager.jsonl") + err := teams.Update("", func(file *teams.File) error { + file.Teams = append(file.Teams, teams.Team{ID: teamID, Name: "harbor"}) + for _, m := range []teams.Member{ + {Key: manager, File: manager, Word: "harbor manager", Handle: "boss"}, + {Key: filepath.Clean(member), File: member, Where: workspace, Word: "web frontend", Handle: "web"}, + } { + if err := file.AddMember(teamID, m); err != nil { + return err + } + } + return file.SetManager(teamID, manager) + }) + if err != nil { + t.Fatalf("make the team: %v", err) + } + return teamID +} + +// waitForDirective waits until the model has been sent a line that is the +// manager's directive and carries text as its words. It asserts what the +// member was handed, not the line's exact wording: a delivered line's head may +// end in the entry's number (" #42", which a member is told so it can answer +// that line), and that number is the Traffic's to choose. +func (m *recordingModel) waitForDirective(t *testing.T, text string, within time.Duration) { + t.Helper() + deadline := time.Now().Add(within) + for time.Now().Before(deadline) { + m.mu.Lock() + for _, request := range m.requests { + for _, message := range request.texts() { + if directiveLineIn(message, text) { + m.mu.Unlock() + return + } + } + } + m.mu.Unlock() + time.Sleep(20 * time.Millisecond) + } + m.mu.Lock() + var sent strings.Builder + for _, request := range m.requests { + sent.WriteString(request.allText()) + } + m.mu.Unlock() + t.Fatalf("the model was never sent the manager's directive %q; it was sent:\n%s", text, sent.String()) +} + +// directiveLineIn reports whether message holds a line marked as the +// manager's directive whose words are text. +func directiveLineIn(message, text string) bool { + for _, line := range strings.Split(message, "\n") { + head, words, ok := strings.Cut(strings.TrimSpace(line), ": ") + if ok && strings.HasPrefix(head, "◆ directive from manager") && words == text { + return true + } + } + return false +} + +// A DIRECTIVE WAKES A MEMBER THE ENGINE HOLDS, with no surface and nobody +// typing: its turn opens on the directive, marked as the manager's. +func TestTeamWakeTheEngineWakesAnIdleMemberOnADirective(t *testing.T) { + root := resolvedTempDir(t) + model, workspace := wakeEnvironment(t, root) + engine, err := bootEngine(remote.Hello{Version: remote.Version, Workspace: workspace}, "", "") + if err != nil { + t.Fatalf("the engine door did not open: %v", err) + } + defer func() { _ = engine.Agent.Close() }() + member := strings.TrimSpace(engine.SessionFile) + if member == "" { + t.Fatal("the engine named no transcript") + } + teamID := managedTeamWith(t, root, member, workspace) + if err := teams.AppendTraffic("", teamID, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}); err != nil { + t.Fatal(err) + } + model.waitForDirective(t, "Fix the header.", 20*time.Second) +} + +// A MEMBER NOBODY HOLDS IS OPENED BY ITS FOLDER'S HOST, and wakes there. The +// member is a real conversation, closed; the host is a real host on a real +// socket, serving the engine's own boot; the door is the one an engine arms +// ([resumeTeamConversation]), dialling that host rather than spawning one. +func TestTeamWakeAMemberNobodyHoldsIsOpenedHeadlessByItsHost(t *testing.T) { + root := wakeRoot(t) + model, workspace := wakeEnvironment(t, root) + + first, err := bootEngine(remote.Hello{Version: remote.Version, Workspace: workspace}, "", "") + if err != nil { + t.Fatalf("the engine door did not open: %v", err) + } + member := strings.TrimSpace(first.SessionFile) + if err := first.Agent.Close(); err != nil { + t.Fatalf("close the member: %v", err) + } + if member == "" { + t.Fatal("the engine named no transcript") + } + + stopped := make(chan error, 1) + go func() { + stopped <- enginehost.Run(workspace, enginehost.Options{ + Boot: func(hello remote.Hello) (*remote.Engine, error) { return bootEngine(hello, workspace, "") }, + Key: func(hello remote.Hello) string { return engineHelloKey(hello, workspace, "") }, + }) + }() + t.Cleanup(func() { + _, _ = enginehost.Stop(workspace) + select { + case <-stopped: + case <-time.After(10 * time.Second): + t.Log("the host did not stop within ten seconds") + } + }) + deadline := time.Now().Add(5 * time.Second) + for { + conn, err := enginehost.Dial(workspace) + if err == nil { + _ = conn.Close() + break + } + if time.Now().After(deadline) { + t.Fatalf("no host answered on the socket: %v", err) + } + time.Sleep(10 * time.Millisecond) + } + + teamID := managedTeamWith(t, root, member, workspace) + if err := teams.AppendTraffic("", teamID, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}); err != nil { + t.Fatal(err) + } + dial := func(folder string) (net.Conn, error) { return enginehost.Dial(folder) } + if err := resumeTeamConversation(member, workspace, dial); err != nil { + t.Fatalf("the host did not open the member: %v", err) + } + model.waitForDirective(t, "Fix the header.", 20*time.Second) + + // AND A WINDOW OPENING IT NOW JOINS THE RUNNING ONE rather than booting a + // second agent onto its journal. + conn, err := enginehost.Dial(workspace) + if err != nil { + t.Fatal(err) + } + client, err := remote.Dial(conn, "", remote.Hello{Workspace: workspace, Session: member, Join: true}) + if err != nil { + t.Fatalf("a window could not join the member the host opened: %v", err) + } + _ = client.Close() +} + +// THE DOOR REFUSES WHAT IT CANNOT OPEN, with the reason the Traffic will carry. +func TestTeamWakeTheResumeDoorSaysWhyItCannotOpen(t *testing.T) { + never := func(string) (net.Conn, error) { + t.Fatal("the door dialled a host for a member it cannot open") + return nil, nil + } + if err := resumeTeamConversation("", "/tmp", never); err == nil { + t.Error("a member with no transcript was opened") + } + if err := resumeTeamConversation("/tmp/x.jsonl", "", never); err == nil || !strings.Contains(err.Error(), "no folder") { + t.Errorf("a member with no folder gave %v", err) + } +} diff --git a/docs/changes/unreleased/1429-chats-on-the-bar.md b/docs/changes/unreleased/1429-chats-on-the-bar.md new file mode 100644 index 0000000000..58e257c00a --- /dev/null +++ b/docs/changes/unreleased/1429-chats-on-the-bar.md @@ -0,0 +1,8 @@ +--- +kind: added +title: the places bar has a chats word that goes back to the conversation +pr: 1429 +surface: [chat, docs] +invalidates: + - "The places bar read `home tasks spend settings` and the digits were home 1, tasks 2, spend 3, settings 4, standing 5, memory 6, search 7. It reads `home teams chats sessions spend settings` and the digits follow it: teams 2, chats 3, sessions 4, spend 5, settings 6, standing 7, memory 8, search 9. A click on `chats`, `alt+3` or `enter` on it returns to the conversation in front, or opens a new chat when none is open; `tab` steps over it." +--- diff --git a/docs/changes/unreleased/1429-manager-column.md b/docs/changes/unreleased/1429-manager-column.md new file mode 100644 index 0000000000..526beb4d58 --- /dev/null +++ b/docs/changes/unreleased/1429-manager-column.md @@ -0,0 +1,8 @@ +--- +kind: fixed +title: with the manager in front the right column is the traffic +pr: 1429 +surface: [chat, docs] +invalidates: + - "With the manager in front, a task column remembered open (or brought back with `ctrl+g`) took the right-hand column and folded the Traffic to its edge, even with no tasks in it. The right-hand column is now always the Traffic there and the task column is not drawn or reserved. When the manager has live tasks the header reads `Traffic · Tasks 2`, and a press on Tasks or `ctrl+g` lays them in the same column and back. Other conversations' task columns are unchanged." +--- diff --git a/docs/changes/unreleased/1429-one-top-bar.md b/docs/changes/unreleased/1429-one-top-bar.md new file mode 100644 index 0000000000..de12482f92 --- /dev/null +++ b/docs/changes/unreleased/1429-one-top-bar.md @@ -0,0 +1,8 @@ +--- +kind: changed +title: the places bar sits where the chat strip does +pr: 1429 +surface: [chat, docs] +invalidates: + - "The places bar started its first word one column left of the chat strip's, with one cell between chips where the strip has two, and drew the place you are in on the ground the strip gives a tab that is not in front. It now matches the strip: first word at column 3, two cells between chips, and the current place on the strip's front-tab ground. The bar keeps all five words down to 42 columns, giving up the air a cell at a time before it gives up a word." +--- diff --git a/docs/changes/unreleased/1429-strip-order.md b/docs/changes/unreleased/1429-strip-order.md new file mode 100644 index 0000000000..0a738607d4 --- /dev/null +++ b/docs/changes/unreleased/1429-strip-order.md @@ -0,0 +1,8 @@ +--- +kind: changed +title: the tab strip reads Home, the team chip, the manager, then the tabs +pr: 1429 +surface: [chat, docs] +invalidates: + - "The team chip led the tab strip, before Home (`● harbor ▾ Home ◆ Manager tabs…`). Home is first and the chip sits right before the tabs it filters: `Home ● harbor ▾ ◆ Manager tabs… + ▦ All`. As the row narrows Home goes first, then the chip, never the tab in front." +--- diff --git a/docs/changes/unreleased/1429-team-manager.md b/docs/changes/unreleased/1429-team-manager.md new file mode 100644 index 0000000000..f668802b54 --- /dev/null +++ b/docs/changes/unreleased/1429-team-manager.md @@ -0,0 +1,21 @@ +--- +kind: added +title: a team can have a manager chat, with a Traffic rail of who told whom +pr: 1429 +surface: [chat, engine, docs] +invalidates: + - "A team was a grouping and nothing more. It can have one manager conversation (`+ Manager` on the strip, or Make this team's manager in the switcher), which runs the team through team_status, team_read, team_send, team_stop and team_start; members reply with team_post." + - "A conversation started by a tool came to the front. A member the manager starts with team_start opens behind the conversation in front, as a tab named @handle, and takes its first turn on its own; nothing a manager does moves the person's focus." + - "A brief handed to a new conversation arrived as the person's first message. The manager's brief reaches the member through the team's Traffic, marked as the manager's, and its page draws it as a quoted card headed by the manager." + - "The right-hand column was the task column's alone. While a team's manager is in front the Traffic rail holds it and the task column folds to its edge; alt+l shows or hides the Traffic and alt+m goes to the manager." + - "A shown team drew every member on the tab strip, open or not, while the conversations view kept only the open ones. Both are now what is open in this window, narrowed by the team; the view's title says `open in this window · in test` and, while the team has members not open here, offers `2 more in test · Open them` (r), which resumes them behind the conversation in front." + - "A member's handle was made from its title's words and never changed, which made @review of a security review. The title model now chooses one word naming the subject, once, when the title is made; a handle a person or the manager gave is kept, and each change is written to the team's Traffic as `@review is now @security`." + - "An @handle or a team's name in a chat was plain text. Each handle of a member of the conversation's teams, and a team's name written as a team, is a link: a ground under the pointer, the member's title on the hint line, and a press opens or resumes that member, or shows the team." + - "Over --host the teams list was the laptop's own. It is the engine machine's now, read and written over three wire methods (Teams.Read, Teams.Update, Teams.Traffic), so a manager and its Traffic work over --host; against an engine without them teams and the manager are off rather than kept on the laptop." +--- + +The UI and the session meet only through internal/teams (teams.json and each +team's traffic.jsonl), which the UI reaches through a seam: locally the +profile, over --host the engine's profile over the wire. A quiet window with a +managed team costs one stat per file a second (over --host one small round +trip per file), backing off to one in five seconds, and draws no frame. diff --git a/docs/changes/unreleased/1429-traffic-jump.md b/docs/changes/unreleased/1429-traffic-jump.md new file mode 100644 index 0000000000..86542148fa --- /dev/null +++ b/docs/changes/unreleased/1429-traffic-jump.md @@ -0,0 +1,8 @@ +--- +kind: added +title: a handle on the Traffic opens the member at the message +pr: 1429 +surface: [chat, docs] +invalidates: + - "A handle on the Traffic rail or on a thread card opened that member's conversation where it was. It now opens it scrolled to the message the row is about, lifted for a moment, without taking the focus: a thread header's handle lands at the directive as the member was told it, an answer's handle at the member's own post, and pressing a message's words on the rail also brings its thread card in the manager's conversation into view. A message from before the conversation's history opens it at the bottom and the hint line says `that message is older than this chat's history`. `team_post` now answers with its own number (` as #N`)." +--- diff --git a/docs/changes/unreleased/1429-traffic-threads.md b/docs/changes/unreleased/1429-traffic-threads.md new file mode 100644 index 0000000000..ec8519881d --- /dev/null +++ b/docs/changes/unreleased/1429-traffic-threads.md @@ -0,0 +1,16 @@ +--- +kind: changed +title: team Traffic is threaded, the newest thread at the top, and a manager's question keeps its answers +pr: 1429 +surface: [chat, engine, docs] +invalidates: + - "A message to several members was one Traffic entry per member. team_send takes several handles and writes one entry (to several, with handles); each named member is still told once." + - "Traffic entries stood alone. An entry carries answers, the id of the entry it answers: a member's reply to the manager answers the last message the manager sent it, or the one it names with team_post's thread, and its finished, failed, asking and wake events answer the same one. Members are told each line's number, `◆ directive from manager #42: …`, and team_send's answer carries it." + - "The Traffic rail was a log, newest at the bottom, one row per entry, wakes and finishings included. It is threads, the newest activity at the top: a header, the message on its own line, and one tree row per member, with wakes shown as working…, finishing as ✓, failure as ✗ and asking in the needs-you amber. Handles on it are links; a message's words expand on a press." + - "A manager's team_send row was a one-line tool call. It reads `team_send ◆ to @a @b · do` with the message quoted under it and each answer attached under that as it arrives, and a turn with one in it is not folded into a work chip. The member's chat hangs its own answers under the manager's card, and in the manager's chat a delivery note whose answers are already under their card is one dim line." +--- + +The thread link is one JSON field on the entry, so it crosses --host with the +entry, and entries from before it read as threads of their own. The rail and +the chat cards draw from the Traffic cache the rail's clock keeps, keyed by +that cache's version; no frame reads the log. diff --git a/docs/changes/unreleased/1500-traffic-age-and-jump.md b/docs/changes/unreleased/1500-traffic-age-and-jump.md new file mode 100644 index 0000000000..f58937dd34 --- /dev/null +++ b/docs/changes/unreleased/1500-traffic-age-and-jump.md @@ -0,0 +1,8 @@ +--- +kind: added +title: a Traffic row shows how long ago it happened, and a press opens that message +pr: 1500 +surface: [chat, docs] +invalidates: + - "A Traffic row had no age on it (it was on the hint line only) and only a press on a handle did anything. Each row now ends with a dim age, and a press anywhere on the row opens the conversation the message belongs to, at that message." +--- diff --git a/docs/design/conversations-and-teams/DESIGN.md b/docs/design/conversations-and-teams/DESIGN.md new file mode 100644 index 0000000000..5247b5df63 --- /dev/null +++ b/docs/design/conversations-and-teams/DESIGN.md @@ -0,0 +1,1510 @@ +# Conversations and teams: every open conversation at once, grouped, and one day managed + +Written 2026-09-24 against draft PR #1429 (`feat/conversation-overview`, head `c520c363c`). +Shaped with the owner over 2026-09-23 and 2026-09-24. Sections 1 to 5 describe what is +built, the manager's first version included; section 7 is what is deliberately left for +later. + +## The problem, in the owner's framing + +A person running codeaf the way it is meant to be run has many conversations going at once: +several agents working, one waiting on an answer, two finished an hour ago. The tab strip +says which conversations exist and nothing about what they are doing. The switcher says what +they were called. Nothing lets a person see the swarm working, move between it quickly, or +group it by the work it belongs to. And nothing coordinates it: the person is every +conversation's manager, carrying facts from one chat to the next by hand. + +## 1. The wall: every open conversation, live + +A full-frame grid of tiles, one per conversation open in this window, each drawing the live +tail of its transcript. + +**What it shows is what is open in this window** (ruled 2026-09-24). The wall and the tab +strip are the conversations this window has open, narrowed by a team when one is shown; they +are not a view of the team. The title says so: `Conversations · open in this window`, and +`· in test` while a team is shown, with `1 open` on the right. A shown team's members that +this window does not have open are neither tiles nor tabs. While there are any, the title +carries one quiet word button, `2 more in test · Open them` (key `r`, hint `Resume the 2 +not open here · r`), which resumes them behind +the conversation in front, on the door line, off the loop, so they arrive as tiles and tabs +without moving the front or the focus. When every member is open there is no mark at all. +The Teams row counts open members; its hint says the team's size (`test · 1 open here · 3 +members`). The first build drew every member on the strip while the wall kept only the open +ones, and the owner's screen read `test 1` over three tabs. A team's whole membership, open +or not, belongs to the teams page on home (section 7). + +**Doors in.** `alt+v`, `/wall`, the dock under the input box, and `▦ All` beside the tab +strip's `+`. The dock is a one-row map of every open conversation coloured by state, led +by `▦ All`, the strip's own door spelled the same way and drawn as one button (one hover +ground over the glyph and the word). It used to lead with a dim `chats`, which is the +nav's word for the way back to the conversations: one word on one frame led two places, +so the dock now says what it opens. A click on a square switches to that conversation +without opening the wall. A click anywhere on `▦ All` opens the wall. The +pointer explains the piece it rests on: `Go to · running · click` (or `waiting on +you`, or `idle`), `<title> · you are here` on the square in front, and `The grid of your +open tabs, and your teams · alt+v` on both `▦ All` doors: with no team yet it is the only +door on the strip that leads to making one. The word `All` is the first thing dropped when +the row is too narrow. The squares stay, then fewer of them, then the dock is not drawn. Amber is only +the square that is waiting on you. The dock is laid out last on the keys row: the project +holds the row's right end (dev's foot since 2026-09-22) with the low-credit line beside it, +and the dock takes what the keys and they leave, ending a gap short of them. + +**A tile, in reading order.** Title, then state, then now, then history: + +- the top border carries the team dots and the title, the brightest thing in the tile; +- a meta line: `⠿ running bash · 2m`, `? waiting on you · 3m`, `updated 14m ago`, or + `seen 4m ago` for a snapshot this window cannot refresh; +- one blank row, then the body, drawn with the chat's own pieces (the person's words under + `›`, replies through the transcript's markdown and chroma, tool calls on the rail); +- the body fades with age through the depth-fade ladder (`depthfade.go`): the newest rows + keep full ink, older rows step down, so a wall of six conversations is not six walls + asking to be read at once; +- the bottom border carries the activity sparkline at rest and, on hover or focus, a row of + word buttons: `Open ↵ Select ␣ Teams m Close x`. + +**The state ladder, one step per claim.** Rest is a dim rounded border. Hover lifts the whole +tile onto the hover ground. Keyboard focus is weight (a heavy border), never colour. +Selected is the selected ground and a `☑`. Needs-you is an amber border, the only amber on +the screen. + +**Clicks are the familiar ones.** One click on a tile opens it (Mission Control, browser tab +overviews). Selection is an explicit mode entered from a tile's Select button; in it a click +toggles. The wheel scrolls the view by one tile row per notch, clamped, and never moves focus +unless focus would leave the screen. + +**Discovery.** Every control explains itself in the toolbar while hovered +(`Add this conversation to teams · m`). The sentence outranks the buttons: while it shows, +`Columns` and then the acts on the right step aside until it is whole (never the button under +the pointer, never `Help`), and come back when the pointer leaves. Before, it was cut between +`Back` and the buttons and read `Resume the …` at 80 columns and lost its key at 110. `?` opens a sheet of everything the page can do, +every row clickable. Next-needing-you is `n`. + +**Sizes.** A tile is at least 44 columns and 12 rows; past that the grid scrolls rather than +squeezes. Columns follow width (one under about 100, up to four). + +**Motion.** Tiles appear row by row when the wall opens (45ms apart, 135ms in all); opening +a tile switches at once and the new conversation grows out of the tile's rectangle over +about 100ms. Both are off on the linear tier, on ASCII and over a remote link, and any key +finishes them. Hover is instant. + +**The laws it keeps.** The frame never reads disk: tails are read off the loop on a stir or +a tick and cached against a version; the painter draws the cache (`framedisk_law_test.go`). +Tab order never moves: the wall's order is the strip's. Closing a tile closes a view and +never ends work. The emptiness law: idle draws no mark. Over a shared engine handle only the +front conversation is live; the other tiles are snapshots and say so. + +## 2. Teams: groups a conversation can belong to many of + +**The word.** Team. "Space" read as a place with one occupant; "Folder" is already the word +for the directory a conversation works in (`/folder`, `choosing-a-folder.md`) and would have +meant two things on one screen; "Team" fits the manager that is coming. + +**The model** (`teams.json`, version 2, resolved through `config.ProfilePath`): + +- a team has a stable random `id`, separate from its `name`; everything refers to a team by + id, so a rename or a reorder never retargets anything; +- `members` are conversations, and a conversation may be in any number of teams, because + work belongs to several contexts at once; +- `parent` makes a tree: one parent per team, loops refused, deleting a team moves its + children up; one parent keeps a single chain of authority for managers; +- `manager` is reserved, a member's conversation key; +- unknown fields survive a load and a save, so later features extend the file safely; +- an empty profile directory is the ordinary launch and resolves to the process's own + profile (`emptyprofile_test.go`); the first build read it as "keep in memory", and no team + outlived the window it was made in. + +**Colour.** Generated, not picked from a fixed list. OKLCH, farthest-point assignment (each new +team takes the hue farthest from every hue in use), with bands of ±25° kept clear around every +hue that already means something (amber, running green, error red, the accent blue), measured +from the live ramp. Two lightness tiers alternate after the sixth team. Stored as a hue in +degrees; rendered truecolor, nearest xterm-256, or the team's initial where there is no colour. + +**Naming, once, from what is inside.** The shared project folder's name when there is one; +otherwise one cheap background call over the titles (`Agent.NameTeam`, the conversation-title +path); a curated word while it runs. Typing wins. A team never renames itself: people find +things by the name they remember. + +**Where teams show.** Dots before a tile's title; a segmented Teams row on the wall; when a +team is shown, a `● name ▾` chip on the tab strip and the rule under it in the team's +hue. The strip reads `● name ▾ ◆ Manager tabs… + ▦ All`: the chip filters the tabs so it +stands first, right before them, and the manager's place follows it; as the row narrows the +chip goes, never the tab in front. The strip's `home` piece is gone: home is the first word of +the nav on the row above (the top nav, below). Showing a team narrows the strip to its members open in this window, plus the tab in +front (section 1). The chip is the switcher: teams, All, add or remove this conversation, new team, team +settings. New conversations started while a team is shown join it. + +**The way back from the places.** The places bar reads `home teams chats sessions spend +settings` (the owner's order, ruled 2026-09-24; `sessions` is the tasks place's word), then +standing, memory and search off the bar. The list is data (`placeOrder` in `pages.go`), and +the digits follow it: teams `alt+2`, chats `alt+3`, sessions `alt+4`, spend `alt+5`, settings +`alt+6`, standing `alt+7`, memory `alt+8`, search `alt+9`. `chats` is not a room: a click, its digit or `enter` on it returns to the conversation +in front, or opens a new chat when none is open. It is the lit word inside a conversation, `tab` +steps over it, and `alt+k` stays the switcher that chooses a conversation. Its hint says +`every conversation, one at a time`, and `▦ All` says `The grid of your open tabs`: the place +and the grid are two doors, one row apart, and they say so. + +**The top nav (ruled 2026-09-24, replacing "one top bar"; the strip ruled 2026-09-25).** +The places sit on the wordmark's row on every page, and that row never moves. The strip +is a chat's own row. On a place the head is three rows: the nav, the rule, a blank. In a +chat it is four: the nav, the strip, the rule, a blank. + +``` + >● codeaf home teams chats sessions spend settings 3 moving · $1.20 thu 10:31pm + ● harbor ▾ ◆ Manager × Refactor the rail… × openrouter price scrape × + ▦ All +────────────────────────────────────────────────────────────────────────────────────────── +``` + +- Row 0 (`navRow`, topnav.go): one cell of inset, the wordmark, two cells of air, then the place + words as buttons that touch (each ` word ` with a one-cell pad either side, so two blank cells + between two words), at least two cells, the pulse, one cell of inset. The gaps never change + with the width. The current place is lit in the accent (`chats` in a conversation, on the wall + and on the work tab); the rest are muted; on a no-colour terminal the lit word wears brackets + in its pads. The hover ground covers the pads, the press target is exactly that ground, and a + terminal that cannot show a ground puts `·` in the leading pad. The hint line says + `alt+N word · what it opens`, read off each place's `about()`. +- Row 1 (`tabStripRow`): the chat strip, only while a conversation is in front (a chat, a + room inside one, the grid, the work tab). On a place this row is the rule, and a click + there is the page's. There is no unlit strip and no place-only press path. The strip + keeps its own narrowing. +- The strip's spacing (2026-09-25): every piece carries its own one-cell pad and ONE blank cell + separates any two pieces (chip and first tab, tab and tab, tab and `+`, `+` and `▦ All`, the + left arrow and what stands before it); the first ground is at column 2 with or without a + chip. A tab is symmetric: inset, status cell and pad before the name, pad, `×` cell and inset + after it (` ◐ name × `); the close target is the `×` and its inset, two cells, where it was + three with a blank of its own that made every tab one cell wider on the right. The reserved + status and `×` cells stay (no re-pack when work starts or the pointer arrives). Names are cut + at a word where one is near. The names shrink, down to 16 cells a tab, before the strip + scrolls; a scrolling strip draws both arrows, the one with nowhere to go dim and inert. + `▦ All` is always spelled with its word (no glyph-alone rung between 60 and 80 columns). + Every piece says what it does on the hint line: a tab says its dock square's sentence, `×` + `Close this tab · the work keeps running`, `+` `New chat · ctrl+t`, the arrows which way. + Where colour cannot show a ground the pointer's tab wears `·` in its leading inset, the + nav's rule. +- The ladder on row 0, in the owner's order: the clock (and `on <machine>` over `--host`), then + `moving`, then the words of `2 want you` shorten to `2 ?` (same count, same amber, the mark + a waiting tab wears), then the allowance, then the trailing places fold one at a time into + `more ▾`, then the day's figure. The needs-you count never folds: it was allowed to for one + wave, and at 80 columns a conversation's top line then carried no count of what was waiting + on the person, the one fact a glance at that row is for. At 80 the row is all six places + and `2 ? · $1.20 / $20`. The wordmark, the lit place, the + bar cursor's word and a counted place never fold. `more ▾` opens a small menu of exactly the + folded places with their keys (navmore.go): hover ground, enter or click goes, esc or a press + off it closes, and focus never moves anywhere else. +- Measured on Spark after the change, with a conversation of three tabs in team harbor: at 80 + columns all six places fit beside `$1.20 / $20`; at 60 `spend` and `settings` fold into + `more ▾` beside `$1.20`; at 110 the counts and the money fit and the clock does not; at 160 + everything fits. The scroll frame's allocation count fell from 229 to 210 under the 230 + ceiling, because the row is memoised whole (`navMemo`), pulse included. +- `TestTheHeadIsTheSameFourRowsOnEveryPage`, `TestOneTopNavOnAChatAndOnAPlace` and + `TestTheTopLineGivesThingsUpInTheOwnersOrder` pin the rows, the cells and the order. + +## 3. Organize: one button, a proposal, never a silent change + +On the All view, `✦ Organize` (key `o`), with a quiet count when five or more conversations +are in no team. It opens a card of proposals, each with a checkbox: new teams, and additions +to existing teams. Proposals come from shared project folders first (exact, free), then one +cheap model call for themes across folders (`Agent.ProposeTeams`, 10s timeout). Apply saves +once and offers Undo for six seconds. Running it again is the refresh: it only ever proposes +new teams and additions, and never renames, removes or moves what the person made. It never +runs by itself. + +## 4. What was argued and settled + +| Proposal | Ruling | Why | +|---|---|---| +| One team per conversation (Arc) | Rejected | Work belongs to several contexts; managers need that | +| "Folder" as the word | Rejected | Collides with the working-directory folder | +| AI that reorganizes on its own, or a typed "organize like…" box | Rejected | Reshuffling breaks the positions people learned; the chat is already the place to type | +| Teams that rename themselves as they grow | Rejected | Stable names are how people find things | +| Glyph controls in tile corners | Replaced by word buttons on hover | Nobody could tell what `●+` did | +| The wall's door only at the top | Added the dock under the input | Where the hands are | + +## 5. The manager (ruled and built 2026-09-24) + +**The goal.** Today the person is every team's manager. The manager chat takes the +coordination load: one place to talk to a whole team, run by something that knows what every +member is doing, and a place where members coordinate with each other in the open. + +**It is a special conversation.** It is recorded in the team's `manager` field, one per team, +and removing it returns it to an ordinary chat with its history. What makes it special: + +- it is the team's first tab, pinned at the left like a browser's pinned tab (`◆ Manager`), + and the pinned first tile on the wall (`◆ Manager · <title>`); until one exists, that tab is + a `+ Manager` placeholder, and nothing costs anything; +- its layout is split: the person's conversation with the manager on the left, the column + on the right open on its **Traffic** (below, **One side column**). Whatever the person types + goes to the manager, always, and the composer says so (`to ◆ manager`, on the box's rule + once there is text; on the teams page `to ◆ harbor manager`). Both read the team's name when + they are drawn, so a rename does not leave the old name in the box. Traffic is drawn as threads (below, **Traffic is threaded**); +- each turn it carries a small team digest (members, handles, states, questions waiting, + files touched, recent traffic), never whole transcripts; +- its messages reach members marked `◆ from manager`, never as if the person had typed them; +- nothing it does moves the person's focus: a member it starts opens behind the conversation + in front, as a tab named `@handle`. With the team's auto-wake on it takes its first turn on + its own (the session sees itself started and wakes), reading the brief as the manager's. + With auto-wake off the member is still opened and the brief still waits for its first turn, + but no turn is started; the Traffic says `opened @handle; this team's auto-wake is off, so + no turn was started. It reads the brief when it next runs.` + +**Why not one stream of chat bubbles.** Members do not all read everything; each receives only +what is addressed to it. A shared stream would look like a group chat and teach the person +that every member saw what they typed. The split puts the person's conversation where it is +unambiguous and makes member traffic a log of who told whom. + +**Authority.** The person's words in a member's own chat, then the manager's directives, then +other members' messages. A directive never overrides the person; a conflict comes to them. + +**Tools.** The manager has every ordinary tool under the same approval rules as any chat: a +rule against editing could not be enforced once it has bash, and a manager that cannot run a +script to fetch data is crippled. What replaces the rule is visibility: its edits show in +Traffic like anyone's, and its brief tells it to hand real work to members. Team tools are +split read from write, because the approval gate keys on tool names: + +| Tool | Who | Default | +|---|---|---| +| `team_status`, `team_read` | manager | allow | +| `team_send` (to a handle or everyone; note or directive) | manager | allow | +| `team_stop` (ends a member's current turn, logged in Traffic) | manager | allow | +| `team_start` (a new member chat with a brief and handle) | manager | ask | +| `team_post` (to the room, a handle, or the manager) | members | allow | +| `team_raise` (a conflict, to the lowest manager above every party; 8.9) | members and managers | allow | + +`team_stop` exists because a message only lands at a turn boundary: a member stuck in a long +tool call reads nothing until it returns, and a directive is advice a model may misread. Stop +is the person's own Stop: it ends the current turn, deletes nothing, and leaves background +tasks and jobs running. + +**What it may not do.** Approve members' permission prompts. Those are the person's safety +gate, and a manager that could answer them would make every approval rule meaningless. If +that is ever wanted, it is a separate, explicit per-team setting. + +**Handles.** Titles are too long to address, so each member gets a handle: ONE lowercase word +naming what the conversation is about (`@security`, `@milestones`, `@gravity`). A word list +cannot do this well; measured on the owner's team it made `@review`, `@reviewing` and +`@session` of "santosh dev2 branch code complexity & security review", "CodeAF repo issue +tags & milestones" and "quantum gravity research updates / session monitor". So: + +- the word list (`teams.DeriveHandle`) is the instant guess, made when the member first has + a title, so it is addressable at once; +- the title model chooses the word when the conversation's title is made + (`internal/session`'s `handlepick.go`): one call on the title role, a few tokens, asking + for the subject and two alternates. A timeout or a network failure is asked once more + after a short wait; a refusal is not, and the word-list guess stands. Still one question + per title. Over `--host` it runs on the engine, which owns the model and the store; +- `teams.File.ChooseHandle` writes it under the store's lock: the first free word, else the + first with a title word in front (`@api-security`), numbered only when nothing else fits; +- `Member.HandleBy` records who chose (`words`, `model`, `typed`); a handle a person or the + manager gave (`team_start`'s) is never replaced, and a model's word is not chosen again; +- one time, every existing guessed handle is chosen again the same way on its conversation's + next turn, and every rename is a Traffic event from `system` to `everyone`, + `@review is now @security`, told to the manager and every member at their next step; the + manager's role note is rebuilt when the teams file moves, so it shows the new handle. + +**Every team reference in a chat is a door.** An `@handle` of a member of any team the +conversation is in, and a team's name written as a team (`team test`, `the test team`, +`"test"`), are links in the model's prose, the surface's notes, a team's quoted cards (the +brief included) and a team tool's call rows (`team_send @security`). They go through the +task link's own pass (`markdown.go`, `teamlink.go`): columns recorded on the row, the press +resolved before the row's own answer, the hover held as (block, ordinal) with team +references numbered from their own offset. The hover is a ground; the hint line says +`Open @security · santosh dev2 branch… · click` (`Resume` when it is not open here). A press +opens the member through the strip's door, resuming it first; a team's name opens the teams +page with that team selected (the rail's cursor on its row, the pane showing it, the keyboard +left on the row). A closed team is selected inside `Closed`, and that fold is opened. The +hint is `Open harbor on the teams page · click`. Over `--host` against an engine without the +teams doors (`teamsOff`) the page cannot open, so the press still opens the wall on that team +and the hint says the conversations view. They are resolved from memory only; an `@word` that is no member's handle stays +text. + +**Where it lives.** The manager is an ordinary session file. Traffic is +`<profile>/teams/<id>/traffic.jsonl`, append-only, rotated at 4 MB with one old file kept; +the team id is its channel. The store is `internal/teams`, shared by the UI and the tools: +every write is a read-modify-write under a file lock (`Update`), so neither side overwrites +what the other wrote. + +**Whose profile.** The store is the one in the profile of the machine the SESSION runs on, +because that is where the team tools write it. The UI never opens it directly: it asks +through a seam (`tui3.TeamsSeam`: `Load`, `ReadSince`, `Update`, `Traffic`). Locally the +seam wraps `internal/teams` at the profile directory. Over `--host` the door hands a seam +that asks the engine over three wire methods, answered from the engine's own profile +(`internal/remote`'s `wire_teams.go`): + +- `Teams.Read(stamp)` answers the file, or `same` when it is still at the stamp the window + holds. A stamp is one stat (size and modification time; every write moves the time + forward), so an unchanged answer is a few bytes. +- `Teams.Update(base, teams)` writes the whole list only while the file is still at `base` + (`teams.ChangeIf`), and answers `stale` otherwise; the window reads again, makes its change + again on the fresh list, and retries up to three times. A manager or handle the far session + wrote in between is kept. +- `Teams.Traffic(team, after, limit)` is one log after a cursor, a page at most. The engine + stats the log before it reads (`teams.Watch`), so a quiet log costs a stat and an empty + answer. + +Every seam call that can wait is made off the update loop: an edit changes what the window +holds at once and is queued, and the queue is written after the message on the door line; the +Traffic clock's turn reads through the seam beside it. The one call on the loop is `Load`, at +an opening, which must not block: locally one small file, over `--host` what is held (the +first read is asked off the loop). The welcome's `Teams` flag says an engine has the doors; an +engine without it gets no seam, and the window turns teams and the manager off with the line +it has always said rather than reading the laptop's file, which the far session never sees. + +**One side column (ruled and built 2026-09-24).** The right of every conversation is one +component (`tui3/sidecol.go`, `sidetraffic.go`), replacing the task column, the Traffic rail, +the bordered Traffic card under 84 columns, and the `Traffic · Tasks 2` special case between +them. + +- **The header is two words**, `Tasks 14 · Traffic 3 new`, with the hide key (`alt+l`, + `ctrl+g` its older name) at the right. A chat in no team has only `Tasks`. The word in front + is bold ink and the other dim; each is a door with a hover ground and a hint; the other word + keeps its count and says `N new` for Traffic that arrived behind it. A zero is dim. +- **The view defaults by kind of chat**: Traffic in a manager's chat, Tasks in a member's and + everywhere else, and the person's choice is remembered per kind for the session. `←` `→` + switch words while the column holds the keyboard (`alt+t`); nothing here takes the focus. +- **The needs-you band** is under the header, from both sources: a member's pending question + (its latest asking event, until anything later from it, from the person, or a wake), a + packet put to the person, and a task whose next step is the person's, all in the needs-you + amber with their own mark (`?` for a question); then a failure this window watched happen + and the person has not opened, its `✕` in ordinary ink. At most three rows and `+N more` (a + fourth item is drawn rather than counted); a rule under it; nothing at all when empty. An + item in the band is not drawn again below it; opening a failure acks it into Done. +- **Tasks** are grouped by state, newest first in each: Running always open, Queued, Waiting + and Done folded to `Done 7 ▸` until pressed, and remembered open for the session. One line a + task: its state glyph, its name cut with `…`, its time in muted ink at the right (dropped + before it would cut a name that fits). What used to hang under a row (what it is doing, + `waits:`, merge word, cost, branch, the reason for a your-call) is the hint line's. The + family forest, its per-row disclosure and `view more` are gone; the margin under the list + (`+ /task`, standing, jobs, `ctrl+. earlier`) and a run's plan rows stay. +- **Traffic in a manager's chat is work**: one row per thread (`teams.Threads`), and every row + reads `from → to words`. The manager is `◆`, several recipients are `@scrape +2`, and the + words follow, and how long ago at the right (`◆ → @scrape +2 Please provide a st… ▸ 2m`). + The age is `now`, `2m`, `3h`, `1d`, the same ladder a task row and a home session use + (`sinceAt`), dim, on every kind of row: a thread, a `↳` reply, a band question, General, + and a member's own lines. It moves when the minute in the row cache moves, and nowhere + else. The state its answers leave it in and its message count give way to the words when + the column is narrow; the hint says them. The arrow and the names keep their cells, then + the age, and a narrow column cuts only the words, at a word, with `…`. A band row is + `? @model → ◆ keep the old schema? 3m`, amber on the question and dim on the age, and a + task row in the band is still cut at a clause, never leaving ` · …`. `▸` lays the replies + open as `↳ @model → ◆ ✓ done, 3 files changed 4m` (events folded into the member's line, + the age on the row), and every unthreaded line under one `General` thread, its open lines + in the same `from → to` with the same age. `▸` and `▾` stay the expand door. The rest of + the row is the jump. A thin `new` line marks what arrived since the Traffic was last in + front and holds still while it is read. A handle opens its member at the message. A press + anywhere else on the row opens the conversation the message belongs to, at that message, + lifted the way a jump already lifts one: a message the sender wrote opens the sender's + chat (`◆ → all` opens the manager at the directive, `you → ◆` in a member's chat scrolls + that chat), and a message to the person opens the manager's chat. Already in front, it + scrolls in place. It does not take the keyboard and it does not open a new window. The + hint is `Open ◆'s message · 2m ago · click`. The hover ground is the whole row, padding + included. **In a member's chat** it is the messages to or from that member, or to + everyone, one line each, and that member is `you` (`◆ → you 2m`, `you → ◆ now`, + `you → @gravity 3h`). +- **Geometry.** The column is a quarter of the frame, 28 to 40 columns (30 at 120), from 100 + columns up while the conversation keeps 56; `alt+w` adds 16 from 120 up. It is the same in + both views and every kind of chat, so switching, folding, the band and new rows never move + the conversation or the header. Under 100 columns there is no column and no edge; `alt+l` or + `alt+t` lay it over the body. Put away, it is an edge carrying the running or asking mark and, + in a team chat, the count of new Traffic. +- **The frame reads memory**: tasks are the roster's nodes, Traffic the cache the Traffic clock + keeps, packets the teams page's last read; the Traffic rows and the band's asks are cached on + the log's tail, width, pointer, minute and what is laid open. + +**Where it departs, and why.** The owner's sketch showed the band only for needs-you; a +failure is in it too, in ink, because a failure nobody opened was the one thing the old column +kept at the top and dropping it would have hidden it under a folded `Done`. The column's width +was the Traffic's three tenths and is a quarter now, because it is every chat's column and +three tenths cost the conversation up to fourteen columns against the old task column; at 110 +columns a Traffic row's title is short, and its hint carries the rest. The margin under the +task list stays, so a Tasks view with no tasks still shows `+ /task`. + +**Known gaps.** Packets reach the band only as fresh as the teams page's last read of them. +Plan rows are spliced only into the Tasks view. + +**Traffic is threaded (ruled and built 2026-09-24).** Measured on the owner's screen, one +question to three members was twelve rows at the bottom of an empty column: the question three +times, three wakes, three replies cut to two words, the manager's wake and two finishings, with +nothing saying which reply answered which question. So: + +- **One entry per message.** `team_send` takes several handles (`to: "@agent @checking"`) and + writes ONE entry, `to: several` with `handles`, or `to: everyone`; delivery asks + `teams.Entry.Addressed`, so each named member is told once and nobody else is. +- **An answer names what it answers.** `teams.Entry.Answers` is the id of the entry a line + answers. A member is told each line's number (`◆ directive from manager #42: …`) and + remembers the last line its manager sent it; its next `team_post` to the manager answers that + line unless it names another with `thread`, and the events its turn raises (finished, failed, + asking, the wake that started it, a failure to wake it) answer the same line. `team_send`'s + answer carries the number too. Entries written before this answer nothing and read as + threads of their own; the field travels in the entry's JSON, so `--host` needs nothing new. +- **The rail was threads, the newest activity at the top** (superseded by **One side + column** above, where a thread is one row), straight under the header with no + space above; inside a thread everything is in the order it happened. A thread is a header + (`◆ manager → @agent @checking @review do 2m`, `+2` for handles that do not fit, never the + tag), the message on its own dim line, and the answers as a tree (`├ @checking ✓ Status + update: … 1m`, `└ @review working…`). Wakes are not rows: a woken member reads `working…` + until it answers; a finishing is the `✓` on its answer or its own `✓ finished` line, a failure + `✗`, and a member asking the person is the one line in the needs-you amber. Stops, starts, + handle changes and unthreaded entries stay one line each. +- **Delegation's entries are threads too** (section 8). A ruling (`teams.IsRuling`) heads its + own thread as `◆ manager ruling → @web` (or `you ruling`, the one entry of the person's the + rail draws), the ruling's words under it with the conflict's packet named in their hint; a + start that made a sub-team reads `◆ manager started @api to run backend`; a member's + clarifying question is a header tagged `asks`, and the manager's answer (a `KindAnswer`, + whose `Reply` stands in for `Answers`) is a line of the tree under it; a packet raised, + decided or answered (`codeaf answered @web: JSON`), a closing and a reopening are one line + each, like an event. `team_send`'s directive to everyone, when some members report to + another team's manager, is one entry to the several who report here. The teams page's + hosted manager draws this same rail and takes the same jump. +- **Handles are links there too**, inked and grounded as in the chat, hint `Open @x at this + message · title · click` (`Resume` when not open here), a press opening or resuming the member + scrolled to the message: a header's handle at the directive as delivered, an answer's handle at + the member's own post. Every place an entry sits in a transcript carries its number (a + delivered line's ` #N`, `team_send`'s `(#N)`, `team_post`'s ` as #N`), and the surface finds + the newest entry carrying it, scrolls it a third of the way down the view and lifts it for + 1.6 s without taking the focus. A jump waits for a conversation still opening, for up to ten + seconds; a number in no entry opens at the bottom with `that message is older than this + chat's history` in the hint line. A message's words are a door: hover puts them whole in the + hint line, a press lays them out under the row and brings its thread card in the manager's + conversation into view, a second folds them. Rows are cached on the entries, width, pointer, minute and what is laid out. +- **A manager's steps are captioned as team work.** The fold over a manager's turn read + `▾ team_send 1 call … 1 call`, the tool's own name and the count twice; the team tools now + gloss like the others: `messaging @scrape @model` (past, `messaged`), `posting to manager`, + `starting @lexer`, `stopping @web`, `reading @web`, `checking the team`, and a run of sends + `sending 3 messages`. The tool row under it keeps the tool's name, as every tool row does. +- **The manager's chat has the thread where it asked.** A `team_send` row reads + `team_send ◆ to @agent @checking @review · do`, the words quoted under it, and each member's + answer attached under that in muted ink as the Traffic cache brings it, one line each; the + same press and hover as the rail. A turn with a `team_send` in it is not folded into a work + chip, because its answers arrive after it ends. +- **The member's chat mirrors it.** The manager's line is the quoted card it always was, and the + member's own answers to it hang under it the same way. +- **No answer is drawn twice.** A member's reply also reaches the manager's model as a delivery + note, which replays as a team card. In the manager's chat an answer already under its + question's card is left out of that card, and a card left with nothing is one dim line, + `· @checking @review answered · in the thread above`. The model's transcript is unchanged; only + the drawing folds. A delivery inside a wake note is read as one too, so a woken member's + directive draws as the manager's card rather than a dim line. + +**Traffic is the only channel between the UI and the session.** A conversation's identity in +a team is its transcript path, the same key the tab strip uses. The session side writes +messages, stops and starts as Traffic entries and delivers what is addressed to it before +every model request, with a cursor kept in its session folder so nothing arrives twice and a +new member is not handed old history. The UI tails the same log off the loop: it draws the +rail, and it carries out stops and starts for the conversations its window holds, once per +entry. Neither package calls the other for team features. + +**Team traffic wakes (built 2026-09-24).** A manager that hands out work and then waits for +the person to type again is not running a team, so the lines that ask for an answer start one: + +- A **directive** (`team_send` kind `directive`) to a member's handle or to everyone starts + each idle member's turn. A **note** wakes nobody and is read at the member's next turn. A + member already working is not started again; it reads the directive at its next step + boundary, the steering road it always had. +- A member's `team_post` **to the manager**, and a member's own **finished**, **failed** and + **asking** events, start an idle manager's turn. They coalesce: the first arms a five second + settle window, measured from that first line and never extended, and one turn carries + everything that arrived in it, so members finishing on one burst of work are one thing to act + on. +- The woken turn is never the person's: it opens on the same marked note a step boundary + hands over, queued as the session's line with the wake bit, so the spend limit, the wall and + a stopped session still decide whether it may run. +- The watch lives with each conversation on the engine (`internal/session`'s + `team_wakewatch.go`), locally and over `--host` alike. It costs nothing while a turn runs, + one stat of the teams file per second shared by every conversation in the process while + idle, and one stat of each team log only while idle in a managed team with wake on. +- **A conversation nobody holds is opened headless.** The side that wrote a waking line probes + the target's journal lock; when nothing holds it, the engine sends a hello naming its + transcript to the session host of its folder (`cmd/codeaf`'s `team_resume.go`), which opens + it with no surface and keeps it while it works. A window that opens it later joins the + running conversation. Where no road exists (a `--no-host` or `--once` process, no folder + recorded, a host that will not start), the Traffic says `could not wake @x: <reason>`. +- **Limits.** One conversation is woken at most 20 times an hour (`teamWakesPerHour`). A + manager woken 10 times by its team with no word from the person (`teamLoopRounds`) stops being + woken and asks the person instead: an asking event from the manager in Traffic, drawn in the + needs-you amber, and a note for its next turn. The person's next message to it resets the + count. Wakes spend through the ordinary budgets. +- **Visibility.** Every wake is a Traffic event, `◆ woke @web` and `@web woke ◆`, and every + refusal is one too. The rail draws a member's wake as `working…` in the thread it answers and + does not draw the manager's; a refusal is the member's line in that thread. +- **Off switch.** `wake` is one of the inheritable team settings (8.2): a team's own `wake` + in `teams.json` (a file from before it was inheritable wrote only `"wake": false`, which + reads unchanged as an override to off), else the nearest ancestor's, else the profile's + `teams.wake` (on). The settings tab's Teams group carries the default as its own row, `team + messages wake`. With it off, a directive, a reply and a + `team_start` start no turn: the new member is opened and reads its brief on the first turn + something else starts, and the Traffic says `opened @handle; this team's auto-wake is off, so + no turn was started.` + +**Mentioning a team or a chat from the composer.** `@` is still the one list +(`internal/tui3`'s `files.go`, `mention.go`). Its first row is the words team, chat +and file, each a press that types `@team:`, `@chat:` or `@file:` and keeps that +section. The word under the pointer takes the cursor ground, and the hint is +`only teams · click` (or conversations, or files). Typing filters every section that +is showing. Argument completion (`/image `, `/export `, `/attach `) stays files only. + +Under the words: teams from the window's in-memory list, a colour dot and the name; +then conversations, open tabs in this window first and then the recent snapshot the +door already holds, loaded once inside a command; then the task sections; then +files. A prefix hides the other sections, including tasks. A conversation in no team +is still offered. The conversation in front is not. + +Choosing a team replaces the `@` token with `●` and the team's slug (`●harbor`), +drawn in that team's colour. The runes are the token, so the caret's column does not +move. Choosing a conversation keeps `@` and writes the handle, or `TaskSlug` of the +title when the conversation has no handle. The row's note is the title. + +After send, the same link pass inks those tokens on the person's own message +(`mentionLinkPass`). A `●slug` opens the teams page on that team, the same door a team's +name uses, including the wall fallback over `--host` when the engine has no teams doors. +An `@handle` or `@slug` +of a conversation this window can name, including one in no team, opens it through +the tab strip. Model prose keeps the older door: an `@handle` of a member of a team +this conversation is in, and a team name written as a team. + +The digest is built on the engine (`internal/session`'s `mention.go`), inside +`Submit` and before the lock, so `--host` works and the frame never reads it. The +journal stores the person's words (`user.said`). The model reads those words plus +one block per reference: a team is `teams.Digest` at 800 runes (members, handles, +states, recent traffic); a chat is its title, its state and an excerpt of the last +reply, cut at 1536 runes. The read is `teams.Load`, `teams.ReadTraffic`, +`journalState` and `Peek`. It does not call `teamRouse`, `AppendTraffic` or +`Submit` on the conversation it names. A token with a slash is a file path and is +not a chat. An unknown `@word` is left as text. A standing mark does not take this +road; `Submit` does, and steering goes through `Submit`. + +**Known limits of v1.** A stop or a start takes effect only in a window that holds those +conversations. A member waiting on a permission prompt shows as running off its journal alone, +because the prompt is not in its session file; its asking event says `asking` while a process +holds the transcript lock and the event is under 30 minutes old (`askingStaleBound`). When the +lock is free, or the event is older than that, it reads idle. The loop breaker's needs-you is +the Traffic's asking row and a note, not a question on the manager's tab. Over `--host` against an engine older than the teams doors, teams and the manager +are off and say so. An unreadable teams file on the engine is not moved aside from a window over +`--host`; the window holds no teams until it can be read. + +**Not in v1.** Collision flags when two members touch the same files, and dispatch of whole +plans. (Nested managers, a sub-team's manager a member of the parent team with reports flowing +up and directives down, were built later: 8.9.) + +## 6. The laws this design leans on + +- The frame reads no disk; readings happen on openings, stirs and ticks, off the loop. +- The update loop starts no process of its own; model calls are commands. +- Tab order never moves; a close is a view, never work. +- One accent on the screen; state claims one step of the ladder each. +- An empty profile directory is the ordinary launch. +- A block's live edge settles through `livestate.go`; nothing else names a field `edge`. +- An untitled conversation is called `new conversation` on home's sessions list and on + the sessions place, through one helper (`homeName`). It is never the session id. +- A resize drops hover that pointed at a door the new layout may not draw (`more ▾`, + a nav word), so the hint line does not keep naming it. +- A person's answer on a card this turn is part of what the completion check reads, + after the clipped account, as `the person answered the card "<title>": <what they chose>`. A + `just once` answer reads `only now, don't repeat`, so the check does not treat + "nothing was set up" as work still owed. The tool result for that answer tells + the model to do the step now and report it, and not to set it up again or to + investigate codeaf. + +## 7. Later, each needing its own go + +- Agent tools for teams from any chat ("put the nvda chats in a team"), through the same + store, which over `--host` is the engine's (section 5, "Whose profile"). +- A Teams place on home showing the tree and each team's whole membership, open or not; + nesting in the UI; drag a tile onto a team. +- The manager waking on events, collision flags, nested managers, dispatch. + +## 8. Delegation (ruled 2026-09-24; store and contract built, session and screens next) + +**The goal.** The person talks to the top manager and steps away. Work is handed down a tree +of teams; questions and decisions travel up it; only what no manager may or can decide reaches +the person, and it reaches them as a card they can answer without reading a transcript. + +This section is the contract two builders work from at once: the session side (the team +tools, delivery, caps and wrap-up, in `internal/session`) and the interface side (the teams +page, the settings tab, the cards, in `internal/tui3`). Both meet only in `internal/teams` +and its Traffic, as section 5 already requires; everything named here exists at the +foundation commit and is tested. + +### 8.1 The rulings, as built + +- **Home and links.** Every conversation that sits in a team with a manager somewhere above + it reports to exactly one manager, its **home**. The home is auto-picked, stored, never asked + and never moved by itself: nearest manager up the chain first, else the membership the + manager's `team_start` made, else the first managed team it joined. Every other manager it + can be reached by is a **link**: it may read the conversation and send it an fyi, nothing + else. The person can move the home (`Reports to ◆ harbor ▾`). +- **Questions go up.** With `questions_up` on (the default), a member's clarifying question + goes to its home manager first, logged in Traffic; the manager answers it or sends it up. + Permission prompts never go up: they are the person's, always (section 5, "What it may not + do"). +- **Decision packets.** Everything that must be decided above the conversation that met it + travels as one self-contained packet (question, parties and each side's context, options + each with its consequence, a recommendation with its reason). The same packet is answered + by a manager or by the person. +- **Conflicts go to the LCA of all n parties**, in one hop: the lowest open team above every + party that has a manager who is not one of them. No such team: the person. Parties declare + a conflict (`team_raise`); nothing detects one. +- **Orders go one level down, reports one level up.** A manager directs its own team's members, + a sub-team's manager among them; it does not reach past them. Managers of different teams + talk only through the tree. +- **The optional global manager is the manager of the root.** With several top-level teams + there is no top manager until the person makes one on the `All teams` row (8.2, "The root"). +- **Caps.** A team may have a daily cap; reaching it raises a cap packet to the person. +- **Lifecycle (c-9).** A team is open or closed. Closing is a card (8.5); a closed team is + folded away, can be reopened, and only a closed team can be deleted. + +### 8.2 The store: the exact API + +Everything below is `internal/teams` unless named otherwise. + +**Per-team settings** (`teamsettings.go`). Five optional overrides, stored flat on the team in +`teams.json`, each unset meaning inherit: + +| teams.json field | Go | Meaning | Band | +|---|---|---|---| +| `questions_up` | `*bool` | members' questions go to the home manager first | | +| `cap_usd_day` | `*float64` | dollars per local day for the team and everything under it; `0` is an explicit no cap | `>= 0` | +| `depth_limit` | `*int` | levels of teams, the top counting as one | 1 to 10 | +| `sub_share` | `*float64` | fraction of this team's cap a new sub-team is made with | (0, 1] | +| `wake` | `*bool` | team traffic wakes idle conversations (section 5); the old `"wake": false` reads as off | | + +- `type Settings struct{ QuestionsUp *bool; CapUSDDay *float64; DepthLimit *int; SubShare *float64; Wake *bool }`, + `Team.Settings`, `(Settings).Empty()`. +- `(*File).SetSettings(id, func(*Settings)) error`: set a field to override, nil it to + reset; out of band is `ErrSetting` and nothing changes. tidy drops an out-of-band value in a + hand-edited file (it reads as inherit). +- `type Defaults struct{ QuestionsUp bool; CapUSDDay float64; DepthLimit int; SubShare float64; Wake bool }` + and `DefaultsAt(profileDir) Defaults`, from config.json in one read. +- `(*File).Effective(id, Defaults) Effective`: each value with its `Origin` + (`QuestionsUpFrom`, `CapFrom`, `DepthFrom`, `SubShareFrom`). `Origin{Kind, Team, Name}`, + Kind one of `OriginTeam`, `OriginAncestor`, `OriginSettings`, `OriginClosed`; + `(Origin).Inherited()`, `(Origin).Words()` = `""`, `from Settings`, `from harbor`, + `closed`. The walk skips closed ancestors; a closed team's own cap is none. +- `(*File).Depth(id) int` (the root is 0, top level 1), `(*File).CanNest(parent, Defaults) bool` + (parent open and one more level inside its effective limit), `(*File).SubTeamCap(parent, + Defaults) float64` (parent's effective cap times its share, to the cent; 0 when the parent + has none). The session writes that figure on the new sub-team with `SetSettings`, so a later + change of the share moves no team that exists. + +**A cap is a pool.** A team's spend counts every team under it, so an inherited cap is the +ancestor's one pool, shared, never a second allowance of the same size. `Effective.CapFrom.Team` +names the pool's owner; when the cap comes from Settings, the owner is the top of the chain +(the root when there is one). The spend drawn beside a cap is always the owner's. + +**Config keys** (`internal/config/teamdefaults.go`, flat dotted keys, category `teams`, one +settings tab `Teams`, each a row with a named reader `TeamDefaultsAt` and a ledger line): + +| key | kind | default | registry label | +|---|---|---|---| +| `teams.questions_up` | on/off | on | questions go to the manager | +| `teams.cap_usd_day` | dollars, `no cap` at 0 | 0 | team daily cap | +| `teams.sub_share_pct` | whole %, 1 to 100 | 50 | sub-team share | +| `teams.depth_limit` | levels, 1 to 10 | 3 | team depth | +| `teams.wake` | on/off | on | team messages wake | + +All five are guarded from model self-service (`teams.wake` as pressure: a wake starts a turn +nobody typed), the first four (`selfservice.go`): a manager is a model, and +each is a rail on managers (money, pressure, consent). + +**Home and links** (`home.go`). + +- `Member.Home bool` (`home`): the one membership whose chain names the manager the + conversation reports to. `Member.Started bool` (`started`): the membership a manager's + `team_start` made; the interface sets it when it carries out a `KindStart`. +- `(*File).Home(key) (Report, bool)`, `(*File).Links(key) []Report`, + `(*File).SetHome(key, teamID) error` (`ErrNoManagerAbove` for a chain with no manager). + `Report{Via, Team, Manager, Distance}`: the membership's team, the managed team, its + manager's key, levels between. +- tidy (every load and write) gives every conversation with something to report to exactly + one flag and takes it from any other; a valid flag is never moved. The pick order: nearest + manager (own team before one a level up, then the deeper team), then `Started`, then file + order (which is join order at the first write that gives a conversation a manager). +- A manager is never its own home: a sub-team's manager reports one level up. +- The flag is stable; the manager at the end of its chain is whoever the person made manager + there. A conversation in an unmanaged sub-team reports to the manager above; when the + person gives that sub-team a manager, the same flag resolves to it. That is the person's + act, not a home changing by itself, and a sub-team manager nobody reported to would manage + nothing. + +**LCA** (`home.go`). `(*File).LCA(keys...) (Team, bool)`: the deepest open team at or above +some membership of every key, with a manager who is not one of the keys (a party never judges +its own case). false is the person. One key gives its nearest manager. + +**Lifecycle** (`lifecycle.go`). + +- `Team.State` (`state`: `TeamOpen` or `TeamClosed`; empty reads open), `Team.ClosedAt` + (`closed_at`), `Team.ClosedWith` (`closed_with`: the team whose close closed it), + `Team.Report` (`report`: the closing report's packet id). `(Team).Closed()`. +- `(*File).Close(id, at, reportID) error`: closes the team and every open team under it; + a sub-team closed earlier on its own keeps its own close. Closing the root is `ErrRoot`. +- `(*File).Reopen(id) error`: reopens the team and exactly the teams its own close closed; + under a closed parent it is `ErrParentClosed`. +- `(*File).Open() []Team`, `(*File).ClosedTeams() []Team` (newest close first), + `(*File).Descendants(id) []Team`. +- `Delete(profileDir, id) ([]string, error)`: only a closed team (else `ErrOpen`), with every + team under it; the file first, then `TeamDir(profileDir, id)` (Traffic and packets). + Conversations are never touched. +- `Quiet(profileDir, f, now, idle) ([]string, error)`, `QuietAfter` (7 days): open teams with + no Traffic, packet or member-transcript activity for idle and no packet waiting on or raised + from them. Organize's input; it closes nothing. +- A closed team is outside every walk: never a home, never found by `managerUp`, never an LCA, + skipped by `Effective`, no cap. A conversation whose home closes is given the next home on the + same write, or none (it is then an ordinary chat). + +**The root** (`root.go`). `Team.Root` (`root`), `RootName` (`All teams`), +`(*File).Root() (Team, bool)`, `(*File).MakeRoot(at) string` (moves every top-level team under +it; then `AddMember` and `SetManager` in the same write), `(*File).DissolveRoot()`. tidy keeps one +open root at the top and puts any later top-level team under it. The root is not a level +(`Depth`), cannot close or move (`ErrRoot`). Its override is what `from All teams` means. + +**Decision packets** (`decision.go`). One file per team, `<profile>/teams/<id>/decisions.jsonl`, +append-only JSON events (`raise` with the whole packet, then `decide` and `escalate` naming it by +id), folded by id. A packet lives in the file of the team it was raised from and never moves; +escalating changes who decides and adds a hop. Writes are under the file's lock and re-check the +fold under it; reads are stat-first and read only the bytes appended since the last read. + +```go +type Packet struct { + ID string // "p" + 12 hex, minted by Raise + Team string // who decides now: a team id (its manager), or Person ("you") + Origin string // the team it was raised from; its file holds it + Kind string // question | conflict | cap | judgement | closing + RaisedBy string // raiser's handle, "manager", or "you" + Parties []Party // {Key, Handle, Team, Context}: each side in its own words + Question string + Options []Option // {ID, Label, Consequence}; ID defaults to "1", "2", ... + Recommendation *Recommendation // {Option, Reason}, optional + Report *ClosingReport // {Done, Left, Files, SpendUSD, Incomplete}, closing only + State string // open | decided | escalated (escalated still waits, at Team) + DecidedBy string // the deciding manager's handle, or "you" + Decision string // an option id, or the person's own words + Reason string // the decider's, or the last escalation's + Trail []Hop // {From, To, By, Reason, At}, oldest first + Raised, At time.Time +} +``` + +- `Raise(profileDir, Packet) (Packet, error)`. Required: a kind, the question, the raiser, and + on every option a label and a consequence; a question may have no options, every other kind + needs one; a recommendation names an option and gives a reason. `Team` is found by the caller + (`LCA` for parties, `Home` for a member's question) and must be open; `Origin` defaults to + `Team` and must be `Team` or under it (`ErrSideways` otherwise). +- `Decide(profileDir, id, by, decision, reason) (Packet, error)`. `by` is the handle of the + manager the packet waits on (or `"manager"`, recorded as the handle), or `Person`, who may + decide any packet. `ErrNotDecider`, `ErrDecided`, `ErrNoPacket`. +- `Escalate(profileDir, id, by, to, reason) (Packet, error)`. `to` is an open team strictly + above the one it waits on, or `Person`; down, sideways, closed or past the person is + `ErrSideways`. +- `OpenPackets(profileDir, scope) ([]Packet, stamp, error)`: waiting packets for a team id, + `Person`, or `ScopeAll` (`""`). `Packets(profileDir, teamID)`: a team's whole history, + decided included (the closed view and its reports). `PacketByID`. `PacketsStamp(profileDir)`: + one stamp over every packet file (a directory listing and a stat per team). + `DecisionsPath(profileDir, teamID)`. +- Option ids the two sides act on: `OptionClose` (`close`), `OptionCloseNow` (`close-now`), + `OptionKeepGoing` (`keep-going`), `OptionRaiseCap` (`raise`), `OptionStopToday` (`stop`). +- Every raise, decision and escalation also appends a `KindPacket` Traffic entry to the origin's + log and to every team asked to decide it, so a window tailing Traffic learns of it without + polling, and a manager's session is handed it by ordinary delivery. + +**Spend** (`spend.go`). The usage ledger (`<home>/v3/usage.jsonl`, internal/session's +`usage_ledger.go`) already records every call's local day, cost, conversation id (`session`) +and, for work a conversation started, that conversation's id again (`root`). A member's id is +its transcript folder's name. So: + +- `TeamSpend(profileDir, teamID, day) (Spend, error)`: the day's lines whose session or root + is a member of the team or any team under it, each line once, each conversation once. + `Spend{Team, Day, USD, Calls, ByMember map[key]float64}`. `TeamSpendIn(profileDir, ledger, + ...)` for tests. `Today()`, `UsageLedgerPath()`, `SpendStamp(profileDir, ledger)`, + `TeamSpendStamp(profileDir, teamID, day)`. +- The ledger is folded once per process into totals by day and (session, root), then only + appended bytes are read; a quiet ledger costs a stat. `internal/session`'s + `TestTeamSpendReadsTheSessionsLedger` pins the path and field names. +- A sub-team closed today still counts toward its parent's day: the money was spent. +- Nothing here enforces a cap; the session does (8.8). + +**Traffic kinds added** (`traffic.go`): + +| Kind | From → To | Meaning | +|---|---|---| +| `question` | member handle → `manager` | a clarifying question to the home manager | +| `answer` | `manager` → member handle | the answer; `Entry.Reply` is the question's entry id | +| `packet` | `system` → `manager` | a packet was raised, decided or escalated; `Entry.Packet` is its id, `Entry.State` its new state | +| `close` | `you`, `manager` or `system` → `everyone` | the team was closed | +| `reopen` | `you` → `everyone` | the team was reopened | + +`ToYou` (`you`) is added as an address for the person. + +**Over `--host`** (`internal/remote`'s `wire_delegation.go`, `delegation.go`). Seven additive +methods, answered from the engine's profile and ledger: `Teams.Defaults`, `Teams.Packets(scope, +stamp)` (answers `same` in a few bytes), `Teams.Raise`, `Teams.Decide`, `Teams.Escalate`, +`Teams.Spend(team, day, stamp)` (answers `same`), `Teams.Delete(team)`. `Welcome.Delegation` +says the engine has them. Close, reopen, overrides, homes and the root are edits to the teams +file and cross by `Teams.Update` like every other edit. + +**The seam** (`tui3.TeamsSeam`). Beside `Load`, `ReadSince`, `Update` and `Traffic`: +`Defaults`, `Packets(scope, since)`, `Raise`, `Decide`, `Escalate`, `Spend(team, day, since)`, +`Delete(team)`, every one asked off the loop. `localTeams` wires all of them to this profile; +cmd/codeaf's `hostTeams` wires them to the wire only when the welcome says `Delegation`, and an +engine with the teams doors and not these gets a seam whose delegation doors are nil +(`TeamsSeam.delegation()` false). The interface then says the inbox and the spend are not +available over that connection; it never reads the laptop's packet files. The frame law +forbids every new store door in a frame (`framedisk_law_test.go`). + +### 8.3 What the session side builds on this (d1) + +- **Identity** is section 5's: a session's key is its transcript path; its home is + `Home(key)`; it manages team T where `T.Manager == key`. +- **Questions up.** When `Effective(team).QuestionsUp` and `Home(key)` exists, a member's + clarifying question is a `KindQuestion` entry to `manager` in the home team's log. The manager + answers with `KindAnswer` (`Reply` set), delivered like any message. A manager that cannot + answer raises a `question` packet to its own home's team, or to `Person` when it has none + (the top manager's own questions reach the person). Permission prompts never take this road. +- **Conflicts.** `team_raise` takes the parties' handles, finds `LCA(keys...)`, and raises a + `conflict` packet there (or to `Person`). The LCA manager is woken by the `packet` entry, may + read and ask the parties, rules with `Decide` and directives to every party (logged in each + involved team's Traffic), or `Escalate`s up. Never sideways. +- **One level.** `team_send`, `team_stop` and `team_start` reach only the manager's own team's + members (a sub-team's manager is one). Links may send fyi notes (`KindNote`) and nothing else. +- **Caps.** Before each model request of a member, the session compares + `TeamSpend(owner, Today())` with the pool owner's effective cap (`Effective.CapFrom.Team`, or + the top of the chain). Reached: it raises one `cap` packet to `Person` for that team and day + (not one per request; look for an open one first) with options `raise` (`Raise to $10`, + twice the cap) and `stop` (`Stop for today`) and a recommendation, and holds new member turns + in that pool until it is decided. Managers never raise a cap: money is the person's. +- **Sub-teams** (nesting step): `CanNest(parent)` gates `team_start` of a team; the new team + gets `SubTeamCap(parent)` written as its own `cap_usd_day`, and its manager is a member of the + parent. +- **Wrap-up** (c-9): when the person picks `Wrap up first`, the manager tells members to finish + and commit, answers what it can, and raises a `closing` packet to `Person` with a + `ClosingReport` and options `close` / `keep-going`, bounded by time and spend; out of bound, it + raises it with `Incomplete` and the option `close-now`. The interface closes the team only when + the person picks close. +- **Closed** teams spend nothing: a session whose only teams closed takes no team turns. + +### 8.4 The interface (d2) + +The house rules hold everywhere below: every clickable thing grounds on hover; actions are +word buttons with a dim hint line and a key; one accent on the screen; padding around every +block; nothing moves the person's focus; every panel closes (`esc` and a word); everything is +findable from `?`. Amber is used for one thing only: something needs the person (a packet +waiting on them, a member's permission prompt). A packet waiting on a manager is not amber: +somebody is on it. + +**The settings tab `Teams`** (built at the foundation commit, between `Tasks` and `Providers`). +Four rows, in this order, each with the registry's hint: + +``` + questions go to the manager on + daily cap per team no cap + sub-team share 50% + team depth 3 levels +``` + +The tab is titled `Teams` and is the one-to-one reading of the `teams` category, like +Spending, Safety and Tasks. A line under the rows, dim: `a team can override any of these on +its card`. + +**The teams page.** A main tab `teams`, right after `home` (the digits after it shift by one). + +- **Left rail: the tree.** One row per open team, indented by level, each with its colour dot, + its name, and at most one mark: `●` working (dim, a member is running), `◆ needs you` + (amber, a packet or a prompt waits on the person). Above the teams, the `All teams` row: with + no root team it is the whole list and carries `+ Manager` (the optional global manager; the + click makes the root, 8.2); with one it is the root team and selects like any team. Below + them: `+ New team` and `Organize`, word buttons. At the bottom, folded: `Closed · N` + (8.5). `↑↓` walks the rail, `enter` selects; the selection never moves focus out of the + composer on its own. +- **Right pane: the selected team's REAL manager conversation** (the full chat of section 5: + typing steers it, its prompts are approved here), under a compact header: + + ``` + ◆ harbor @web ● running @api idle @docs ◆ asking $1.20 of $5 today Settings Open ▦ + ``` + + members with their states (each clickable, opening the member), today's spend against the + effective cap (`$1.20 today` with no cap; the pool owner's figure with `· harbor's cap` when + the cap is inherited), `Settings` (the team card), `Open ▦` (the team on the wall). A member's + permission prompt shows as a needs-you row in the header with `Allow once` / `Always` / + `Deny`, the person's own gate (a manager never answers it). +- **The inbox.** Above the conversation, the packets waiting on the person or on this team's + manager, one card each, newest last, folded to one line each beyond three. Hosted, the + cards also have a height: about a third of the frame (at least 8 rows); the newest, or the + one a press unfolded, is always whole, older ones stay whole while they fit, the rest fold + to `▸ kind · question waiting on you`. Measured at 110x34 with three packets before the + change: the cards took every pinned row and left the manager's conversation one row, the + Traffic edge cut to `T`. A card leads with whose it is: `?` in the needs-you amber when it + waits on the person, `◆` when it waits on a manager (every card led with `◆` before, which + read as the manager's own question): + + ``` + ? conflict · raised by @web waiting on you + which shape does the signup form send? + @web the form posts JSON + @api the endpoint takes form data + [ JSON ] @api changes the handler; the form stays recommended: matches the rest + [ form data ] @web rewrites the submit; the handler stays + [ Your own answer… ] [ Send up ▴ ] + ``` + + Options are word buttons with their consequence as the dim line; the recommended one says + so beside it; `Your own answer…` opens a one-line box (`enter` decides with the words); + `Send up ▴` escalates to the next manager up, or to the person (shown only when the viewer is + a manager's page and there is somewhere up to go). A packet waiting on a manager is shown + dim with `waiting on ◆ dock`, and the person may still decide it (authority: person first). + Decided packets leave the inbox and stay in the team's history. +- **No manager:** the right pane is the members (states, open) and one `+ Manager` button with + the line `a manager takes your messages to the team and asks you only what it cannot decide`. +- **No teams at all:** an explainer (two sentences: what a team is, what a manager does) and + `Organize` / `New team`. +- **A cap reached** is a `cap` packet, drawn like any card: + + ``` + ◆ harbor reached its $5 cap today waiting on you + [ Raise to $10 ] harbor and its sub-teams go on until $10 today + [ Stop for today ] members finish their current turn and start no new one recommended: … + ``` + + The team's rail row carries `◆ needs you` until it is decided. + +**The team settings card** (from `Settings` in the header). Overrides only: each of the four +values on its own row, the effective value in ink when the team overrides it, with `reset` +beside it; an inherited value dim with its origin, `$5/day · from Settings`, +`on · from harbor`, `3 levels · from All teams` (`Origin.Words()`). Editing a dim value makes +it an override. Below the four: `Reports to` for a selected member (its home and `▾` to move +it), and `Close team…`. Closable with `esc`. + +### 8.5 Closing, reopening, deleting (c-9) + +- **`Close team…`** (card from the team settings card, the rail's context menu, and `?`): + - with work running: `Wrap up first` (default, the accent), `Close now`, `Cancel`. The hint + under `Wrap up first`: `the manager asks everyone to finish and commit, then brings you a + closing report`. The team closes only when the person picks `Close` on the report. + - `Close now` stops every member turn (the person's own Stop), ends the manager's turn, + closes the team's tabs and moves it to Closed, in one step with `Undo` on the notice line. + - with nothing running: one `Close` with `Undo`. + - Closing a team closes its sub-teams; their reports roll up into the parent's. A sub-team + closing alone reports to its parent's manager. + - A conversation that is also in another open team is never stopped; its home moves by the + auto rule, or it becomes an ordinary chat. +- **The closing report** is a `closing` packet: `done`, `left`, where the files are, what it + spent, and `Close` / `Keep going` (or `Close now` when the wrap-up ran out of time or money, + marked `wrap-up incomplete`). +- **`Closed · N`**, folded at the bottom of the rail and of the team switcher, never on the + strip or the wall. Opening a closed team shows its closing report, members, spend, opened and + closed dates, and `Reopen` (tabs reopen, the manager resumes) and `Delete…` (confirm; it + forgets the grouping, the Traffic and the packets; conversations stay in history). Delete + exists only here. +- **Organize** adds one proposal kind: `Close N quiet teams` (`Quiet`, 7 days without activity + and no open packet), each named, with `Undo`, never applied without the person. Its row is + the sentence whole and then the teams (`☑ Close 2 quiet teams harbor, orbit`): it is not a + team, so it wears no colour dot and no second count (it read `☑ ● Close 2 quiet t… 2`). +- **A team's cards stand over the pane.** The settings, close and move cards are centred over + the teams page's pane while that page stands, so the rail beside them still says which team + they are about; they covered the rail before. Elsewhere they are centred on the frame. + +### 8.6 Where this departs from the brief, and why + +- **The home flag resolves to the nearest manager up its chain**, so giving an unmanaged + sub-team a manager takes its members with it. The alternative (store the manager's team, + never move) leaves a new sub-team manager managing nobody; making a manager is the person's + act, so this is not a home "changing by itself". +- **`decided_by` is `you`, not `person`**, because Traffic already spells the person `you` + (`FromYou`, now `ToYou`); one word for one party. +- **The settings group is its own tab, `Teams`.** The settings tabs are one-to-one with their + categories for the four newer tabs; a group inside Tasks would be a row filed under one + category and drawn under another. +- **A cap is a pool, and the header says whose.** `$1.20 of $5 today · from harbor` beside a + sub-team would read as a second $5; the header shows the pool owner's spend and says + `harbor's cap`. The settings card still says `from harbor`, which is true of the value. +- **Cap packets always go to the person.** A manager that could raise its own cap would make + the cap advice. Managers may stop their own team early; they may not spend more. +- **The global manager is a real root team**, not a special case beside the tree, so every + rule above holds for it unchanged; the root is not a level and cannot close. +- **Team defaults are rails**, refused to model self-service like the spending and consent + rows. A team's own overrides are written only by the interface for the person; the team + tools must not write them (d1). +- **Packets waiting on a manager are not amber**, only those waiting on the person. The brief + said "amber only for needs-you"; this is that rule applied to packets. + +### 8.7 Open questions + +- Over `--host` the `Teams` tab reads and writes the engine's `teams.` defaults + (`Teams.Defaults`, `Teams.ApplyDefault`), the same registry write the local tab makes. + A value is drawn with `from Settings` (`Origin.Words`). An engine without + `Welcome.TeamSettings` keeps the tab read only and says + `changing them is not available over this connection`. The other settings tabs still + write this laptop's config.json. The note on those tabs says + `these rows belong to this machine; the Teams tab is saved on the other one.` + On the Teams tab, when the seam can write, it says `these rows are saved on <machine>.` +- Spend over `--host` is the engine machine's ledger only. A conversation whose model calls + were made on another machine (a laptop-run member of a far team) is not counted; no such + arrangement exists today. +- (Settled by d1, 8.8: the packet file now rotates.) A packet file was never rotated. A team that raises thousands of packets grew it without + bound; if that happens, rotate like Traffic and keep undecided packets in the new file. +- The ruling does not say who may reopen a team whose parent is closed; the store refuses it + (`ErrParentClosed`) and the card should offer `Reopen harbor` instead. + +### 8.8 What the session built (d1) + +Everything below is `internal/session` unless named otherwise, on branch `task/deleg-session`. +The interface side (d2) meets it only through `internal/teams` and its Traffic. + +**Wake is an inherited setting.** `teams.Settings.Wake`, `Effective.Wake`/`WakeFrom`, +`Defaults.Wake`, config key `teams.wake` (8.2). A conversation's roles are resolved against the +profile's `teams.` rows, which are read again only when `config.json` moves (one stat per +boundary). A closed team gives no role at all: no verb, no delivery, no team turn. + +**Home and links (routing).** A conversation's home is `File.Home(key)`. In a managed team whose +manager is not its home it is **shared**: that manager is a link. + +- `team_send` kind `directive` and `team_stop` from a link are refused, in words that name the + home team (`@web reports to the manager of "harbor", not to you: here you are a link …`); a + note goes through. A directive to `everyone` is written once per member who reports here + (`To` = handle) and names the shared ones it left out; with none left it is refused. +- A member reads a link's directive (from an older writer) as `◆ fyi from the manager of …` + and is not woken by it. +- `team_status` and the digest mark a shared member `reports to <team>`, and `busy for <team>` + in place of `running` (`teams.MemberState.ReportsTo`). `team_status` also lists the packets + waiting on the team. + +**Questions up.** `ask` of kind clarification, choice or confirmation from a member whose home +team has `questions_up` effective raises a `question` packet (`Team` = home team, `Origin` = the +membership, `RaisedBy` = handle, one party with the asker's reason as context, the options with +their consequences, the pick as the recommendation) and returns at once, saying so; nothing is +shown to the person, and the manager is roused if nobody holds it. A permission, landing, +assumption or ratify never goes up. The manager's own clarifying question (and its judgement +calls) is a packet too: to its home team when it has one and questions go up there, otherwise +to `you`. New manager verbs, all on the approval floor (allow): + +| Verb | What it does | +|---|---| +| `team_decide` | `Decide(id, "manager", answer, reason)` on a packet waiting on a team it manages; an option may be named by its label; refuses cap and closing packets (the person's) | +| `team_escalate` | `Escalate` to its own home team (`to: up`, the default) or to `you` | +| `team_close_report` | raises the `closing` packet to `you` (done, left, files, the team's spend today) | + +Delivery reads `KindPacket` lines by packet id: a manager is handed a packet newly waiting on +its team whole (question, contexts, `[id] label: consequence`, recommendation, trail), and is +woken by it; the raiser (member or manager) is handed `◆ answered: <label or words> (by ◆ +@boss, because …). Your question was: …` and woken; an escalation of its question is told +without waking. `Decide` on a question now logs `answered @web: <label>` (the rail draws it +after the decider's mark). + +**Caps.** At every point the team would START something (a member or manager wake, a new +member's brief, `team_start`), the pool (owner = `CapFrom.Team`, or the top of the chain for a +Settings cap) is checked: at or over the ceiling, the start is held and the Traffic says `held +@web: harbor reached its $5 cap today …` once per reason; a running turn is never cut; the +person's own typing is never held. The first holder raises ONE `cap` packet to `you` for the +pool and ceiling (`harbor reached its $5 cap today`; `raise` = `Raise to $10`, twice the +ceiling; `stop` = `Stop for today`; recommended `stop`), carrying `Packet.Cap` = +`CapFacts{Team, Day, CapUSD, SpentUSD, RaiseTo}`. The raise is idempotent across processes: +under the decisions file lock, the crossing is the pool team id, the local day and the ceiling +(`CapUSD`). A second raiser, another window or a headless wake, finds that packet and writes +nothing. A later day, or the same day after a `raise` when the new ceiling is crossed, is a +different crossing and a new packet. A decided `raise` lifts the ceiling to +`RaiseTo` for that local day; meeting it raises one more packet at the new ceiling; `stop` or +the person's own words hold until the day turns or the cap is changed. Spend is read through +`TeamSpend` only when `TeamSpendStamp` moved (per pool, per session), never per model request. + +**Wrap up first: the door and the marker (for d2).** The interface appends ONE Traffic entry to +the team's log: + +```go +teams.AppendTraffic(profile, teamID, teams.WrapUpRequest("")) // or the person's own words +// = Entry{Kind: KindDirective, From: FromYou, To: ToManager, State: StateWrapUp ("wrap-up"), Text: …} +``` + +`teams.IsWrapUp(e)` is the only reader. The manager is woken by it and handed an instruction +(tell every member to finish and commit, answer what it can, start nothing new, then +`team_close_report`), bounded by `wrapUpFor` (15 minutes) and `wrapUpSpendUSD` ($2 of the +team's spend since the clock's first look). The start and the bound are written on the team +(`teams.Wrap`, through `Change` / `ChangeIf`) when the clock starts, and cleared when the +report goes out. A session that opens reads it back (`teamWrapUpResume`): the time left is +the bound minus how long since the start, and a wrap-up already past its bound raises the +incomplete report on that start, once. Past either with no report, codeaf raises the +`closing` packet itself with `Report.Incomplete`, question `close harbor? (wrap-up incomplete)`, +options `close-now` / `keep-going`, recommended `keep-going`. A complete report has `close` / +`keep-going`, recommended `close`. At most one closing packet waits per team. The in-memory +clock is taken out before `Raise` so a second look during the write cannot raise another +report. A `Raise` that fails (the decisions lock is busy, `ErrBusy` after its wait) puts +that same clock back; the next ordinary due check tries again, and there is no retry loop +inside the failed check. A raise that lands clears the clock in memory and on disk, once. + +**Accepting closes.** `teams.AcceptClosing(profile, packet)` closes `packet.Origin` with the +packet as its report and appends a `KindClose` line, only for a decided closing packet whose +decision is `close` or `close-now`; it is idempotent. The interface calls it after the person's +`Decide`; the manager's session calls it again when its delivery reads the decision (and tells +the manager). `Close now` stopping member turns and closing tabs stays the interface's (8.5). + +**Packet file rotation.** `decisions.jsonl` rotates past 1 MB (`decisionsRotateBytes`) to +`decisions.1.jsonl`, and the new file opens with one `carry` line per packet still waiting (the +packet whole, trail and escalated state included). The reader folds the rotated file, then the +current one; a carry replaces what the older file said of that id. A waiting packet is never +lost; a decided one stays readable for one more rotation. + +**Over `--host`.** All of the above runs where the conversations run, the engine: questions, +caps, the wrap-up clock and the verbs are the engine's session reading the engine's profile and +ledger, so a window over `--host` needs nothing new. The clock travels with the team: +`Teams.Read` and `Teams.Update` already return `[]teams.Team`, and `wrap` is a field of that +record, so a restarted engine resumes the same countdown. It sees packets through `Teams.Packets` +and decides through `Teams.Decide`. Traffic has no general writer over the wire, so the wrap-up +has two narrow doors of its own, said by `Welcome.WrapUp`: `Teams.WrapUp` (`WrapUpArgs{Team, +Text}`) appends exactly `teams.WrapUpRequest(Text)` to the engine's log, and +`Teams.AcceptClosing` (`AcceptClosingArgs{ID}` → `AcceptClosingReply{Closed, Stamp}`) runs +`teams.AcceptClosing` on the engine. Client: `(*remote.Client).TeamsWrapUp(team, text)`, +`TeamsAcceptClosing(id)`. The interface wires them into its seam (d2); an engine without the +flag gets `Close now` only, said as such. + +**Known gaps.** A conversation in an unmanaged sub-team whose home +manager is a level up gets no member verbs and no questions-up (its membership has no manager). (Closed by 8.9: such a member answers to that manager for +questions and `team_post`.) +A person's decision on a packet whose raiser nobody holds is delivered when that conversation +next runs; only a manager is roused. + +### 8.9 What the interface built (d2), and where it departs from 8.4 and 8.5 + +Everything below is `internal/tui3` unless named otherwise, on branch `task/teams-page`. The +person's guide is `internal/manual/chat/teams-page.md`. + +**As specified.** The `teams` place right after home (`placeOrder`, one entry, so the bar is +data and not restyled); the rail with `All teams`, the tree, `+ New team`, `✦ Organize` and +`▸ Closed · N`; the pane with the header (spend against the pool, `Settings`, `Close…`, +`Open ▦`), the members line, the inbox cards and the manager's real conversation under them; +the team card with provenance and `reset`; the close card; the Closed fold with `Reopen` and +`Delete…`; Organize's quiet-team proposal with `Undo`; the `Teams` settings tab's dim line. +The session's contract (8.8) is used as built: `teams.WrapUpRequest` through the seam's +`WrapUp` door (locally `teams.AppendTraffic`, over `--host` `Client.TeamsWrapUp`), and +`teams.AcceptClosing` after the person's Decide on a closing packet (over `--host` +`Client.TeamsAcceptClosing`), both only when `Welcome.WrapUp` says so. Cap packets draw +`Packet.Cap`; Raise and Stop are the person's alone. Shared members read `reports to <team>` +or `busy for <team>` (`MemberState.ReportsTo`). + +**Where it departs, and why.** + +- **The marks are `⠿` (a member working, dim) and `? N` (amber, N things wait on you from the + team or a team under it)**, not `●` and `◆ needs you`. `●` is already every team's colour + dot and `◆` already marks a manager; a count says how much waits, which the rail row had no + room to say in words. +- **The team card is the one settings surface.** The wall's `e`, the chip menu and the + switcher's `Team settings…` all open it, so the wall's old name-and-colour popover is gone + from use, and its delete with it. +- **Delete exists only on a closed team** (8.5 said so), so the wall's `D` now closes the shown + team instead of deleting it, with Undo when nothing runs and the close card when something + does. +- **The keyboard reaches the page's buttons by `alt+↑` `alt+↓`**, and `esc` gives it back to + the message box. The pane hosts a real conversation whose box takes every plain key, so the + page's letters (`s c w n o m r d u`) and arrows work only once the person has stepped onto + the buttons; without a manager in the pane they work at once. +- **The side column is folded on this page** (`alt+l` unfolds it), because the teams rail has + the left edge and the pane is narrower than a conversation's own screen. +- **Choosing a team with a manager brings that manager's conversation in front.** It is the + person's own selection, so this is not focus moving by itself; the conversation they were in + stays open behind on the strip. Resuming a member not open opens it behind, without moving. +- **The manager comes into the pane on every road, and the pane says why when it cannot** + (`teamsopen.go`). The attempt is state the page holds: `teamsSync`, run after every message, + starts one whenever the selected team's manager is not in front and none was made for it, so + teams arriving after the page opened or a manager set on the file by a session are brought + in too. A manager this window is not holding is opened off the loop in its own folder, held + behind, and brought forward only if the page still wants it, so the person stays on the page + (the switcher's door it used before steps off any place standing). A refusal, or an open with + no answer after 4 seconds, reads `couldn't open ◆ <team>'s manager: <reason>` with `Retry` and + `Open in chats`; a manager whose transcript is gone offers `+ Manager`, which replaces it. + Before this the pane read `opening ◆ <team>'s manager…` whenever the manager was not in front, + with nothing behind the word (reported by the owner, 2026-09-24). + One open per manager is out at a time: choosing the team again while it is out takes that + open up instead of asking the door twice, an answer for the manager the page is asking about + is the page's whichever attempt carried it, and a refusal about a conversation the window now + holds is no refusal, and the swap uses that same check: a lock on a transcript this window + already holds brings that manager forward and says nothing. Only `Retry` asks again while an + open is out. Over a connection that holds one conversation at a time the swap is asked on the + ordered door line, never from Update. +- **How the page loads.** The rail, the header and the pane's frame are drawn from memory on the + opening frame (the teams file is the one read made on the loop, and it does not block), and + every reading fills in place: the spend is the header's last piece, members start as members + and become chips, and nothing on the page says it is loading. The reads are one command off + the loop, on the opening, a choice, a gesture and the router's beat while a team has a + manager. It asks the packets, the defaults, the selection's pool spend and the members' rows + side by side, because over `--host` each is a round trip. The rows are the open teams' + members only: read by name off this machine's disk (`session.ReadRows`), or cut out of the + world a connection already holds. The page used to walk every session on the machine on its + opening and every beat to find them. One read is out at a time and none is dropped: a read + asked while one is out is made when that one is folded, for the selection as it then stands. + Measured on Spark over a 320-session, 5-team, 25-member fixture (2026-09-24): opening to the + first full reading 33 ms before, 3.3 ms after (the walk was 22 to 29 ms of it, the member + rows are 2 ms); a team chosen while the beat's read was out never showed its spend until the + next beat, and shows it in 3 to 12 ms now; a double press on a cold manager's team left the + pane saying `open in another window` in 2 of 5 runs, and in none now. The store's own reads + are microseconds locally and were left alone; so was the in-process door's resume, whose + bucket scan costs 3 to 5 ms of a 10 to 40 ms open. +- **A message handed to the hosted manager that puts another conversation in front takes the + person to it.** A Traffic row goes to its member through the chat surface's own door + (`trafficGo`), and the page steps down for it as a press on a member row does. +- **`Close now` keeps the front tab.** Every other member's tab closes, but the conversation the + person is looking at stays, so a close never moves them. +- **Over `--host` the seam's `History` and `Append` doors are nil**: a closed team's report is + not read over the connection, and close and reopen write no Traffic lines there. The page + says so where the report would be. Organize's quiet-close proposal is offered locally only, + because quietness is read from the Traffic log. +- **The `Teams` settings tab edits the engine's defaults over `--host`** when the engine says + `TeamSettings` (8.7's first question). The write is the registry's own `Apply` on that + machine. The settings note on that tab says `these rows are saved on <machine>.` The + other tabs say `these rows belong to this machine; the Teams tab is saved on the other one.` + An older engine keeps the tab read only, with + `changing them is not available over this connection`. +- **Wake is on the card** (`team messages wake`, with its provenance), which 8.4's four rows + predate; the settings tab's row order is questions, wake, cap, depth, share. +- **The interface writes no cap raise.** The person's `Raise to $10` is a Decide; the session + applies it (8.8), so the setting has one writer. +- **Under 72 columns the rail stacks above the pane**, because a 24-column rail beside a + conversation leaves the conversation too narrow to read. A hosted manager at that width is + shown without the rail. +- **The manual's digits follow the whole order** (`home teams chats sessions spend + settings`, `alt+1` … `alt+9`): when `chats` landed third, every digit after `teams` in the + manual and the help moved by one. + +- **The header is one line, and the members are a card** (owner feedback 2026-09-24, built on + `task/nest-ui`, `teamcrew.go`). The two wrapped rows of every member as prose + (`@review not open, reports to test 1d · …`) are gone. The line is the name, `◆ Manager` (a + door to the manager), a chip for each member with something happening (`⠿ working`, `? + asking` in the needs-you amber, `✗ failed` from its newest Traffic event), one quiet word for + everyone else (`+4 idle`, or `6 members` when nobody is doing anything), the spend (only with + a spend or a cap to set it against, the cap in whole dollars, `$0.42 of $5 today`), and the + three buttons. Narrow, it drops the idle word first, then the spend, then the chips from the + last, then `◆ Manager`, then the buttons from the right, never the name. The idle word (or + `p`) opens the **members card**, titled with the header's own count (`harbor · ◆ Manager · + 1 member`, where it used to say `2 members` beside a header saying `1 member`): handle, + title, state, last active, `also in test` for a + shared member (its hint says whose manager it reports to) and `Open` or `Resume`. `not open` + is said nowhere on the page: it is a fact about the window, and the button carries it. The + card hangs over the pane, clear of the rail, because its rows are the drag source for adding + a member to another team (8.11). On the root with a manager the header and the card list + `TopManagers()` (8.10), never their members. + +**Known gaps.** A switcher row `Closed · N` has no hover hint. The wall popover's delete code +is unreached and kept until the wall is next reworked. Over `--host` the Settings tab shows +and edits the engine's `teams.` rows when the engine has the door. + +### 8.10 Nesting, as the session built it + +Everything below is `internal/session`'s `team_nest.go` unless named otherwise, on branch +`task/nest-session`. The interface meets it only through `internal/teams` and its Traffic; it +needs nothing new to carry any of it out. + +**A sub-team is started like a member.** `team_start` takes `kind` (`member`, the default, or +`team`), and for a team `name` and `members` (handles of the manager's own members to move in): + +```json +{"handle":"api","brief":"…","kind":"team","name":"backend","members":["parser"]} +``` + +In one `teams.Update` it checks the manager still manages the team, that the team is open and +`CanNest` (refused with the level, the limit and its origin: `A team under "harbor" would be +level 3, past its depth limit of 2 (from Settings)`), that the handle and the name are free and +that each member to move reports here; it makes the child under the manager's team, writes +`SubTeamCap(parent)` on it as its own `cap_usd_day` when that is above zero (a parent with no cap +gives none, and the child spends from the pool above), and moves the members (added to the +child with their handles, removed from the parent). Then it writes ONE start to the parent's +Traffic, `Entry{Kind: start, From: manager, To: <handle>, Text: <brief>, Team: <child id>}` +(`teams.Entry.Team` is new), and a `note` from `system` to `room` in the child's Traffic naming +who made it and who runs it. The approval is `team_start`'s (ask), and the card's gloss reads +`a new team "backend" under yours, managed by it.` before the brief. The cap holds it like any +start. + +The interface carries the start out as it carries out every start: it opens the conversation +behind the one in front and adds it to the PARENT team under its handle (`Started`). The new +conversation reads its brief at its first boundary (`team_wake.go` starts that turn, as for any +start); a start that names a team is handed as `◆ you were started to manage the team +"backend", under "harbor": …` above the brief, and the session then makes itself the child's +manager (`Agent.claimSubTeams`: `AddMember` with its parent record, `SetManager`, in one +`Update`; a child gone, closed or already managed is left alone and the parent's Traffic says +`could not make the new conversation a team's manager: …`). This happens before the role note is +composed, so the request that carries the brief also says it is the manager. Its manager is a +member of the parent, so its home is the parent's manager by the ordinary rule (8.2): it reports +up and takes the parent manager's orders. + +**Conflicts (`team_raise`, members and managers, allow).** + +```json +{"question":"…","parties":["@api","back/@api"],"context":"my side", + "options":[{"label":"JSON","consequence":"…"},{"label":"form data","consequence":"…"}], + "recommend":"1","reason":"…","team":"optional"} +``` + +A party is a handle, looked for in the raiser's own teams first and then in every open team, or +`team/@handle` (a team by name or id); one handle answering to two conversations is refused +with both spelled `team/@handle`. The raiser is a party already (from its membership where it +is not the manager, the first). The decider is `LCA(all party keys)`; none is `you`. The origin +is the raiser's membership at or under the decider, and each party's `Team` is the membership +it was found in, or its membership under the decider (not one it manages, the deepest, first), +so every party's line runs through a team under the decider. At least two options, each with a +consequence. The LCA manager is roused if nobody holds it. + +In the store (`teams` `decision.go`): every packet line now goes to the origin, the decider and +every party's team (`involved`), so the other parties are told `◆ @web raised a conflict naming +you (p…), for a manager above to decide: …` (not woken). A decided conflict appends to each +party's team log a ruling, `Entry{Kind: directive, From: manager | you, To: <handle>, Member: +<key>, Packet: <id>, State: decided, Text: "ruling on the conflict p…, by ◆ @boss (manager of +"harbor"): JSON: <consequence>. Because: … The conflict was: …"}`, whoever decided it (the +manager's `team_decide`, a manager above after `team_escalate`, or the person on the teams +page, here or over `--host` through the engine's own `Decide`). `teams.IsRuling(e)` is the one +reader. The session delivers a ruling to the party it names (`Member`, else `To`) whatever it +is in that team, member or manager, shared or not, as `◆ ruling on … Follow it unless the +person said otherwise in this conversation.`, and it wakes that party (`teamWakes`). The +decided packet line hands the parties nothing more, so a ruling is delivered once. `mayDecide` +refuses a manager who is one of the parties (`ErrNotDecider`); the person still may. A +manager handed a conflict sees `parties: @web, @api` and may `team_read` a party in a team +under its own as `team/@handle` (a read reaches down the tree; it changes nothing). + +**One level.** `team_send` (directive or note) and `team_stop` naming a handle that is not the +manager's own member but a member of a team under it are refused with the sentence that names +whom to send to: `@parser is in "backend", a team under yours, and orders go one level down: it +takes them from the manager of "backend", not from you. Nothing was sent. Send a message to +@api, which passes on what it should.` A sub-team's manager who is not a member of the parent +(a tree the person nested by hand) is named as such; a member of a sub-team with no manager is +told to ask the person for one. `everyone` was already the manager's own members. + +**The global manager** (`teams` `root.go`). While the root has a manager, tidy seats every open +top-level team's manager as a member of the root with its own handle when free (only ever +added), and `(*File).TopManagers()` is the root's members who manage an open top-level team now. +The session's view of the root for its manager (`managedView`) is its manager and +`TopManagers()`, never their members: the roster, the digest, `team_status`, `team_send`, +`team_stop` and `everyone` all read it. The top-level managers therefore take its directives by +ordinary delivery, report to it by the ordinary home rule (their questions reach it before the +person), and conflicts across trees meet at it. `team_start` of kind team at the root makes a +top-level team. With no root manager nothing changes. + +**The unmanaged sub-team.** A member of a team with no manager whose nearest open ancestor has +one (`bossOf`) is a managed member (`teamRole.boss`, `bossName`): it has `team_post` and +`team_raise`, its clarifying questions go up as packets to that manager (origin its own team), +and its `team_post` to the manager is written to that manager's team log, marked `(from +"dock", a team under yours with no manager of its own)`. Its room posts stay in its own team. +That manager does not direct it. + +**Roles.** A sub-team manager's role note says `Your team is a team under "harbor": you report +to its manager, @boss. Post to it with team_post; your questions go to it before the person.`, +a top-level manager under a global manager `Your team is a top-level team, under the global +manager of "All teams": …`, and a manager with sub-teams `Teams under yours: "backend" (run by +@api). Direct their managers, never their members.` The global manager is told `You are the +global manager: "All teams" holds every team, and your members are the managers of the top-level +teams, never their members. …`. A top-level manager's membership of the root is told it reports +to the global manager. A member of an unmanaged sub-team is told whom it answers to. The laws are +seven: law 4 says one level down, law 7 says how a conflict travels. Members' notes gained one +sentence (`A conflict you cannot settle with another member or team goes up with team_raise.`). +None of this is in the fixed prefix: the verbs arm at a boundary and the role rides a note, so +`TestTheFixedPrefixStaysUnderItsBudget` and `TestTheLeanPrefixStaysUnderItsBudget` are +unchanged. + +**Over `--host`.** Nothing new crosses: every step above runs where the conversations run, and +the window's `Teams.Raise` / `Teams.Decide` are the engine's store calls, so a conflict the +person rules over `--host` writes its rulings on the engine +(`TestAConflictRuledOverTheWireReachesEveryPartyOnTheEngine`). + +**For the interface (d3u).** A start line may carry `team` (a sub-team start: draw `◆ started +@api to run backend`); carrying it out is unchanged. A ruling is a directive with `packet` set +(`teams.IsRuling`), in each party's team: draw it as the ruling on that packet, not as that +team's manager's own directive (`From` is `manager` for any deciding manager, `you` for the +person). Packet lines now also appear in every party's team. The root's members include the +top-level managers once it has a manager; the teams page's `All teams` header should list +`TopManagers()`. + +**Known gaps.** A root membership seated for a manager who later stops managing a top-level team +stays until the person removes it (the session's view ignores it). A sub-team start whose new +conversation never runs (the window refused the start) leaves an unmanaged child team; the +parent's Traffic shows the refused start only in the window. The root's folder for a +top-level start is whatever the interface's `teamWhere` gives the root. + +### 8.11 Nesting, as the interface built it (d3u) + +Built on `task/nest-ui` from rulings c-12 and c-13, in `internal/tui3` (`teammove.go`, +`teamdrag.go`, `teamcrew.go`) and one store file, `internal/teams/move.go`. The person's guide +is `teams-page.md`, *Moving a team inside another team, and adding a chat to a team*. + +**The store answers two questions** (`move.go`), because the session's own restructuring tools +will ask them too. `(*File).MoveCheck(ids, parent, d)` says whether teams may go inside a +parent ("" is the top level, which is the root when there is one, `MoveTarget`) and when not a +`MoveBlock` with its facts: `self`, `inside` (a team under the moved one), `closed`, `depth` +(the target's depth, the levels the moved subtree takes, the target's effective limit and its +origin), `here` (already there), `root`, `gone`. A team picked together with its parent rides +inside it (`MoveRoots`). `(*File).MoveEffects(ids, parent, d)` is what the move changes, on +tidied copies of the file: every carried conversation whose `Home` changes, every moved team +whose capped pool above it changes (the pool owner by the `teamsPool` rule), and every moved +team whose conflicts `LCA` over its own conversations changes. `(*File).Move` writes it through +`SetParent`. + +**Move into…** (`m` on the rail, or `Inside: harbor ▾` on the team's card) opens one picker: a +card with a filter box (every printable key filters; only the arrows walk), `Top level`, then +the open tree indented. Every row is drawn; a row that cannot take the move is dim and its +reason is the card's foot and the hint line, in the ruling's words +(`orbit is 2 levels deep · limit 2 · Settings`, `set on harbor` when a team set the limit). +`enter` on a dim row moves nothing. `space` on a rail row picks teams (the wall's `☑` in place +of the dot) and `m` moves them all; `esc` clears the picks. + +**The drag** is the rail's shortcut. A press on a team row selects it as a click always did; it +becomes a drag only after two cells of held movement. A member's chip or a members card row is +a drag source too, and its press waits for the release so a drag never opens it. During a drag +only a target that takes the drop is grounded, the dragged row is dim, the first blank row under +the tree reads `↳ Top level` (the empty rail under the tree is the top level), and the hint +says `Drop to move api into harbor` or the block's reason. A member dropped on a team is +ADDED (`AddMember` with what its own team kept of it) and never removed from where it came +from. `esc`, or a second press before the release, drops the drag. + +**The consequence line.** Every move goes through one door (`teamMoveAsk`): with no changes it +is written at once; otherwise one line on the pane (or on the card) says +`api will report to harbor's manager · its $3/day becomes part of harbor's $10 pool` with +`Move` (the accent, where the keyboard lands) and `Cancel` (`esc`). A conflicts clause is said +only when the conflicts go somewhere the report clause has not named. Every move, confirmed or +not, is offered back for `teamsUndoFor` (six seconds) with `Undo` or `u`: the old parents are +written back, and every carried conversation's home flag is put back where the membership can +still hold one. The pane shows one Undo at a time, the newer of a close and a move. + +**`+ New team in harbor`.** With a team chosen the rail's `+ New team` makes the team inside it +(the wall's naming card says `New team in harbor`), and writes `SubTeamCap(parent)` as its own +cap when that is above zero, as the session's `team_start` of kind team does. A rail too narrow +for the words draws two rows rather than cutting the name. A team at its depth limit dims the +row and its hint and press say why. + +**The switcher and the wall.** The strip's switcher lists the open tree, each sub-team indented +under its team. The wall's Teams row stays flat and names a nested team `harbor › api`, each +part cut on its own so the team's own name is never the part lost. + +**Traffic (8.10's asks).** A start carrying `Team` reads `◆ started @api to run backend`, +and the name is read from the teams held in memory when the rail is drawn, so a rename +does not leave `to run` on the old name. A +ruling (`teams.IsRuling`) reads `◆ ruling → @web` (or `you ruling`) with the decision's words +and the packet named in the hint, never as the team's own manager's `do`. + +**Where it departs, and why.** + +- **`m` is Move into…, so starting a manager moved to `M`.** The ruling names the letter; a + manager is started once per team, a move whenever the tree is reshaped. +- **The picker is a card over the frame, not a menu hung from the row**, because the same + picker opens from the team's card, which is itself a card in the middle of the frame. +- **A drag from a team row still selects it on the press.** The shared place laws hold that a + press on a row does what `enter` on it does; a team's select is harmless under a drag, while a + member's door (which opens a conversation, possibly leaving the page) waits for the release. +- **The members card's rows, not the header's chips, are the everyday member drag source**, + because idle members (most of them) are only on the card. +- **A consequence line wraps on a narrow pane** rather than cutting the thing being decided; the + buttons follow the last line, or stand on their own row when it is full. + +**Traffic of a move.** A committed move appends one `KindEvent` to each affected team's log, +through the store, beside the write (`MoveNotices`, `MemberMoveNotices`, `WriteMoveNotices`). +The team left and the team that moved say `@handle moved to harbor`. The team joined says +`@handle joined from ops`. For a team moved under another, that is the moved team and its new +parent (and the parent it left, when it had one). A refused move appends nothing. The lines are +from `system` to `everyone` with no member state, so the existing Traffic read hands them to a +manager on its next wake and they do not start a wake of their own. + +**Known gaps.** The picker has no pointer scroll; a list longer than the frame scrolls with the +cursor only. Multi-select is keyboard only (`space`); there is no pointer gesture for picking. Over `--host` +the move writes through the seam like every edit, but the defaults the picker reads for the +depth limit are the engine's only once the page has read them (`Teams.Defaults`); before that a +depth block is not shown and the store's own `SetParent` is the only check. + +## The standing card says what it is + +A proposal card names its kind on the first line, then what it does, then when and what one time costs. The words live in `session.StandingOptions` so the conversation, home, `--host` and the recorded `labels` say the same thing. + +- A reminder (`when.at`): `wants to remind you`. `Remind me <when>`, `Change…`, `Don't remind me`. No once. +- A repeating check (`when.every`): `wants to set up a repeating check`. `Set it up · <cadence>`, `Change…`, `Only now, don't repeat`, `Don't set it up`. +- A watch (file, idle, probe): `wants to watch for something`. `Watch for it`, `Change…`, `Check once now`, `Don't watch`. +- A rule (`when.hold`): `wants to keep a rule`. `Keep this rule`, `Change where…`, `Don't keep it`. No once. + +Keys stay `1` yes, `3` once, `0` no. Once is never the cursor rest. On a narrow row the cadence drops off the yes before the label is cut, and the no is never the chip that is dropped. diff --git a/internal/config/derivation_test.go b/internal/config/derivation_test.go index c0728fe6cb..70f0cd7ac4 100644 --- a/internal/config/derivation_test.go +++ b/internal/config/derivation_test.go @@ -325,6 +325,14 @@ var settingReaders = map[string]string{ // and lanes.go). The chooser reads the pin too, through the same reader. LaneSettingKey(LaneSlotTalk): "LaneAt", KeyLaneGuard: "LaneGuardAt", + // The five team defaults are read together by internal/teams' DefaultsAt, + // which hands them to the resolver that walks a team's parent chain; they + // are one snapshot for [KeySSHControlPersist]'s reason. + KeyTeamsQuestionsUp: "TeamDefaultsAt", + KeyTeamsCapUSDDay: "TeamDefaultsAt", + KeyTeamsDepthLimit: "TeamDefaultsAt", + KeyTeamsSubSharePct: "TeamDefaultsAt", + KeyTeamsWake: "TeamDefaultsAt", } // Every persisted row names a reader, and every named reader is really there. diff --git a/internal/config/selfservice.go b/internal/config/selfservice.go index eae09440b9..ec0fe2c835 100644 --- a/internal/config/selfservice.go +++ b/internal/config/selfservice.go @@ -102,6 +102,18 @@ var selfServiceGuards = map[string]string{ KeyTaskMinFreeMB: guardPressure, KeyBashBackgroundAfter: guardPressure, + // The team defaults: a team's day and the share a sub-team is handed are + // money; how deep a manager may build teams is how much unattended work it + // may start; and whether a member's question goes to its manager rather + // than to you is the consent question asked one level up. A manager is a + // model, and each of these is a rail on managers. + KeyTeamsCapUSDDay: guardSpending, + KeyTeamsSubSharePct: guardSpending, + KeyTeamsDepthLimit: guardPressure, + KeyTeamsQuestionsUp: guardConsent, + // Waking starts a model turn nobody typed: unattended work, so pressure. + KeyTeamsWake: guardPressure, + KeyTaskAudit: guardProof, // The signature itself has no row; what is left of it is whether the // `Assisted-by` line names the model, and that is the person's to decide. diff --git a/internal/config/selfservice_test.go b/internal/config/selfservice_test.go index 52b3916090..446faf836b 100644 --- a/internal/config/selfservice_test.go +++ b/internal/config/selfservice_test.go @@ -40,6 +40,8 @@ func TestTheRestraintRowsAreNotSelfService(t *testing.T) { KeyTaskRepairRounds, KeyWorkingSet, KeyContextReuse, // How hard the machine may be worked. KeyTaskParallel, KeyTaskMaxLoad, KeyTaskMinFreeMB, KeyBashBackgroundAfter, + // What every team inherits: a manager is a model. + KeyTeamsCapUSDDay, KeyTeamsSubSharePct, KeyTeamsDepthLimit, KeyTeamsQuestionsUp, KeyTeamsWake, // Whether the work is checked, and how it is signed. KeyTaskAudit, KeyAttributionModel, // The credentials. diff --git a/internal/config/settings.go b/internal/config/settings.go index 9bda64e36b..0096d96cd4 100644 --- a/internal/config/settings.go +++ b/internal/config/settings.go @@ -76,6 +76,10 @@ const ( // CategoryTasks is how work you can walk away from is run — how it starts, // how it is checked, how much of it happens at once, and on whose hands. CategoryTasks = "tasks" + // CategoryTeams is what every team inherits when it says nothing of its + // own: who answers a member's question, what a team may spend in a day, + // and how deep teams may nest (teamdefaults.go). + CategoryTeams = "teams" // CategoryPractice is what codeaf does with its own time, and what it // remembers of yours. CategoryPractice = "memory & practice" @@ -98,7 +102,7 @@ const ( // safety and tasks follow it in the order the design's own hierarchy names. var SettingCategories = []string{ CategoryModels, CategorySpending, CategorySafety, CategoryTasks, - CategoryPractice, CategoryInterface, + CategoryTeams, CategoryPractice, CategoryInterface, } // Persisted keys are also the json field names in the profile's config.json. @@ -2765,6 +2769,7 @@ func (s *Settings) build() []Setting { write: func(raw string) error { return writeChoice(dir, KeySSHIPQoS, raw, SSHIPQoSChoices) }, }, ) + rows = append(rows, teamRows(dir)...) return rows } diff --git a/internal/config/teamdefaults.go b/internal/config/teamdefaults.go new file mode 100644 index 0000000000..6a372ae90e --- /dev/null +++ b/internal/config/teamdefaults.go @@ -0,0 +1,195 @@ +package config + +import ( + "fmt" + "strconv" +) + +// ── THE TEAMS GROUP: WHAT EVERY TEAM INHERITS WHEN IT SAYS NOTHING ───────── +// +// A team may override five things about how work is delegated to it +// (internal/teams' teamsettings.go): whether team traffic wakes its idle +// conversations, whether its members' questions go up to its manager first, what it may spend in a day, how deep teams may nest under +// it, and what share of its own cap a new sub-team is handed. A team that sets +// none of them inherits each from its parent, and the top of every chain +// inherits from these five rows. So these are DEFAULTS and nothing else: no +// session reads them to decide anything except through internal/teams' +// resolver, which reports beside every value where it came from, so a card can +// say `$5/day · from Settings` without guessing. +// +// THEY ARE FLAT KEYS UNDER `teams.`, because config.json is a flat dotted map +// ([readProfileConfig]); a nested `teams` object would read as unset with no +// error and every team would fall to the built-in default. + +// The five rows' keys. +const ( + KeyTeamsQuestionsUp = "teams.questions_up" + KeyTeamsCapUSDDay = "teams.cap_usd_day" + KeyTeamsDepthLimit = "teams.depth_limit" + KeyTeamsSubSharePct = "teams.sub_share_pct" + KeyTeamsWake = "teams.wake" +) + +// The built-in defaults. +// +// QUESTIONS GO UP by default, because that is the ruling's goal: a person who +// talks to the top manager and steps away should be asked only what no manager +// could answer. A day's cap is OFF by default, for the reason every rail in +// this build ships large or off ([DefaultSpendRailUSD]): a cap nobody chose +// would stop work nobody asked to stop. Depth is three levels, the ruling's +// "about three". A new sub-team gets half its parent's cap. +const ( + DefaultTeamsQuestionsUp = true + DefaultTeamsCapUSDDay = 0.0 + DefaultTeamsDepthLimit = 3 + DefaultTeamsSubSharePct = 50 + // DefaultTeamsWake is on: a directive that waited for the person to type + // in the member's tab would make a manager a mailbox. + DefaultTeamsWake = true +) + +// The bands the two counts are kept inside. A depth of 1 is teams with no +// sub-teams at all; ten levels is past anything a person could follow. A +// share is a whole percentage of the parent's cap, and 0 would be a sub-team +// that can spend nothing, which is a stopped team rather than a share. +const ( + teamsDepthMin = 1 + teamsDepthMax = 10 + teamsShareMin = 1 + teamsShareMax = 100 +) + +// TeamDefaults is the five rows resolved: the persisted value where there is +// one inside its band, and the built-in default everywhere else. +type TeamDefaults struct { + QuestionsUp bool + // CapUSDDay is dollars per local day for a team and everything under it; + // 0 is no cap. + CapUSDDay float64 + // DepthLimit is how many levels a chain of teams may have, the top + // counting as one. + DepthLimit int + // SubSharePct is the whole percentage of its parent's cap a new sub-team + // is given. + SubSharePct int + // Wake is whether team traffic wakes an idle conversation: a directive its + // member, a member's reply its manager. + Wake bool +} + +// TeamDefaultsAt resolves the five rows in one read of the profile, for +// internal/teams' [teams.DefaultsAt]. A value outside its band reads as the +// default rather than refusing a team over a hand-edited file. +func TeamDefaultsAt(profileDir string) TeamDefaults { + out := TeamDefaults{ + QuestionsUp: DefaultTeamsQuestionsUp, + CapUSDDay: DefaultTeamsCapUSDDay, + DepthLimit: DefaultTeamsDepthLimit, + SubSharePct: DefaultTeamsSubSharePct, + Wake: DefaultTeamsWake, + } + if value, ok := persistedBool(profileDir, KeyTeamsQuestionsUp); ok { + out.QuestionsUp = value + } + if value, ok := persistedFloat(profileDir, KeyTeamsCapUSDDay); ok && value >= 0 { + out.CapUSDDay = value + } + if value, ok := persistedInt(profileDir, KeyTeamsDepthLimit); ok && value >= teamsDepthMin && value <= teamsDepthMax { + out.DepthLimit = value + } + if value, ok := persistedInt(profileDir, KeyTeamsSubSharePct); ok && value >= teamsShareMin && value <= teamsShareMax { + out.SubSharePct = value + } + if value, ok := persistedBool(profileDir, KeyTeamsWake); ok { + out.Wake = value + } + return out +} + +// teamRows are the Teams group, in the order a person reaches for them: who +// answers a question and whether messages wake, then money, then the shape of +// the tree (how deep it may go, then what a new branch of it is given), which +// is the order a team's own card lists its overrides in (DESIGN.md section 8). +func teamRows(dir string) []Setting { + return []Setting{ + { + Key: KeyTeamsQuestionsUp, Category: CategoryTeams, Kind: SettingBool, + Label: "questions go to the manager", + Hint: "when a team has a manager, a member's clarifying question goes to that " + + "manager first and reaches you only if the manager cannot answer it. " + + "Permission prompts always come to you. A team can override this.", + read: func() string { return formatBool(TeamDefaultsAt(dir).QuestionsUp) }, + write: func(raw string) error { return writeBool(dir, KeyTeamsQuestionsUp, raw) }, + }, + { + Key: KeyTeamsWake, Category: CategoryTeams, Kind: SettingBool, + Label: "team messages wake", + Hint: "a manager's directive starts an idle member's turn, and a member's " + + "reply starts the manager's. Off, everything still arrives, at the next " + + "turn each conversation takes. A team can override this.", + read: func() string { return formatBool(TeamDefaultsAt(dir).Wake) }, + write: func(raw string) error { return writeBool(dir, KeyTeamsWake, raw) }, + }, + { + Key: KeyTeamsCapUSDDay, Category: CategoryTeams, Kind: SettingDollars, + Label: "team daily cap", EmptyLabel: "no cap", + Hint: "what a team and every team under it may spend in a day before its " + + "manager asks you whether to go on. 0 is no cap. A team can set its own.", + read: func() string { return moneyValue(TeamDefaultsAt(dir).CapUSDDay) }, + write: func(raw string) error { return writeDollars(dir, KeyTeamsCapUSDDay, raw) }, + }, + { + Key: KeyTeamsDepthLimit, Category: CategoryTeams, Kind: SettingCount, + Label: "team depth", Unit: "levels", UnitOne: "level", + Hint: "how many levels of teams a manager may build by starting sub-teams, " + + "the top team counting as one. 1 means no sub-teams.", + read: func() string { return strconv.Itoa(TeamDefaultsAt(dir).DepthLimit) }, + write: func(raw string) error { + return writeTeamsBand(dir, KeyTeamsDepthLimit, raw, teamsDepthMin, teamsDepthMax) + }, + }, + { + Key: KeyTeamsSubSharePct, Category: CategoryTeams, Kind: SettingCount, + Label: "sub-team share", Unit: "%", + Hint: "the share of its parent's daily cap a new sub-team starts with. It is " + + "written on the sub-team when it is made, so changing this later moves " + + "no team that already exists.", + read: func() string { return strconv.Itoa(TeamDefaultsAt(dir).SubSharePct) }, + write: func(raw string) error { + return writeTeamsBand(dir, KeyTeamsSubSharePct, raw, teamsShareMin, teamsShareMax) + }, + }, + } +} + +// ApplyTeamDefault writes one `teams.` row in profileDir the way the settings +// tab writes it: the registry row's own Apply, so the bands, the empty cap and +// the refusal words are the row's and not a second copy. A key that is not one +// of the five defaults is refused and nothing is written. The settings tab +// over --host asks the engine to call this on the engine's profile, which is +// the file the far session's teams actually inherit. +func ApplyTeamDefault(profileDir, key, raw string) error { + switch key { + case KeyTeamsQuestionsUp, KeyTeamsWake, KeyTeamsCapUSDDay, KeyTeamsDepthLimit, KeyTeamsSubSharePct: + default: + return fmt.Errorf("%s is not a team default", key) + } + row, ok := NewSettings(SettingsOptions{ProfileDir: profileDir}).Row(key) + if !ok || row.Category != CategoryTeams { + return fmt.Errorf("%s is not a team default", key) + } + return row.Apply(raw) +} + +// writeTeamsBand persists a whole number inside [low, high], refusing in the +// row's own words anything outside it. +func writeTeamsBand(profileDir, key, raw string, low, high int) error { + value, err := parseCount(raw) + if err != nil { + return err + } + if value < low || value > high { + return fmt.Errorf("that's not between %d and %d", low, high) + } + return writeProfileValue(profileDir, key, value) +} diff --git a/internal/config/testdata/profile-keys.ledger b/internal/config/testdata/profile-keys.ledger index 4d6c828b2f..b7bd45ff4d 100644 --- a/internal/config/testdata/profile-keys.ledger +++ b/internal/config/testdata/profile-keys.ledger @@ -90,6 +90,11 @@ task.parallel task.repair_rounds task.settle task.start +teams.cap_usd_day +teams.depth_limit +teams.questions_up +teams.sub_share_pct +teams.wake telemetry tenure_after tools.approval diff --git a/internal/e2e/tui_e2e_test.go b/internal/e2e/tui_e2e_test.go index b863096ef4..febb26a3dd 100644 --- a/internal/e2e/tui_e2e_test.go +++ b/internal/e2e/tui_e2e_test.go @@ -693,7 +693,7 @@ func testAskHere(t *testing.T) { time.Sleep(1500 * time.Millisecond) settled = r.capture() t.Logf("the settled exchange, reopened:\n%s", settled) - if !strings.Contains(settled, say(t, "standYesWord")+" · "+say(t, "standSetWord")) { + if !strings.Contains(settled, say(t, "standRemindYes")) || !strings.Contains(settled, say(t, "standSetWord")) { t.Errorf("the settled card does not carry the answer and its verdict:\n%s", settled) } if !strings.Contains(settled, say(t, "homeAskStoodWord")) { diff --git a/internal/e2e/tuiwords_test.go b/internal/e2e/tuiwords_test.go index 473738ae4e..1a3a141844 100644 --- a/internal/e2e/tuiwords_test.go +++ b/internal/e2e/tuiwords_test.go @@ -300,8 +300,9 @@ var tuiWords = map[string]tuiWord{ why: "the pane saying the exchange is filed under what it made", }, "exchangeAnswerHint": { - screen: "1 yes, set it up · 0 no · o other", - source: "yes, set it up", + screen: "Don't remind me", + source: "Don't remind me", + pkg: "internal/session", why: "the answers a ONE-OFF REMINDER's card offers, spelled in full under the box at every width. " + "There are two rows and the key that asks for the box: a reminder has no `3 just once` to give, " + "and since #189 the line is built from the answers the question carries rather than typed out, so " + @@ -321,9 +322,10 @@ var tuiWords = map[string]tuiWord{ screen: "enter or tab answer this ", why: "the hint while the cursor stands on an errand row that is asking something", }, - "standYesWord": { - screen: "yes, set it up", - why: "the first chip on a standing card, and half of the settled card's `yes, set it up · set up`", + "standRemindYes": { + screen: "Remind me", + pkg: "internal/session", + why: "the yes on a one-off reminder, which is what the errand in this suite asks for", }, "standSetWord": { screen: "set up", @@ -378,7 +380,7 @@ var tuiWords = map[string]tuiWord{ // THE PHASE CLOCK COMPOSES BOTH OF ITS SENTENCES AT THE DRAW, out of halves // two packages own (internal/tui3's phase.go, and the clock that feeds it in // internal/provider). So each half is its own row and the suite asserts the - // join, which is the shape `standYesWord` and `standSetWord` already have. + // join, which is the shape `standRemindYes` and `standSetWord` already have. // What varies is not a needle: the machine that went quiet is whatever this // run pinned, and the provider a rescue would go to is whatever the frontier // named. What stands still is the clause around them. diff --git a/internal/manual/chat/asking-from-home.md b/internal/manual/chat/asking-from-home.md index f749576b35..f7d4405577 100644 --- a/internal/manual/chat/asking-from-home.md +++ b/internal/manual/chat/asking-from-home.md @@ -199,8 +199,10 @@ the list`, with the card's own answers in front of it when a card is up and **The answers in that line are the ones the card actually drew, and never one more.** A card that offers all three reads -`1 yes, set it up · 3 just once · 0 no · o other`; a one-off reminder's card, -which has no `just once` to give, reads `1 yes, set it up · 0 no · o other`. +`1 Set it up · Mondays at 9am · 3 Only now, don't repeat · 0 Don't set it up · o Change…`; +a one-off reminder's card, which has no once to give, reads +`1 Remind me at 6 · 0 Don't remind me · o Change…`. The once button used to say +`just once`, which also read as "set it up once". The line is built from the question rather than written out, so it cannot name a digit that would do nothing. @@ -275,7 +277,7 @@ window is in no project at all. A reminder belongs to no repository; a watch on row is drawn at the top of the list whichever project it ended up in, and the project it belongs to is what the errand's own record says. -## How do I answer the card, or say no to it — 1 yes, o other when or where, 3 just once, 0 no +## How do I answer the card, or say no to it. 1 yes, o Change, 3 once, 0 no When the exchange gets far enough to propose something that keeps working, a card appears in the pane with your own words, when it would wake, and what it would cost per run. Nothing is @@ -286,10 +288,11 @@ created until you answer it: your own words ("make it 8pm", "every weekday") and the model proposes again. Nothing is created by a change. (This was `2` before the card's answers moved onto the question every screen here draws; `c` is that question's own key for "not as it stands".) -- `3` — once. The action runs now and nothing standing is created. **Not every card offers - it**: a one-off reminder draws no `3 just once` chip, because doing "remind me at six" - now says the wrong thing hours early. The hint under the box names the digit only where - the chip is on the card. +- `3`. Once. The action runs now and nothing standing is created. On a repeating + check the button reads `Only now, don't repeat`. **Not every card offers it**: a + one-off reminder draws no once chip, because doing "remind me at six" now says the + wrong thing hours early. It used to say `just once`, which also read as "set it up + once". The hint under the box names the digit only where the chip is on the card. - `0` — no. Nothing is created and nothing is run, the card settles as `not set up`, and the keyboard goes back to the list. **This is the only way to say no in this pane**: `esc` here hands the keyboard back to the list without answering anything, and a card left standing on @@ -304,9 +307,9 @@ on home says `? waiting on you` for as long as it does. **The card stays after you answer it.** It does not disappear — it settles in place, greys out, and its bottom edge carries what was decided in the same words a card in a conversation -uses: `yes, set it up · set up`, `just once · done now, nothing kept`, -`change when or where · you asked for something different`, -`not set up`, `ended · nothing was set up`. The answers go, so `1`, `3`, `0` and `c` are +uses: `Set it up · Mondays at 9am · set up`, `Only now, don't repeat · done now, nothing kept`, +`Change… · you asked for something different`, +`not set up`, `ended · nothing was set up`. The answers go, so `1`, `3`, `0` and `o` are ordinary characters again and can be typed into a follow-up. The only card that ever replaces it is the new one the model sends after a change. diff --git a/internal/manual/chat/attaching-files.md b/internal/manual/chat/attaching-files.md index 5756342726..7320478ebf 100644 --- a/internal/manual/chat/attaching-files.md +++ b/internal/manual/chat/attaching-files.md @@ -546,3 +546,25 @@ own record, so on a connection that has no file door it still says as it opens: ``` these are the files made on this machine — what that session made is written down on the other one ``` + +## Mention a file, a team or another chat with @ + +Type `@` in the message box. The list under it has three words on the first row, +**team**, **chat** and **file**, then teams, conversations, tasks, and files. Typing +filters every section at once. `@file:` keeps only files, `@team:` only teams, +`@chat:` only conversations. The three words are buttons: a press types that prefix, +the word under the pointer takes a background, and the hint names the key, `click`. + +Choosing a file still puts `@` and the path in the sentence, and nothing is read +until the model asks. Choosing a team puts `●harbor` in the team's colour. Choosing +a conversation puts `@handle`, or a short slug of the title when it has no handle, +and the hint on the row is the full title. A conversation that is in no team is +still on the list. + +After you send, that team mark and that `@handle` stay clickable. A press on the +team opens the teams page with it selected. A press on the conversation opens it. Over +`--host`, against an engine with no teams doors, a press on the team opens the +conversations view on it instead. The +model is handed a short digest of each one, not the transcript, and the other +conversation is not messaged and not woken. The words in your transcript are the +words you typed. diff --git a/internal/manual/chat/commands.md b/internal/manual/chat/commands.md index 8e2a43fbc8..7fa69f74bf 100644 --- a/internal/manual/chat/commands.md +++ b/internal/manual/chat/commands.md @@ -192,8 +192,10 @@ Canonical word, the other words it answers to, its argument form, and what it do | `/history` | — | — | opens the full-screen sessions place — every task this machine has run, filterable (also ctrl+.) | | `/status` | `/info`, `/context` | — | prints every fact the status line knows, one per line | | `/status` | `/info`, `/context` | `--json` | prints the same facts as one JSON object, keys in the same order | -| `/search` | — | — | opens the search place — everything said on this machine (also `alt+7`) | -| `/spend` | — | — | opens the spend place — what this machine has cost, by the day (also `alt+3`) | +| `/search` | none | none | opens the search place, everything said on this machine (also `alt+9`) | +| `/spend` | none | none | opens the spend place, what this machine has cost, by the day (also `alt+5`) | +| `/wall` | | | every open conversation at once, as a grid of live tiles, and the teams you group them into (also `alt+v`, or `▦` under the box) | +| `/teams` | | | the teams page: your teams as a tree, what waits on you, and the selected team's manager conversation (also `alt+2`, or `teams` on the tab bar) | | `/cost` | `/usage`, `/tokens` | — | prints what this conversation has spent, and on what | | `/budget` | `/limits` | — | what codeaf may spend · every limit on one tab | | `/budget` | `/limits` | `<amount>` | sets the day's limit · `none` removes it | @@ -226,16 +228,16 @@ Under the table `/help` prints the keys that have no slash command, including `alt+enter`, and `d` inside `/permissions`. The keys page covers those in full. The `ctrl+c` line reads `ctrl+c quits everything · mid-turn it interrupts instead, like esc`. -**It also names the way into the seven places**, which it did not for a long while — three +**It also names the way into the eight places**, which it did not for a long while: three rows, directly under the `tab` row: ``` -alt+1…7 go to a place · in the tab bar's own order: home tasks standing memory spend search settings +alt+1…9 go to a place · in the tab bar's own order: home teams chats sessions spend settings standing memory search alt+. on a place: what else is here · every key that place has, drawn on a place, tab is the next place · esc back ``` -On a Mac those read `opt+1…7` and `opt+.`; the substitution happens once, at the moment of +On a Mac those read `opt+1…9` and `opt+.`; the substitution happens once, at the moment of drawing, and the words are the same. **One gesture, one spelling.** Wherever the sheet names the escape key it writes `esc @@ -758,13 +760,13 @@ and the note's leading `· `; strip those before feeding it to a parser. ## /search and /spend — the typed doors onto those two places `/search` opens the **search place** — everything that has been said on this machine, -found by the words you remember of it. It is the same place `alt+7` opens and the same +found by the words you remember of it. It is the same place `alt+9` opens and the same place `tab` walks to. It takes no argument: the place *is* a box, and typing in it searches. With the **memory** row off nothing said is indexed, and the place says so and searches nothing — find the conversation from home's box instead (see the *places* page). `/spend` opens the **spend place** — what this machine has cost, by the day, by the model -and by what it was for. It is the same place `alt+3` opens. +and by what it was for. It is the same place `alt+5` opens. **`/spend` used to be an alias of `/cost` and is not any more.** The two answer different questions: `/cost` is *this conversation's* bill, printed into the conversation, and the @@ -1111,7 +1113,7 @@ box, opens it on a one-conversation machine and on an empty one alike, and over it opens the far machine's. There is no argument form. There are three other ways in: **`alt+1`**, home being the first -of the four places on the tab bar; **`space` twice** on an empty box; and **`tab`** from any +of the six words on the tab bar; **`space` twice** on an empty box; and **`tab`** from any other place. **It is seven panels**, in one column under 110 cells, two from 110 and three from 170, @@ -1446,7 +1448,7 @@ is built from this session's own work, and carries only a short dulled note of t **It is not `/tasks`, and there is no `/tasks` command.** `/task <brief>` and its `solo` form mean *give codeaf work*; this page starts none, so it does not share their word. Typing `/history` is the only slash form — but the PLACE this opens is called `tasks` on the tab -bar, and **`alt+2`** and `tab` reach it without a command at all. The word is a place, not a +bar, and **`alt+4`** and `tab` reach it without a command at all. The word is a place, not a command. Two sections. `running` is the tree of everything still going, drawn whole, with each task's @@ -1659,13 +1661,31 @@ So a value set here follows you between projects, and a value a project sets for has to be edited by hand in that file. When a project answers the same row, a write through `change_setting` says so rather than reporting a change that is not in force. -Over `--host`, opening the panel first notes: +Over `--host`, opening the panel on any tab but Teams first notes: ``` -these rows are this machine's — the ones that govern the conversation are read from the profile on the other one +these rows belong to this machine; the Teams tab is saved on the other one. ``` -and then opens anyway. +On the Teams tab the note is `these rows are saved on <machine>.` An older engine, where +that tab cannot be saved over the connection, notes: + +``` +these rows belong to this machine; this conversation reads its profile on the other one. +``` + +The panel opens anyway. + +## Can I edit team defaults over --host + +The **Teams** tab is the one section that edits the other machine. Over `--host` its five +rows (`questions go to the manager`, `team messages wake`, `daily cap per team`, +`team depth`, `sub-team share`) are that machine's defaults, and a change is saved there. +Each value says `from Settings`, the same words a team's card uses when it inherits the +row. The foot line says `a team can override any of these on its card · saved on <machine>`. + +An older engine keeps the tab read only and says +`changing them is not available over this connection`. The other tabs stay this computer's. Refusals inside the panel, exactly as written: diff --git a/internal/manual/chat/conversations-and-teams.md b/internal/manual/chat/conversations-and-teams.md new file mode 100644 index 0000000000..22bd784abb --- /dev/null +++ b/internal/manual/chat/conversations-and-teams.md @@ -0,0 +1,372 @@ +# Conversations and teams + +## The conversations view: every open conversation at once + +To see all your conversations at once, open the **conversations view**: every conversation +this window has open, as a grid of live tiles, so you can see at a glance which ones are working, which are waiting on you +and which are at rest, and go to any of them with one press. It is also where you group +conversations into **teams**. + +Open it any of these ways: + +- `alt+v` from anywhere in a conversation (on a Mac keyboard that is not sending alt, + `option+v` types `√`, and that works too) +- `/wall` +- `▦ All` at the right end of the row under the message box, drawn once a + second conversation is open (the word goes first when the row is narrow) +- `▦ All` on the tab strip, after the new-chat `+` (not drawn under 60 columns). The strip + is the second line of a chat, not of a place, so from home or teams use `alt+v` or `/wall` + +Close it with `alt+v` again, `esc`, the `‹ Back` button at the bottom left, or a press on +the strip's `▦ All`. Nothing you do in the view ends any work: closing a tile closes its +view in this window, and the conversation keeps running. + +The view and the tab strip show **what is open in this window**. The title bar says so, +`Conversations · open in this window`, or `open in this window · in harbor` while a team is +shown, and counts what is running, what needs you and how many are open here. A team's +members that this window does not have open are not tiles and not tabs; while the shown team +has any, the title bar carries one quiet button, `2 more in harbor · Open them` (or `r`), that +resumes them in the background, so they arrive as tiles and tabs while the conversation in +front and your focus stay where they are. When every member is open the button is not there. Under it is the **Teams** row, which ends in `✦ Organize` while every conversation is +shown, and at the bottom a toolbar with `Filter /`, +`New team s`, `Columns − +` and `Help ?`. While the pointer rests on any control, the middle +of the toolbar says in one dim line what it does and which key does the same; on a narrow +window `Columns` and the other buttons step aside for that line so it is always whole, and +come back when the pointer leaves. Pointing at `▦ All` says `The grid of your open tabs, and +your teams · alt+v`; pointing at a square of the tabs dock under the box names that +conversation (see below). + +**`▦ All` and the `chats` place are two different doors.** `chats` on the top line is the +place: every conversation, one at a time, with the tab strip over it. `▦ All` is this view: +the tabs this window has open, all at once, as a grid. + +## The tabs dock under the message box + +Once a second conversation is open, the row under the message box ends in `▦ All`, the +same door the tab strip has, then one square per open conversation, in the same order as +the tab strip. The square in front is `▣`. The others are `■`, coloured the way the strip colours +a tab: the live colour while it is running, amber while it is waiting on you, and dim +while it is idle. Amber is only for waiting on you. One open conversation draws no dock. + +Rest the pointer on a square and that square takes the hover ground. The hint line says +`Go to Shipping the parser · running · click`, with `waiting on you` or `idle` in the +middle. On the square in front it says `Shipping the parser · you are here`. On `▦ All` +it says `The grid of your open tabs, and your teams · alt+v`, as the strip's `▦ All` does, +and the hover ground covers the glyph and the word together: they are one button. + +A press on a square goes to that conversation and does not open this view. A press +anywhere on `▦ All` opens the conversations view, the same as `alt+v`. A press on the +square in front does nothing. On a narrow row the word `All` is the first thing to +go, leaving `▦`. The squares stay, then fewer of them with a `+N`, then the dock is not drawn. + +## Reading a tile: title, what it is doing, and the newest lines + +A tile reads top to bottom: + +- **the title** on the top border, the brightest thing in the tile, after the dots of the + teams it is in (up to three, then `+N`) +- **one dim line** saying what the conversation is doing now, like `running bash · 2m`, + `writing` or `? waiting on you · 3m`, or when it last moved, like `updated 5m ago` +- **the conversation's own newest lines**, drawn the way the conversation draws them, fading + with age so the newest are where your eye lands; lines that just arrived are lifted for a + moment and then settle +- a small **activity line** on the bottom border while there is activity to show + +A conversation this window can only show as a snapshot (over a shared connection only the one +in front is live) says `seen 6m ago` and draws no spinner. + +**A tile that needs you** has the amber border, the only amber in the view, and its body ends +in the question and an `Answer ↵` button. `n` jumps to the next one waiting on you, and the +title bar's `needs you` count does the same when pressed. + +## Pointing, focusing and opening a tile + +A press on a tile opens its conversation, the way a thumbnail opens its window. The tile +grows into the frame for a moment while the conversation is already live under it, so a key +typed at once lands in its box. + +The pointer resting on a tile lights it and turns its bottom border into its **action row**: + +`Open ↵ ── Select ␣ ── Teams m ── Close x` + +`Open` becomes `Answer` on a tile waiting on you. The keyboard has its own **focus**, drawn as +a heavy border; the arrows (or `h j k l`) move it, and the pointer never does. The focused tile +shows its action row too. + +## Selecting several conversations + +`space` (or `Select` on a tile) picks the focused conversation. Once one is picked, the view is +in **selection mode**: every tile shows its box, `☐` or `☑`, and a press anywhere on a tile +picks it or puts it back instead of opening it. + +While anything is picked, a tray rises over the bottom of the grid: +`2 selected Make team s Add to… ▾ Close views Clear esc`. + +- **Make team** starts a new team from the picked conversations +- **Add to…** opens the teams list for all of them +- **Close views** closes their views in this window; the work keeps running, and one with + work in flight is asked about first +- **Clear** (or `esc`) unpicks them all + +## Teams: named groups of conversations + +A **team** is a group of conversations you name, like `harbor` for everything about one +project. A conversation can be in any number of teams: a team is a grouping, not a place a +conversation lives. Showing a team narrows both the conversations view and the **tab strip** +to its members that are open in this window, and nothing else changes: no conversation is +opened, closed or stopped. A team's whole membership, open here or not, lives on the team: +each segment of the Teams row counts the members open here, and resting the pointer on it +says both, `harbor · 1 open here · 3 members`. + +**Making a team.** Press `s` (or `+ New team` on the Teams row, `Make team` in the tray, or +`+ New team…` in a tile's teams list). With nothing picked, the team starts with the focused +conversation. A card opens with a name and a colour already chosen: + +- if the conversations all sit in **one project folder**, the name is that folder's name +- otherwise a pleasant word is there at once, and codeaf asks the model you use for names + (the same cheap one that names conversations) once, over the conversations' titles, for a + one to three word name; `naming…` shows beside the field while it asks. What comes back + replaces the word only if you have not started typing, and if it fails or takes more than five + seconds the word stays + +Type to replace the name, `ctrl+r` for another word and colour, `←` `→` to pick among the +colours offered, `enter` to create it or `esc` to put the card away. After that the name +changes only when you change it, in the team's settings. + +**Colours.** Each team gets a generated colour, as far from the others' as it can be, and +never the colours that already mean something here: the amber of a question, the colour of +running work, the red of a failure and the cursor's accent. A team's colour is drawn as its +dot, on the tiles it holds, on the rule under the tab strip while it is shown, and on the +view's `▦` door. On a terminal without enough colours, the dot is the team's first letter. + +**Putting a conversation in and out of teams.** `m`, or `Teams` on a tile, opens a list of +every team with a box: `☑` in it, `☐` not, `▣` when some of the picked conversations are and +some are not. A box pressed is saved at once, and so is `+ New team…` at the foot. + +**Showing a team.** Press its segment on the Teams row, `tab` and `shift+tab` to step through +the teams, or `1` to `9` for a team by its place (the digit of the team already shown goes +back to All). Each team keeps its own focus and scroll while the view is up, so looking into +one team and back to All returns you to where you were. The tab you are on never vanishes from +the strip: if it is not in the team, it stays at the end. + +**A conversation started while a team is shown joins it.** `/new`, the strip's `+` and the +start page, `ctrl+t`, and a folder typed on home all start a new conversation, and it goes into +the team that is shown. Going back to a conversation that already exists changes no team. + +**Team settings.** `e`, the dot on a team's segment, or the `⋯` the pointer brings up where its +count was, opens the team's **card**: its name, which you edit as you type, its colour, +**`Inside: harbor ▾`** (which team it sits in; a press opens the Move into… picker), the +settings it overrides (each one saying where an inherited value comes from) and +**Close team…**. The **teams page** has the card whole. + +**Teams inside teams.** A team can sit inside another. The Teams row stays one flat row and +names a team inside another with its parent first, `harbor › api`; the team switcher and the +teams page draw the tree. You move a team on the **teams page** (`m`, Move into…, or a drag in +its rail) or with `Inside` on its card, and every move can be undone for a few seconds. + +## Moving a conversation between teams is written to Traffic + +Moving a conversation from one team to another writes one Traffic line on each side: +`@web moved to harbor` on the team it left, `@web joined from ops` on the team it joined. +Moving a whole team under another writes the same kind of line on the team that moved and on +its new parent. A move that does not go through writes nothing. The manager of a team that +gained or lost a member is told on its next wake, from the Traffic it already reads. + +**Closing a team.** `D` closes the team that is shown: at once, with Undo, when nothing in it +is running, and with a card offering **Wrap up first**, **Close now** and **Cancel** when +something is. A closed team leaves the Teams row and the switcher and waits under +`▸ Closed · N` on the teams page, where it can be reopened, and deleted once you are sure. +Closing or deleting a team never deletes a conversation. + +## Organize: teams suggested for your conversations + +While the view shows **All**, the Teams row ends in `✦ Organize`. Press it, or `o`, and a card +suggests teams for the conversations that are open. Nothing changes until you apply it: + +``` +╭─ Organize ────────────────────────────────────────────────╮ +│ New teams │ +│ ☑ ● codeaf 5 from the folder │ +│ ☑ ● nvda research 3 cpu profiling, nvda deep…, 10-K │ +│ Add to existing │ +│ ☑ ● harbor + 2 relay audit, footprint table │ +│ │ +│ about $0.0020 Cancel esc Apply ↵ │ +╰───────────────────────────────────────────────────────────╯ +``` + +The suggestions come from two places: + +- **Folders.** Conversations that share a project folder, two or more of them, are suggested + as a team named after the folder (`from the folder`). If a team already has that name, the + ones it is missing are suggested for it instead, and a folder whose conversations are + already together in one team is left alone. This part is free and always the same. +- **The model you use for names**, asked once per press (the same cheap one that names + conversations and teams), over the conversations' titles and folders and your teams, for + groupings a folder cannot see and conversations that belong in a team you already have. + `thinking…` shows while it works, and it is given ten seconds. Where the two disagree the + folders win. The line at the bottom says about what the ask cost. + +If the model cannot be asked or does not answer, the card shows the folder suggestions alone +and says `suggestions from folders only`. With nothing to suggest it says +`Everything is organized` beside a `Close`. + +Every row starts ticked. `↑` `↓` move, `space` or a press ticks and unticks a row, `enter` or +**Apply** makes the ticked ones in one go, and `esc`, **Cancel** or a press off the card puts +it away with nothing changed. A new team gets the name and the colour the card showed; each +new team's colour is its own. A conversation can be suggested for several teams, as it can be +in several. + +After an Apply the Teams row says what it did for a few seconds, like +`Organized · 2 new teams, 2 added Undo`. **Undo**, or `u` while it is there, puts your teams +back exactly as they were. + +When some teams have had no activity for a week and nothing waiting on them, the card also +offers **Close 3 quiet teams** under `Quiet for a week`, ticked like the rest; Apply closes +them and Undo reopens them. Apart from that Organize only ever adds: it never renames a team +and never takes a conversation out of one, so pressing it again is how you refresh the +suggestions. Nothing runs by itself. The button +counts the conversations in no team once there are five or more, `✦ Organize 7`, and after a +run that found nothing to suggest it reads `Organized ✓` until your conversations or teams +change; it can still be pressed. + +## The team switcher on the tab strip + +While a team is shown, the tab strip carries a chip naming it, `● harbor ▾`, first on the +strip and right before the tabs it narrows, with the manager's place after it: + +``` + ● harbor ▾ ◆ Manager × Refactor the rail sco… × openrouter price scrape × + ▦ All +``` + +The chip is a filter over the tabs, so it sits with them. There is no `home` on the strip: +home is the first place on the top line, over the strip while a chat is in front. The +strip is not drawn on a place. When the row runs +short the chip goes, and never the tab in front. With teams but none shown, the chip is a quiet `teams ▾`; with no teams at all there +is no chip. A press on the +chip opens the **team switcher** under it, on any page the strip is on, the conversations view +included: + +``` +╭─ Teams ────────────────────╮ +│ ◉ ● harbor 2 │ +│ ○ ● orbit 1 │ +│ ○ ● dock 0 │ +│ ○ All 3 │ +│ Closed · 2 ▸ │ +│ ────────────────────────── │ +│ − Remove this conversation │ +│ + New team… │ +│ Team settings… │ +╰────────────────────────────╯ +``` + +- a team, or **All**, narrows or widens the strip; the conversation in front stays in front + unless it is not in the team, and then the team's first conversation comes forward. The + teams are the tree: a team inside another stands indented under it +- **+ Add this conversation** puts the conversation in front into the team that is shown, and + the row turns into **− Remove this conversation** +- **Closed · 2** is there while you have closed teams: a press opens the teams page with its + Closed fold open. A closed team is never one of the switcher's teams +- **+ New team…** opens the conversations view with the new-team card, the conversation in + front already picked +- **Team settings…** opens the shown team's card, over whatever page you are on + +`↑` `↓` move, `enter` chooses, `esc` or a press anywhere off it puts it away. + +## A team's manager + +A team can have one **manager**, a conversation that runs the team for you: you talk to it, it +hands work to the members and tells you where things stand. While a team is shown, the first +place on the tab strip is the manager's, pinned at the left: a quiet `+ Manager` until there is +one and `◆ Manager` after; `◆ Make this harbor's manager` in the team switcher or in a tile's +Teams list makes an existing conversation the manager. The right-hand +column of a chat in a team has two words, `Tasks` and `Traffic` (what passes in the team). A +Traffic row reads who it is from and who it is for, then how long ago, `◆ → @scrape +2 Please provide… 2m`, and in +a member's chat that member is `you` (`◆ → you`, `you → ◆`). A press on the row opens that message in the chat it belongs to. The +manager's opens on the Traffic, a member's on its tasks, `←` `→` switch them while the column has +the keyboard, `alt+l` shows or hides it, and `alt+m` goes to the manager. What a manager can do, and how members talk to each other, is on the +**team manager** page. The **teams page** (`/teams`, `alt+2`) lists every team as a tree +and puts the chosen team's manager conversation beside it, with what waits on you. + +## What clicking a team name in a chat does, and how team names and handles are links + +In a conversation that is in a team, every **handle** of a member of that team, like +`@security`, is a link wherever it appears: in a reply, in a team's quoted card, in the +surface's own notes and in a team tool's call such as `team_send @security`. So is a team's +name where it is written as a team: `team harbor`, `the harbor team` or `"harbor"`. The +pointer on one puts a ground under it and the hint line says what a press does, like +`Open @security · santosh dev2 branch code… · click`. A press opens that member, resuming it +first when this window does not have it open. A press on a team's name opens the **teams +page** with that team selected: the rail's cursor on it and the pane showing it. The hint +says `Open harbor on the teams page · click`. A closed team is selected inside `Closed`, and +that fold is opened. Over `--host`, against an engine that has no teams doors, the teams page +cannot open, so the press opens the conversations view on that team instead and the hint says +so. An `@word` that is no member's handle is left as plain text. + +## Mention a team or another conversation with @ + +In the message box, `@` opens the same list files use. Teams are a section of it, +each row a coloured dot and the team's name. Conversations are the next section: +the ones open in this window first, then recent ones. A conversation in no team is +on that list. + +The first row is the words **team**, **chat** and **file**. Each is a button with a +background under the pointer and a one-line hint (`only teams · click`). A press +types `@team:`, `@chat:` or `@file:`, and the list keeps only that section. Typing +filters every section that is still showing. + +Choosing a team inserts `●harbor` in the team's colour. Choosing a conversation +inserts `@handle`, or a short slug of its title when it has none, and the row's +hint is the full title. After you send, both stay links. A press on the team opens +the teams page with it selected. A press on the conversation opens that conversation. +Over `--host`, against an engine with no teams doors, a press on the team opens the +conversations view on it instead. + +The model receives a short digest of each reference: for a team, its members, +handles, states and recent traffic; for a chat, its title, its state and an excerpt +of the last reply. It does not receive the transcript. Mentioning a conversation +does not message it and does not wake it. Your transcript keeps the words you typed. + +## Where teams are kept + +Teams are saved in your profile, in `teams.json`, every time one changes, and never in +`config.json`. Over `--host` that is the far machine's profile, where the conversations run. A `spaces.json` from an earlier build is read once, its groups keep their +names, members and colours, and it is renamed to `spaces.json.migrated`. A teams file that +cannot be read is moved aside as `teams.json.unreadable-<number>` rather than written over, +so nothing you made is lost. + +## Every key in the conversations view + +`?` (or `Help ?`) opens a sheet of all of these, and every row on it is a button that does +what its key does. + +| Key | What it does | +|---|---| +| `alt+v` | Open or close the conversations view | +| `esc`, `q` | Back one step: the list or card that is up, then the selection, then the filter, then the view | +| `?` | The help sheet | +| arrows, `h j k l` | Move the focus | +| `g`, `G` (`home`, `end`) | First and last conversation | +| `pgup`, `pgdown` | A screen of rows; the wheel moves one row | +| `n` | Next conversation waiting on you | +| `enter` | Open the focused conversation | +| `space` | Pick the focused conversation, or put it back | +| `x` | Close the focused view, or the picked ones; the work keeps running | +| `m` | The teams list for the focused conversation, or the picked ones | +| `s` | New team of the picked conversations, or the focused one | +| `e` | The shown team's card: name, colour, settings, Close team… | +| `r` | Resume the shown team's conversations that are not open here | +| `D` | Close the shown team; its conversations stay open | +| `o` | Organize: suggest teams for your conversations (while All is shown) | +| `u` | Undo the last Organize, while the Teams row offers it | +| `tab`, `shift+tab` | Next or previous team, then All | +| `1` to `9` | That team; its digit again goes back to All | +| `/` | Filter conversations by name; `esc` clears it | +| `-`, `+` or `=` | Fewer or more columns | +| `0` | Columns back to automatic | + +In the new-team card: type the name, `ctrl+r` another name and colour, `←` `→` the colour, +`enter` create, `esc` cancel. + +In the Organize card: `↑` `↓` move, `space` tick or untick, `enter` apply, `esc` cancel. diff --git a/internal/manual/chat/getting-started.md b/internal/manual/chat/getting-started.md index bf2ff2396f..867c9fb5e0 100644 --- a/internal/manual/chat/getting-started.md +++ b/internal/manual/chat/getting-started.md @@ -308,9 +308,9 @@ ghostty with `font_family`, `[font.normal] family` and `font-family` in their co files. **Option as meta, on macOS.** Every chord codeaf binds is the option key, and on a Mac it is -drawn the way the keycap names it — `opt+enter` to send what you typed off as a task, `opt+1`…`opt+7` +drawn the way the keycap names it, `opt+enter` to send what you typed off as a task, `opt+1`…`opt+9` to jump to a place, `opt+.` for the map. (On Linux and Windows the same chords are drawn -`alt+enter`, `alt+1`…`alt+7`, `alt+.`; this manual names both spellings together.) Most Mac +`alt+enter`, `alt+1`…`alt+9`, `alt+.`; this manual names both spellings together.) Most Mac terminals send Option as an accent-composing key until you tell them otherwise, so those chords type `¡ ™ £ ≥` instead of doing anything. Turn on **iTerm2** → Profiles → Keys → *Left Option key: Esc+*, or **Terminal.app** → Profiles → Keyboard → *Use Option as Meta @@ -323,14 +323,14 @@ line: `your terminal sends opt as a letter — turn on "use option as meta" in terminal you are actually in. **The first-run setup says it too.** When the three questions are done, a Mac gets one more -line: `the seven places answer opt+1…opt+7 · if opt types a character instead, turn on "use option as +line: `the places answer opt+1…opt+9 · if opt types a character instead, turn on "use option as meta" in …`. It is a condition rather than a report — nothing has been pressed yet — and it is said once. **On kitty, ghostty and WezTerm there is also a way in with no setting at all:** those terminals report that they run the kitty keyboard protocol, and where that report arrives -`ctrl+1` … `ctrl+7` jump to the same seven places and `ctrl+.` draws the same map. The map's -own line says `alt+1…7 or ctrl+1…7 go to a place` exactly when the alias is live. +`ctrl+1` … `ctrl+9` jump to the same eight places and `ctrl+.` draws the same map. The map's +own line says `alt+1…9 or ctrl+1…9 go to a place` exactly when the alias is live. On Linux and on Windows terminals, Alt is already meta and there is nothing to set. The whole of this is also in *Screen* — see *The font codeaf is drawn for*, *alt or option or opt — diff --git a/internal/manual/chat/home.md b/internal/manual/chat/home.md index 02b798bca1..ab923eabcc 100644 --- a/internal/manual/chat/home.md +++ b/internal/manual/chat/home.md @@ -8,7 +8,7 @@ answering one question you would ask walking up to a colleague's desk: ``` codeaf $0.14 / $20 · thu 9:49am - home tasks spend settings + home teams chats sessions spend settings ─────────────────────────────────────────────────────────────────────────────────────── Understanding Hash Tables 2m projects @@ -45,7 +45,8 @@ in the right-hand rail instead — heading and one dim line each — so the left is only ever the things that are actually going on. `esc` puts you back in exactly the chat you came from, untouched — nothing was closed and -nothing was sent while you were looking. The resting foot reads +nothing was sent while you were looking; `alt+3` (`chats` on the bar) does the same. The +resting foot reads `alt+p project · alt+e effort · alt+a approvals · alt+k chats · / commands`. The project, approvals and chats hints appear only where those controls can act. The controls stay the same as the cursor walks between rows. `→` opens the selected @@ -57,7 +58,9 @@ whole map over the cells you are already reading. There is no argument form. The screen is how you name what you want; a command that took a project name would be asking you to type out the very thing home exists to show you. -Home is the **first of the four places on the tab bar** — `home tasks spend settings`. +Home is the **first place on the top line**, right after the `codeaf` wordmark: +`home teams chats sessions spend settings`. +The **teams page**, right after it, is where your teams and their managers live. It still does nothing on its own: no notifications and no alerts. You open it, you see where things stand, and you either act on something or leave. @@ -285,6 +288,13 @@ before choosing the fifteen most recent, so each conversation appears once. The `opt+k` chats menu still lists open tabs; closing or reopening a conversation updates the tab and the row in Sessions together. +## Why does home show a session id for an untitled chat, untitled conversation, new conversation + +**A conversation nothing has named yet reads `new conversation`** on home's sessions +list, the same word the sessions place uses. It never reads as its session id, including +the id with its first letter raised (`D53cceead3f99593`). A conversation that has a title +keeps that title. + ## Close or put away a task from home — task row options, new in project, open folder, copy project **`→` offers task options just as it does for threads:** `x close`, @@ -487,7 +497,7 @@ names none of them; `alt+.` draws the map when you want the rest. A digit answers the question row drawing its answers, wherever you are standing. `enter` acts on the row under the cursor. `alt+.` draws the map. -## Why is a heading highlighted, why is one project name darker than the others +## Why is a heading highlighted, which section is my cursor in, why is one project name darker than the others **Because the cursor is in that panel.** The heading of the panel holding the cursor wears the cursor's ground — one heading per frame, following the keyboard, and never the mouse. @@ -508,8 +518,8 @@ own tab stack — so going back is `enter`. A window that has held only one conv **On a launch** — home greeting you — the cursor is on the conversation this window is holding, the row `esc` drops back into. -**`↑` off the top row of home stays on it.** The tab bar — the row of four words — is -reached by clicking a word, by `tab`, or by a place's own chord (`alt+2` and the rest); on +**`↑` off the top row of home stays on it.** The tab bar, the row of six words, is +reached by clicking a word, by `tab`, or by a place's own chord (`alt+4` and the rest); on every other place `↑` off the top row still walks up onto it. On the bar `←` and `→` walk along the words without opening anything, `enter` or `↓` goes into the one under the cursor, and `esc` puts the cursor back on the row it came from. Walking up onto the bar does @@ -591,19 +601,26 @@ under it. ## The line at the top of home — the pulse, want you, moving, spend and allowance, the clock -The top line is the program's name and, right-aligned, what is true of the **whole -machine** right now. It is the first row of **every** frame — home, every place, and the -chat itself, where it sits over the tab strip (` home <your chats>`), a rule and a blank: -the same four rows at the top wherever you are standing. **Inside a chat** and on every -place but home it reads: +The top line is the program's name, the places you can go, and, right-aligned, what is true +of the **whole machine** right now. It is the first row of **every** frame: home, every +place, and the chat itself, and it does not move. Under it, **inside a chat**, is the tab +strip of your chats, then a rule and a blank: four rows. On home and every other place +there is no strip. The rule and a blank come next, three rows, and the page starts one +row higher. **Inside a chat** and on every place but home the top line reads: ``` - codeaf 2 want you · 4 moving · $0.55 / $500 · tue 1:11pm + >● codeaf home teams chats sessions spend settings 2 want you · 4 moving · $0.55 / $500 · tue 1:11pm ``` -**On home it drops the two counts** and keeps the budget and the clock — -` codeaf $0.55 / $500 · tue 1:11pm` — because the `needs you` -and `sessions` panels are those counts, row by row. +**On home it drops the two counts** and keeps the budget and the clock, because the +`needs you` and `sessions` panels are those counts, row by row. + +**On a narrow window the right end gives way first**: the clock, then `4 moving`, then +the words of `2 want you`, which becomes `2 ?` in the same amber, then the allowance +(`$0.55 / $500` becomes `$0.55`); only then do the places fold into `more ▾`, and then the +day's figure goes. **The count of things waiting on you never goes**: `2 ?` is on the line at +every width, because it is the one number you must not have to go looking for. The **Places** page of +this manual has the whole order and the `more ▾` menu. - `2 want you` — how many things have **stopped on you**: a conversation waiting for an answer, a standing order that will not fire until you say so, an errand holding a @@ -626,18 +643,19 @@ another window asks can take up to ten seconds to reach a chat's top line. **The money on this line is the money on the spend place and the `spend` panel**, to the cent — one reading of one file, wherever you are standing. -## Where did standing, memory and search go — the four places on the tab bar +## Where did standing, memory and search go: the six words on the tab bar -**They are still places; they are just off the bar.** The tab bar under the top line is four -words — `home tasks spend settings` — and `tab`, `alt+1` … `alt+4` walk them. Standing, +**They are still places; they are just off the bar.** The bar on the top line is six +words, `home teams chats sessions spend settings`. `tab` walks the five rooms among them and +`alt+1` … `alt+6` go to each; `chats` (`alt+3`) is the way back to your conversation. Standing, memory and search open exactly as they did: -- **`/standing`** (or `/orders`), `alt+5`, or `enter` on a `standing` row; -- **`/memory`** (or `/memories`), `alt+6`, or `enter` on memory's line in `since you left`; -- **`/search`**, `alt+7`, or the typed door on home's box. +- **`/standing`** (or `/orders`), `alt+7`, or `enter` on a `standing` row; +- **`/memory`** (or `/memories`), `alt+8`, or `enter` on memory's line in `since you left`; +- **`/search`**, `alt+9`, or the typed door on home's box. -While you stand in one of the three, its word is drawn after the four so you can see where -you are; `tab` from there goes to home. `alt+.` draws the map of all seven with their +While you stand in one of the three, its word is drawn after the six so you can see where +you are; `tab` from there goes to home. `alt+.` draws the map of all eight with their numbers. Home's own panels already summarise the three on the bar: `sessions` is a glimpse of tasks, `spend` of spend, `standing` of standing. @@ -1513,6 +1531,9 @@ machine with one conversation or with none still has a home to go to. The rule t home from *greeting* a first run is a different rule — not being greeted by home and not being able to reach it are two different things. +From home, `alt+3` (`chats` on the bar) goes straight back to the conversation you were +in, and `alt+k` chooses one. + ## space space does nothing — why the gesture did not open home Three reasons, and neither the machine holding nothing nor `--host` is one of them any @@ -1620,11 +1641,12 @@ The chips are the ones the question has: - It is **waiting for permission to run something**: `1 allow once 2 always 3 deny`. - It is **asking whether to start a task**: `1 yes 2 no`. -- It is **asking whether to keep an eye on something**: `1 yes 3 just once 0 not set up` - — or `1 yes 0 not set up`, when what it is asking about is a **one-off reminder**, which - has no `once` answer at all. **`0` is how you say no from home**: nothing is set up, - nothing is run, and the card in that window settles as `not set up`. There is no - `2 change when or where` here, on purpose: that answer is a request for a text box; open +- It is **asking whether to keep something going**. The chips are that card's own + words: a repeating check is `1 Set it up · <cadence>`, `3 Only now, don't repeat`, + `0 Don't set it up`. A one-off reminder has no once, and its no is `Don't remind me`. + A watch's no is `Don't watch`. A rule's no is `Don't keep it`. **`0` is how you say + no from home**: nothing is set up, nothing is run, and the card settles as `not set up`. + There is no change chip here, on purpose: that answer is a request for a text box. Open the conversation to say a different time or place. `2 always` means what it means in the window: **that session stops asking about that @@ -1670,8 +1692,8 @@ one (*Why is the home screen empty*). Over `--host` home lists **the machine your session is running on**. The projects, the conversations in them and the work each of those ran are read on the far end and carried -here, so what you are looking at is the server's afternoon rather than your laptop's — and -the right end of the tab bar says `on <machine>` so you can see which. Enter on a row opens +here, so what you are looking at is the server's afternoon rather than your laptop's, and +the right end of the top line says `on <machine>` so you can see which. Enter on a row opens that conversation beside the one you are in rather than in place of it. Two things a remote home does not do, and both are silences rather than sentences. **No row @@ -1715,7 +1737,7 @@ opens the conversation; on a `standing` row it opens the standing place. The `◦` mark itself belongs to the standing place and to a conversation's own lines — `◦ leave for the train · in 4m`. `∙` is a paused item there, and `◆` means the thing went off -after the last time you spoke in the conversation behind it. The standing place (`alt+5`, +after the last time you spoke in the conversation behind it. The standing place (`alt+7`, `/standing`) is every promise this machine has made, with how much rope each has. **Retired items are nowhere on home.** Something that fired once and finished, or that you @@ -1819,32 +1841,30 @@ standup note" — a card appears in the conversation and **nothing is set up unt you answer it**: ``` -╭─ ? ◦ every Monday at 9, post the standup ────────────────────────────────── +╭─ ? wants to set up a repeating check ────────────────────────────────────── │ every Monday at 9, post the standup note from the git log -│ when · Mondays at 9am +│ Mondays at 9am · about $0.02 a run, at most once a day │ where · for this project -│ costs · about $0.02 a run, at most once a day -│ [ 1 yes, set it up ] [ 2 change when or where ] [ 3 just once ] [ 0 no ] -│ I'll keep doing this Mondays at 9am, for this project, until you stop it ╰──────────────────────────────────────────────────────────────────────────── ``` -Three bands make it different from the card that proposes a task: **`when ·`**, in -the words you said or the words it worked out; **`where ·`**, how far it reaches; -and **`costs ·`** — what one run may spend and how often it may run. A watch that -has to *look* at something adds `checked every 5 minutes`. If it made the timing up -rather than reading it off what you said, the band asks instead of stating: -`Mondays at 9am — you didn't say, so that's my guess. Right?` +The head says what kind of thing it is. The next line is what it does. The line +after that is when, and what one time costs. **`where ·`** is how far it reaches. +A watch that has to look at something adds `checked every 5 minutes` on that +cost line. If it made the timing up rather than reading it off what you said, +the line asks instead of stating: +`Mondays at 9am. You didn't say, so that's my guess. Right?` **The answers**, by key, by `←`/`→` and `enter`, or by clicking one: -- `1 yes, set it up` — it gets set up and starts happening. -- `2 change when or where` — the box below becomes a place to say the **time or - the place** you want instead: "make it 8", "only in this project", "everywhere". - Nothing is set up until a new card comes with them in it. -- `3 just once` — do it now and leave nothing behind. -- `0 no` — nothing is set up, nothing is run, and the row settles as - `not set up`. `esc` does exactly the same thing. +- `1` sets it up. On a repeating check the button reads `Set it up · <cadence>`. +- `o Change…` turns the box into a place to say the time or the place you want + instead: "make it 8", "only in this project", "everywhere". Nothing is set up + until a new card comes with them in it. On a rule the button reads `Change where…`. +- `3` does it now and leaves nothing behind. On a check it reads `Only now, don't repeat`. + This used to say `just once`. +- `0` sets nothing up. The button's words depend on the kind: `Don't set it up`, + `Don't remind me`, `Don't watch`, or `Don't keep it`. The row settles as `not set up`. **The line under the answers says what the one you are on will actually do**, written out of this card's own facts. A **one-off reminder's card draws no `3`**: "do it now" for @@ -1935,7 +1955,7 @@ phone*). **The machine's own card is gone too.** `↑` off the top of the column stays on the top row, and each thing that card said has a place: `keeping an eye on` is the standing place -(`alt+5`), `today` is the `spend` panel and the pulse line, `agents` is the pulse's +(`alt+7`), `today` is the `spend` panel and the pulse line, `agents` is the pulse's `4 moving`, and `thinking` is the `thinking` row of `/settings`. ## The card beside a search — the preview on the right while you type @@ -2216,7 +2236,7 @@ words that set one up. On a short terminal `standing` is the first panel to give **The `spend` panel, pinned in the rail under `projects`**, is the day and the fortnight in three dim lines. **Nothing under its heading is selectable or clickable**: the arrows step over its lines, the pointer does not light them, and a press on one does nothing. The heading is the door — `enter` -cannot reach it, but a click on the word `spend` opens the spend place, as does `/spend` or `alt+3`: +cannot reach it, but a click on the word `spend` opens the spend place, as does `/spend` or `alt+5`: ``` spend diff --git a/internal/manual/chat/keeping-an-eye.md b/internal/manual/chat/keeping-an-eye.md index 321c14a968..faf713c293 100644 --- a/internal/manual/chat/keeping-an-eye.md +++ b/internal/manual/chat/keeping-an-eye.md @@ -137,25 +137,22 @@ passed". Because "once" would not be a smaller version of what you asked for; it would be a different thing at the wrong moment. -`3 just once` means **do the action now, as an ordinary turn, and leave -nothing behind**. For a watch, a rule, a routine or overnight work that is a real -answer: you wanted the tests run, not the arrangement. For "remind me at 6 to -leave" the whole content of the request is the **6** — doing it now says -`time to leave` hours early, or says nothing at all. So the card does not offer -it there: +`3` means **do the action now, as an ordinary turn, and leave nothing +behind**. On a repeating check the button reads `Only now, don't repeat`. On a +watch it reads `Check once now`. It used to say `just once`. For "remind me at 6 +to leave" the whole content of the request is the **6**. Doing it now says +`time to leave` hours early, or says nothing at all. A rule never runs. So +neither of those cards offers `3`: ``` -? wants to keep an eye on: remind me at 6 to leave - 1 yes, set it up it keeps happening until you stop it - 0 no nothing happens, now or later +? wants to remind you + 1 Remind me at 6 Reminds you then. Nothing repeats. + 0 Don't remind me You are not reminded. ``` -Two answers, `1` and `0`, and `3` does nothing — on the question in the -conversation, in home's `ask here` pane, and on home's own answer row. The hint -under the box says so too: `1 yes, set it up · 0 no · esc later`. The **way out -is still drawn**: `0 no` is on every standing card there is. - -Everything else keeps all three: a watch, a rule, a routine, overnight work. +Two answers, `1` and `0`, and `3` does nothing. A rule is the same shape: it +never runs, so there is no once. A repeating check and a watch keep `3`. The +**way out is still drawn**, and it is last, so a narrow row does not drop it. ## Why did it set my reminder for a time that already passed — it cannot any more @@ -265,9 +262,9 @@ yes nor a clear no, codeaf treats it as a no and the log says ## How long do I have to answer the card — the card does not time out As long as it takes. The card carries **no clock**: no countdown, no bar, and no -moment when it answers on somebody's behalf. It waits until you press `1 yes, -set it up`, `0 no`, `c` to change it, or — where the card offers it — -`3 just once`. +moment when it answers on somebody's behalf. It waits until you press the yes +(`1`), the no (`0`), `o` to change it, or, where the card offers it, +`3` to do it once. `3` used to read `just once`. `esc` **puts it off and does not answer it**. The question folds away so you can type, the work stays waiting on it, and the count beside the box goes on @@ -280,64 +277,60 @@ still takes the decline. It does not have to be answered in that window either. A window sitting on this card says so on **home**, and the row there carries the same answers the card is -offering — `1 yes`, `3 once` and `0 not set up`, or `1 yes` and `0 not set up` on -a one-off reminder — so the card can be **answered or declined** from the -dashboard without opening the conversation (home's own page has the whole rule). -`o other` stays here, where there is a box to say the new time or -place into. +offering. A repeating check reads `Set it up · <cadence>`, `Only now, don't repeat` +and `Don't set it up`. A reminder reads `Remind me <when>` and `Don't remind me`. +The card can be **answered or declined** from the dashboard without opening the +conversation (home's own page has the whole rule). `o Change…` stays here, where +there is a box to say the new time or place into. -## I don't understand these options — what each answer on the card does, how to change the time on a standing card, and how to cancel +## I don't understand these options. What kind of standing card is this, how do I cancel this card, where did 2 change when or where go The card in the conversation shows what is being proposed — your own words, when it would wake, where it reaches, what it costs. The **question sits above the message box**, where every decision on this screen is put, and every answer carries what it costs beside it: ``` -? wants to keep an eye on: every Monday at 9, post the standup note from the git log - 1 yes, set it up it keeps happening until you stop it - 3 just once it happens now, and nothing is kept - 0 no nothing happens, now or later - esc later · o other · ? clarify -``` - -- **`1 yes, set it up`** — it gets set up and starts happening, and goes on until you stop - it. The `when ·` and `where ·` bands on the card above say when and how far. -- **`c` change when or where** — you want it, but not like that. Press `c` and the box below - becomes a place to say the **time or the place** instead — "make it 8", "only in this - project", "everywhere" — and `enter` sends your words back. Nothing is set up until a new - card comes with them in it. (This was `2 change when or where` on the card's own row of - chips; `c` is the key every question on this screen uses to say "I will take one of these, - but not as it stands".) -- **`3 just once`** — do the thing now, this once, and keep nothing. Some cards do not - offer it; the section above says why. -- **`0 no`** — **this is cancel**. Nothing is set up, nothing is run, and the card settles - as `not set up`. -- **`esc`** — later. Nothing is decided, the rows come off the screen so you can type, and - the question is still counted beside the box. It used to be the outright no here; it is - not any more. +? wants to set up a repeating check + every Monday at 9, post the standup note from the git log + Mondays at 9am · about $0.02 a run + 1 Set it up · Mondays at 9am It repeats on that cadence until you stop it. + 3 Only now, don't repeat Runs the check one time now. Nothing repeats. + 0 Don't set it up Nothing is set up, and nothing runs. + esc later · o Change… · ? clarify +``` + +The first line says what kind of thing it is. The second line is what it does. +The third is when, and what one time costs. + +- **A reminder** says `wants to remind you`. `1` is `Remind me <when>` (reminds you then, nothing repeats), `0` is `Don't remind me`. There is no once. +- **A repeating check** says `wants to set up a repeating check`. `1` is `Set it up · <cadence>` (it repeats until you stop it), `3` is `Only now, don't repeat` (runs once now, nothing repeats), `0` is `Don't set it up`. On a narrow row the cadence drops off the yes before any word is cut. `3` used to say `just once`. +- **A watch** says `wants to watch for something`. `1` is `Watch for it`, `3` is `Check once now`, `0` is `Don't watch`. +- **A rule** says `wants to keep a rule`. `1` is `Keep this rule`, `o` is `Change where…`, `0` is `Don't keep it`. There is no once. + +`o Change…` turns the box into a place to say the time or the place, and `enter` sends your words back. Nothing is set up until a new card comes with them in it. That is where `2 change when or where` went: it is `o` now, and it does not resolve the card. `0` is how you cancel this card: nothing is set up and nothing runs, and the no is never dropped when the row is narrow. **`esc`** is later. Nothing is decided, the rows come off the screen so you can type, and the question is still counted beside the box. Each answer is a row of its own and **a click anywhere along it takes that answer**. The digit takes it too. -Answering leaves a line where the question was — `✓ wants to keep an eye on: … → yes, -set it up · you · 14:02` — and the card in the conversation settles with the answer and what -it came to on its bottom edge: `yes, set it up · set up`. +Answering leaves a line where the question was, the kind and the button you pressed, +and the card in the conversation settles with that button and what it came to: +`Set it up · Mondays at 9am · set up`. ## How do I decline a standing card or say no to a reminder — 0, esc, or the no on the card -`0 no` is the way out, and it is one keystroke and **one visible answer** everywhere +`0` is the way out, and it is one keystroke and **one visible answer** everywhere a card like this is drawn: in the conversation, on home's answer row, and in home's `ask here` pane. Nothing is created, nothing is run, and the card settles -as `not set up`. On home's answer row the chip reads `0 not set up`, which is the -same answer said as its outcome, because that row has no card under it to settle. +as `not set up`. The chip's words are the kind's own no: `Don't set it up`, +`Don't remind me`, `Don't watch`, or `Don't keep it`. **`esc` is not the no.** It used to be, in the conversation, and it is *later* now: the question folds away, nothing is decided, and the count beside the box goes on counting it. That is the same thing `esc` does to every question this program asks, and it is why the no had to become something you can see and click. -It is a `0` and not a `4` because the answers are numbered by where they sit — -`1 yes`, `3 just once` — so a fourth digit would move under your hand on a card +It is a `0` and not a `4` because the answers are numbered by where they sit. +`1` is yes and `3` is once, so a fourth digit would move under your hand on a card that drew one answer fewer. `0` is off the end of that numbering, on every card, always the same answer. @@ -924,6 +917,17 @@ arrives". A firing's run folder is a normal session folder outside your projects, so its transcript reads with the same tools as any other conversation. +## Why did it say the reminder was never set up after I said just once + +The completion check reads a short account of the turn, and a long turn clips +that account. Your answer on a card this turn is kept on the account anyway, +after the clip, as one line. For `3 just once` that line is `the person +answered the card "<the card's own sentence>": only now, don't repeat`. Any +other card you answered is the same shape, with the words that were on the +chip. The check is deciding what is still owed. An answer you already gave is +in front of it, so "nothing was set up" is the choice on the card and not a +piece of the ask still to do. + ## What it will not do - **It will not set anything up when nobody is watching.** A headless `--once` @@ -936,7 +940,7 @@ transcript reads with the same tools as any other conversation. task proposal, where silence starts the work: a task is bounded work somebody is watching, and a standing item spends money at times nobody chose. - **A "do it once" answer sets nothing up.** It answers - `do it once, now, as an ordinary turn — nothing stands. Nothing was set up.` + `Do it now as an ordinary step and report what happened. The person chose not to repeat it. Do not set it up again unless they ask. Do not investigate codeaf.` and codeaf does the thing in front of you instead. A **one-off reminder's card does not offer that answer** — see "Why is there no once on my reminder card". - **It will not set a reminder for a moment that has already passed.** The stamp diff --git a/internal/manual/chat/keys.md b/internal/manual/chat/keys.md index 7213acc594..5db59d663c 100644 --- a/internal/manual/chat/keys.md +++ b/internal/manual/chat/keys.md @@ -239,7 +239,9 @@ while it is open, so none of them contend for one keystroke on one screen. ## ? — the key that opens the key sheet `?` **over an empty box** opens `/help`: every command and every chord, written into the -transcript where you can scroll it. +transcript where you can scroll it. A row that is wider than the window wraps under the +column its sentence already starts in, so the next line does not sit at the left edge as +if it were another key. **On a place** — home, tasks, standing, memory, spend, search, settings — `?` draws **the map** instead, which is what `alt+.` draws: that place's own keys, in the cells the foot @@ -252,6 +254,14 @@ before this binding is read, so a `?` typed into one of those reaches it and not `/?` is an alias of `/help` as well, for fingers that arrived from elsewhere. +## Why a wrapped /help line stays under its key + +`/help` is a column. The key sits on the left and the sentence starts in a fixed +column. When the window is too narrow for the sentence, the next line starts in +that same column. It does not start at the left edge, which would look like a +second key. The same is true of a line that was already indented under the +column above it. + ## Stop it and tell it something different at the same time — interrupt and say something new in one key `ctrl+shift+enter` while a turn is running **stops the answer and sends what is in the box**, @@ -342,6 +352,8 @@ A message waiting above the box stays with its conversation when you open Home w pasted documents and standing mark stay with it. A connection that holds one conversation at a time returns the waiting words and pictures to the box and tray when switching ends the old conversation. `esc` stops the answer and drops waiting messages. +From Home, `alt+3` (`chats` on the bar) goes straight back to the conversation you +were in, and `alt+k` chooses one. ## Interrupting a running turn — how do I stop it mid answer @@ -474,7 +486,7 @@ conversation this machine's codeaf service is running **keeps working** after th closes — its tasks, its questions and its journal are all there when you open the same workspace again — and a conversation running inside this terminal (`--no-host`, or a host that could not be reached) stops with it. To see what is running before you go, the task -column (`ctrl+g`) and `/status` both say. +column (`alt+l`) and `/status` both say. **Closing one tab still asks.** `ctrl+w` on a conversation with work running raises a card that names that work — `a task and a job running` — and waits for an answer. Leaving the @@ -597,10 +609,13 @@ key arrives as ordinary `enter` and the message steers instead. | `ctrl+.` | Open the sessions place (`/history`) — every task this machine has run, across every project and every session; type to filter it. It opens on a machine that has run nothing too, and the page says what tasks are | | `space` `space` | On an **empty** box: open home (`/home`) — every project and conversation on the machine the session runs on, and an empty home on a fresh one. Does nothing when the box has words in it | | `ctrl+l` | Jump back to the live edge of the conversation | +| `alt+v` (`opt+v`) | Open the **conversations view** (`/wall`): every open conversation as a live tile, and the teams you group them into. Press again or `esc` to close it. Its own keys are on the *Conversations and teams* page | | `ctrl+t` | Start a **new chat** — the same start page the `+` at the end of the tab strip opens. Nothing is created until you send the first message, `esc` comes back, and the conversation you were in keeps its draft, its attachments and its work. On a home row it starts the fresh chat in that row's own folder, while clicking a `projects` row selects the folder for the next message | | `ctrl+w` | **Close this tab** — the same thing the `✕` on it does. Selects the last-used remaining tab, or Home if none remain. Drafts are kept, and the conversation keeps running; a tab with work in it asks `keep running` / `stop work` / `cancel` first | | `alt+t` (`opt+t`) | Give the keyboard to the task roster. Press again or `esc` to take it back | -| `ctrl+g` | A foreground command that can be kept takes the key first. Otherwise close the task roster's column, or bring it back — the column stands even with no tasks in it. Remembered for the next session. On a frame under 100 columns with no roster raised and no command to keep, it does nothing | +| `alt+l` (`opt+l`) | Close the column on the right, or bring it back, in every chat: the same column holds the Tasks and, in a chat in a team, the Traffic. The key is named at the right of the column's header. Under 100 columns it lays the column over the body, and a second press takes it off. Remembered for the next session | +| `alt+m` | In a team that has a manager: go to the manager. Over `--host` against an older codeaf on the far machine it says managers are not available there | +| `ctrl+g` | A foreground command that can be kept takes the key first. Otherwise it does what `alt+l` does: close the column, or bring it back; the column stands even with no tasks in it. Remembered for the next session | | `ctrl+e` | Empty box: open or close the running conversation’s compact steps first; otherwise the newest `▸ worked` chip onto its outline of captions — the latest completed turn's out here, the newest settled phase's inside a task's page — or the most recent thinking block when there is no chip. A caption is a short status line per step; its tool rows are one expand further. Otherwise: go to end of line | | `pgup` / `pgdown` | Scroll one page — the height of the view minus one, never less than one row | | `tab` | Open or commit path completion, over a command's path argument only — and over an **empty** box with no completion showing, go back to the last conversation. Does nothing when this terminal holds only one | @@ -663,7 +678,7 @@ rather than stopping at the edge. **With the keyboard**, `shift` with any motion key selects: `shift+←`/`shift+→` by a character, `shift+↑`/`shift+↓` by a line, `alt+shift+←`/`alt+shift+→` by a word, `shift+home`/`shift+end` to a line's ends, and `cmd+a` takes the whole message. Those -`shift` chords are the message box's; on the seven places `shift+←→↑↓` are already the +`shift` chords are the message box's; on the eight places `shift+←→↑↓` are already the time window that place is showing, so there they move the window and the pointer is how you select. @@ -1495,9 +1510,18 @@ the original**. Replaying a conversation starts its attachments collapsed again. ## Completing a path with `@` -Type `@` and codeaf offers **tasks first, then files and folders**, in one list under -the message box. It opens on the bare `@` — you do not have to type a letter first. It -closes on `esc`, on committing, or when the token stops being one. +Type `@` and codeaf offers one list under the message box. The first row is the +words **team**, **chat** and **file**. Under them: **teams**, then **conversations**, +then **tasks**, then **files and folders**. It opens on the bare `@`. You do not have +to type a letter first. It closes on `esc`, on committing, or when the token stops +being one. + +**team**, **chat** and **file** are presses. The word under the pointer takes a +background, and the hint says `only teams · click`, `only conversations · click` or +`only files · click`. A press types that prefix, `@team:`, `@chat:` or `@file:`, and +the list keeps only that section. Press the same word again and the prefix comes off. +Typing still filters every section that is showing. A command's path argument +(`/image `, `/export `, `/attach `) stays a file list and has no prefix row. **Folders are on the list too**, spelled with a trailing slash — `internal/tui3/` — and marked `folder` on the right the way a picture row is marked `img`. Choosing one puts @@ -1524,11 +1548,14 @@ will not appear in the list. Ranking puts a prefix match above a substring above a subsequence; the whole path and the base name are both tried at each tier, the base name a hair below the path. Inside a tier the earlier match wins, then the shorter path. File hits are capped at -32. The list shows 8 rows, or **14** when there are tasks on it; task rows are capped -at 8 and searched to a pool of 40. +32. The list shows 8 rows, or **14** when a team, a conversation or a task is on it. +Team rows, conversation rows and task rows are each capped at 8. Tasks are searched +to a pool of 40. -While the walk is still running the list reads exactly ` looking…`; with no match it -reads ` no file matches`. Only the file half waits — the task index lands first. +The prefix words are there at once. Teams and the conversations already open in this +window are there at once, from memory. Recent conversations and the file walk arrive +as they are read. With no match the line is `no matches`. A prefix that finds nothing +says `no team matches`, `no conversation matches` or `no file matches`. ## What `@` puts into your message @@ -1540,15 +1567,26 @@ reads ` no file matches`. Only the file half waits — the task index lands fir instead. - **A task:** the task's name goes in after the `@`. The pointer block is minted when you send, not here. +- **A team:** the `@` comes out and a coloured dot plus the team's slug goes in, + `●harbor`, in that team's colour. On a screen that draws no colour the dot is `*`. +- **A conversation:** `@` and its handle, or a short slug of its title when it has + no handle. The row's note is the full title. A conversation in no team is still + on the list. - **Under a command's path argument:** the path replaces the argument whole, with no `@` in front, and an image is written into the line like any other file. **When you send,** every `@<slug>` that names a task codeaf already knows about grows -a pointer-block footnote after the message — one block per task, in token order, -deduplicated. Unknown tokens are left alone in silence. This resolves against the -snapshot already in memory and never touches the disk, so a slug pasted whole and -sent in the same beat resolves to nothing and stays plain text. The entry remembered -for `↑` is the sentence as you typed it, before expansion. +a pointer-block footnote after the message, one block per task, in token order, +deduplicated. A team mark and a chat mark do something else, on the engine: the +model is handed a short digest of that team or that conversation, and your +transcript keeps the words you typed. The digest is members, handles, states and +recent traffic for a team, and the title, the state and an excerpt of the last +reply for a chat. It is never the whole transcript. Mentioning a conversation does +not message it and does not start its turn. Unknown tokens are left alone in +silence. A task slug pasted whole and sent in the same beat resolves against the +snapshot already in memory and never touches the disk, so it may stay plain text. +The entry remembered for `↑` is the sentence as you typed it, before the task +footnote. **The honest limit: `/attach ` (and its `/upload ` alias) and `/export ` get path completion.** That is the whole list. Any other command that takes a path gets no @@ -1565,7 +1603,7 @@ follows what you type. Only these keys are taken from you: | `up` / `ctrl+p` | Move the list cursor up | | `down` / `ctrl+n` | Move the list cursor down | | `esc` | Close the list. For the command list it also **seals that word** — the list does not reopen on the next letter of it. It does **not** interrupt a running turn | -| `enter` | Command list: take the highlighted command. At the start of an otherwise empty box that **runs** it; anywhere else it replaces just that word with the command's name and runs nothing. If nothing matched, the line is sent as typed. `@` list: insert the highlighted task or file; if nothing is picked, the line is sent | +| `enter` | Command list: take the highlighted command. At the start of an otherwise empty box that **runs** it; anywhere else it replaces just that word with the command's name and runs nothing. If nothing matched, the line is sent as typed. `@` list: insert the highlighted team, conversation, task or file; if nothing is picked, the line is sent | | `tab` | Read **before** the list. It only opens or commits an *argument* completion, over `/attach ` or `/export `. With nothing to complete and an empty box it goes back to the last conversation | | `enter`, with an argument completion open | Closes the list and runs the line **as typed**. Your path is never swapped for the top-ranked row | @@ -1683,6 +1721,23 @@ reads `[m] send to main · [esc] cancel`, because reviving live work would dupli ## Keys in the settings panel and the other panels +**Conversations view** (`alt+v`, `/wall`, or `▦ All` on the strip or under the box): the +arrows move the focus · `enter` opens · `space` picks · `x` closes a view (the work keeps +running) · `m` its teams · `s` a new team · `e` the shown team's settings · `tab` or `1` to +`9` show a team · `/` filters · `?` lists every key, and each of its rows is a button. The +**team switcher** under the strip's team chip takes `↑` `↓` `enter` `esc`. The whole map is on +the *Conversations and teams* page. + +**Teams page** (`alt+2`, `/teams`): while the manager's conversation has the box, keys type +into it; `alt+↑` `alt+↓` put the keyboard on the page's buttons and `esc` gives it back. On +the buttons: `↑` `↓` walk, `←` `→` cross between the rail and the pane, `enter` presses, +`s` the team's card · `c` close · `w` open on the conversations view · `n` new team (inside +the chosen team) · `o` Organize · `m` Move into… another team · `space` pick a team for a +move of several · `p` the members card · `M` a manager · `r` reopen · `d` delete a closed +team · `u` Undo a close or a move · `esc` cancels a drag or a move's question. In the Move +into… picker, typing filters, `↑` `↓` walk, `enter` moves, `esc` cancels. The whole map is on +the *teams page* page. + **Settings panel** (`ctrl+,`): `esc` backs out one layer at a time — search, then an open account, then the panel · `left`/`shift+tab` and `right`/`tab` change tab · `up`/`ctrl+p`, `down`/`ctrl+n`, `pgup`, `pgdown`, `home`, `end` walk · `enter` activates, @@ -1691,8 +1746,7 @@ a phrase like `shell command` can be written · `backspace`, `ctrl+u`, `ctrl+w` search · anything else types into it. **Task page** (`ctrl+.`, or `/history`, or the one dim door line at the bottom of the task -column — `ctrl+. earlier`, or `ctrl+. view more` where the column has only folded a -family away): `esc` closes it — or clears the filter first, if one is being typed — +column, `ctrl+. earlier`): `esc` closes it (or clears the filter first, if one is being typed), and `ctrl+.` closes it either way · `up`/`ctrl+p`, `down`/`ctrl+n` move, stepping over the `running` and `earlier` section words · `pgup`/`pgdown` move twelve · `home`/`end` first and last · `enter` opens the row · `backspace`, `ctrl+w` and `ctrl+u` edit the filter @@ -1746,7 +1800,7 @@ reads `⟲ rewind — pick where the conversation goes back to` and its foot `⟲ drops 2 turns — everything below the pick is let go` above `esc close · ↑↓ move · enter picks the point` — which becomes `esc close · ↑↓ move · enter again rewinds here` once a pick is placed, and -`esc clears the search · ↑↓ move · enter picks the point` while you are typing one. +`esc clear the search · ↑↓ move · enter picks the point` while you are typing one. Clicking a row places the pick; clicking the placed point rewinds; the wheel walks the cursor. The sessions and rewind page describes what the cut does. @@ -2134,22 +2188,24 @@ to filter, `↑↓` to walk, `enter` to use it, `esc` to go back to the layer. **Press the space bar twice with an empty message box.** That is the way back to home from inside a conversation, and `/home` opens it too. -**There is also a number: `alt+1` (`opt+1` on a Mac).** Home is the first of the four places on -the tab bar — `home tasks spend settings` — and each answers to its position there, -`alt+1` through `alt+4`. **`alt+5`, `alt+6` and `alt+7` are kept**, on the three places that +**There is also a number: `alt+1` (`opt+1` on a Mac).** Home is the first of the six places on +the top line, `home teams chats sessions spend settings`, and each answers to its position there, +`alt+1` through `alt+6`. **`alt+7`, `alt+8` and `alt+9` are kept**, on the three places that are off the bar — standing, memory and search — so those keys still open a room rather than -doing nothing; `alt+.` draws all seven with their numbers. Hold +doing nothing; `alt+.` draws them all with their numbers. `alt+2` is the teams page, and +`alt+3` is `chats`, the way back to the conversation in front (a new chat when none is open); +it is not a room, so `tab` steps over it. Hold `alt` and press the digit. On macOS codeaf draws the modifier as `opt+`, after the name on that keycap; it is the same key and the same chord, and on Linux and on Windows it is drawn `alt+`. It arrives in every terminal codeaf runs in, which is why the numbers are on `alt` rather than on `ctrl`. -**`ctrl+1` … `ctrl+7` are a second spelling, on the terminals that can send them.** `ctrl` +**`ctrl+1` … `ctrl+9` are a second spelling, on the terminals that can send them.** `ctrl` and a digit has no encoding in the forty-year-old scheme most terminals speak, so it is not the first spelling and never will be — but a terminal running the kitty keyboard protocol sends exactly the keys that scheme cannot spell, and it tells codeaf it does. Where that -report arrives, `ctrl+1` … `ctrl+7` jump to the same seven places and `ctrl+.` draws the same -map, and the map's own line says `alt+1…7 or ctrl+1…7 go to a place` so you can see it is +report arrives, `ctrl+1` … `ctrl+9` jump to the same eight places and `ctrl+.` draws the same +map, and the map's own line says `alt+1…9 or ctrl+1…9 go to a place` so you can see it is live. Where it does not, those chords do nothing and are never advertised. kitty, ghostty, WezTerm, foot and Windows Terminal are the usual ones that report it. **On a Mac this is the way in that needs no setting at all** — see "Why my option key types ¡ ™ £ instead of @@ -2160,7 +2216,7 @@ place key that does: `tab` belongs to the composer's path completion while you a and the rest of the place grammar — `→` for the row's verbs, `alt+<letter>` for how a place is shown, `shift+←→↑↓` for its time window — is about the room you are standing in. Every number opens its room whatever is in it: a place with nothing of its own to draw spends the -frame saying what it is for, and none of the seven is ever a key that does nothing. **On +frame saying what it is for, and none of the eight is ever a key that does nothing. **On such a page the line under the box names only the way out** — `tab next place · esc` — on tasks, on standing orders and on memory alike: a foot that offered `enter` or `type to filter` over a body with no rows would be naming a key with nothing to act on. @@ -2261,9 +2317,9 @@ not on this chord — it is the `thinking` row of `/settings`, and *alt+e — ho thing you are looking at thinks* says why. With the mouse: a click puts the cursor on a row and a second click on that row opens it. -The wheel walks the list three rows a turn, and the **tab bar above the panels is a -control** — clicking a place's word goes there, and clicking a gap between two words does -nothing. +The wheel walks the list three rows a turn, and the **places on the top line are +controls**: clicking a place's word, or the cell either side of it, goes there, and clicking +the air around the words does nothing. **Under 60 columns those two clicks are one.** At phone width home is an inbox and a row's card is a full-frame sheet, so a tap selects and opens in one gesture; the sheet's @@ -2326,9 +2382,11 @@ to it. `ctrl+c` does not close home — it quits codeaf, with home still up. ## The tab bar is a row the cursor can stand on — ↑ off the top row, and ←/→ along the words -**On every place, `↑` from the first row of the page lands the cursor on the tab bar** — -the row of four words under the top line (five while you stand in standing, memory or -search, whose word is drawn after the four). The word you are standing in wears the cursor's +**On every place, `↑` from the first row of the page lands the cursor on the tab bar**, +the six place words on the top line after the `codeaf` wordmark (seven while you stand in +standing, memory or search, whose word is drawn after the six). The chat tab strip is +not on a place. It is the row under that top line only while a conversation is in front. +The word you are standing in wears the cursor's band there instead of its usual mark, and five keys mean something on that row: | Chord | What it does while the cursor is on the bar | @@ -2337,10 +2395,10 @@ band there instead of its usual mark, and five keys mean something on that row: | `enter` | go into the place under the cursor | | `↓` | the same — go into the place under the cursor | | `esc` | back into the page, on the row you walked up from. It does **not** close the place | -| `↑` | nothing. Above the bar is the top line, which is a reading rather than a control | +| `↑` | nothing. The bar is on the top line, and there is nothing above it | Everything else means exactly what it means everywhere else: `tab` and `shift+tab` are the -next and previous place, `alt+1` … `alt+7` jump, `alt+.` draws the map, and **any printable +next and previous place, `alt+1` … `alt+9` jump, `alt+.` draws the map, and **any printable key goes into the composer** — taking the cursor back down into the page with it, because somebody who has started typing has stopped looking at the bar. @@ -2360,7 +2418,7 @@ between the tabs with the arrow keys*. ## `b` on the spend place — the letter that opens the limits, and the money figure you can press -On the spend place (`/spend`, or `alt+3`) two things lead to the money limits, and neither +On the spend place (`/spend`, or `alt+5`) two things lead to the money limits, and neither one is an editor on that page — the page answers *what did it cost*, and the Spending tab of `/settings` is the one place *what may it spend* is set. @@ -2385,30 +2443,34 @@ ink once this conversation has spent four fifths of its own `per conversation` l ## Keys in the task roster and inside a room **While the task roster holds the keyboard** (`alt+t`, `opt+t`): `esc` gives the keyboard -back · `up`/`down` move · `right`/`left` open and fold · `enter` opens that row's room · -`alt+w` widens the column and narrows it again. Its hint reads exactly -`↑↓ move · →← tree · enter open · alt+w wide · esc`. On a row whose work is still running or -still queued the hint gains one more clause before `esc` — `alt+e think harder`, which -moves that task's thinking rung. On an ordinary finished task, it saves the rung -for when you continue; it does not restart work or rewrite the last attempt. +back · `up`/`down` move over the needs-you band, the group headings and the tasks · +`enter` opens a task's room, opens or folds a group on its heading, and opens a band row's +thing · `left`/`right` switch the column between Tasks and Traffic in a chat in a team · +`x` stops the task under the cursor · `alt+w` widens the column and narrows it again. Its +hint reads exactly `↑↓ move · enter open · x stop · alt+w wide · esc`, led by +`←→ tasks/traffic · ` in a chat in a team. On a row whose work is still running or still +queued the hint gains one more clause before `esc`, `alt+e think harder`, which moves that +task's thinking rung. On an ordinary finished task, it saves the rung for when you +continue; it does not restart work or rewrite the last attempt. **Widen is a chord and not the bare letter `w`.** It used to be `w`, and `w` was read before the message box: a sentence typed while the roster still held the keyboard came out as `riting the port` and `orktree`. Every bare letter on this surface is either a key on a modal page with no message box, or an answer to a question drawn on screen, pressed over an -empty box — and widening a column is neither, so it took a chord. The bare `w` still works -on the **full-frame roster** (`alt+t` under about 100 columns, where the roster is drawn -over the whole frame and there is no message box on screen). The column's own footer says -`alt+w widen · click seam` or `alt+w narrow · click seam`, and clicking the seam — the -column's two leftmost cells — does the same thing with the pointer. Both the offer and -the handle exist only from 120 columns up, which is the only frame that lends the wider -tier; narrower than that those two cells belong to the row under them and open its task. - -**`→` and `←` fold two things, and it is one gesture.** On a family's root row they open -and close the family. On a row whose **work has finished** they open and close that row's -own detail line — the merge word and price — which a finished row keeps folded so that the -column's height goes to work that is still moving. A job's log path is not on that fold: -it is on the job's page. `→` on anything else does nothing. +empty box, and widening a column is neither, so it took a chord. The bare `w` still works +on the **full-frame roster** (`alt+t` under 100 columns, where the column is drawn over the +whole frame and there is no message box on screen). The column's own footer says +`alt+w widen · click seam` or `alt+w narrow · click seam`, and clicking the seam (the +column's two leftmost cells) does the same thing with the pointer. Both the offer and the +handle exist only from 120 columns up, which is the only frame that lends the wider +column; narrower than that those two cells belong to the row under them and open its task. + +**Folding is the headings' and nothing else's.** `Queued`, `Waiting` and `Done` start folded +to one heading line; `enter` on the heading, or a press on it, opens the group, and it stays +open for the session. `Running` never folds. A task row has no fold of its own: what it +used to fold away (the merge word, the price, the branch) is on the hint line when the +pointer is on it. `←` and `→` no longer fold anything; in a chat in a team they switch the +column's two words, and elsewhere they do nothing. **The walk stops at this conversation's last job, after its last task.** The roster holds this conversation's work, then the jobs section under it, so `↓` walks both and clamps at @@ -2416,46 +2478,43 @@ the bottom rather than carrying on into the project's record. Old tasks from ear sessions are on the sessions place, reached from the column's own `ctrl+. earlier` line, from `ctrl+.` or from `/history`; `enter` on an `earlier` row there goes inside that task's card. In a directory whose earlier sessions ran tasks but where **this** conversation has -run none and started no jobs, `alt+t` falls through — there is nothing on the column to +run none and started no jobs, `alt+t` falls through: there is nothing on the column to put a cursor on. A session that has only started a server still has the jobs section, so `alt+t` takes it. **The column's other lines take no cursor.** Its `standing` section, and the two `+` rows -that close each of those sections (`+ /task`, `+ /standing`), are the pointer's — the walk -skips them. The `jobs` section does take the cursor: the label, then every job row the -column actually drew. Their keyboard equivalents for standing are the commands themselves: -`/standing` opens the standing orders page, and typing `/task ` is exactly what pressing -`+ /task` puts in the box. **No new key is added to the column by either of them.** `enter` -on the `jobs` label toggles the section; `enter` on a job row opens that job's page. - -**Under 60 columns the TASKS PAGE this column reaches is a thumb's, not a keyboard's** — the +(`+ /task`, `+ /standing`), are the pointer's; the walk skips them. The `jobs` section does +take the cursor: the label, then every job row the column actually drew. Their keyboard +equivalents for standing are the commands themselves: `/standing` opens the standing orders +page, and typing `/task ` is exactly what pressing `+ /task` puts in the box. `enter` on the +`jobs` label toggles the section; `enter` on a job row opens that job's page. + +**Under 60 columns the TASKS PAGE this column reaches is a thumb's, not a keyboard's**: the column itself is unchanged, and its own keys are the ones above. The page's rows become two-line cards a tap opens, its foot is a `‹ back` bar in place of the key legend `enter open its room · alt+s sort · type to filter`, and the strip that opens it is one full-width door -(`▸ 3 tasks · 1 running`) rather than a row of chips. Mouse motion is ignored — a tap opens +(`▸ 3 tasks · 1 running`) rather than a row of chips. Mouse motion is ignored: a tap opens in one gesture. The tasks page describes the phone flow in full. -**`ctrl+g` closes the roster's column, and opens it again when it has no foreground -command to keep.** It works from the message -box, from inside a room, and while the roster holds the keyboard — it is the one key -here you do not have to ask for the roster first to use. Closing it hands the keyboard -back to the box. The choice is written to your profile as `ui.task_column`, so the next -session opens the way you left it, and `alt+t` counts as asking for the column back. +**`alt+l` closes the column, and opens it again.** It works from the message box, from +inside a room, and while the roster holds the keyboard: it is the one key here you do not +have to ask for the roster first to use. It is the same key in every chat, whichever word +is in front, and the column's header names it at its right (`opt+l` on a Mac). Closing it +hands the keyboard back to the box. The choice is written to your profile as +`ui.task_column`, so the next session opens the way you left it, and `alt+t` counts as +asking for the column back. `ctrl+g` does the same while no foreground command can be kept; +while one can, `ctrl+g` backgrounds the command instead. **A closed column leaves a two-column edge down the right of the frame with a `❮` in it, drawn in ink, and clicking anywhere on that edge opens the column again. Clicking the -column's `❯` door while it stands closes it** — one chevron control, two states, so the -pointer can go both ways. With no foreground command to keep the line says -`❯ ctrl+g hide`; while a command owns `ctrl+g`, it says only `❯ hide`. The chevron -works in both states; the keyboard chord belongs to the command in the second one. -When no command can be kept, the key falls through and does nothing only when there is -no roster on the frame to close: a frame under 100 columns where nothing has raised the overlay. It works with -no tasks at all — the column stands with only its `+ /task` and `+ /standing` doors, with the -`ctrl+. earlier` door under them if earlier sessions ran anything, and either way an -empty column is still a column to close. On the untouched empty screen there is no -column yet; there `ctrl+g` is a first keystroke like any other — the greeting goes and -the key then closes the column it would just have raised, so a second press brings it -back (*The empty screen* page). +`alt+l` at the right of the column's header while it stands closes it**, so the pointer can +go both ways. `alt+l` works with no tasks at all: the column stands with only its header, +its `+ /task` and `+ /standing` doors, and the `ctrl+. earlier` door under them if earlier +sessions ran anything, and either way an empty column is still a column to close. Under 100 +columns there is no column beside the conversation, and `alt+l` lays it over the body +instead. On the untouched empty screen there is no column yet; there the key is a first +keystroke like any other: the greeting goes and the key then closes the column it would +just have raised, so a second press brings it back (*The empty screen* page). **With a room open:** `esc` leaves the room, though a history recall walk is cancelled first · `enter` steers the node (see *What steering a task looks like on its @@ -2674,11 +2733,14 @@ Only the left button acts. A press is resolved in this order: terminal the strip chip the roster's cursor is on carries a `✕` of its own, and pressing it asks to stop that work instead of opening its room. **When the column is closed, the two-column edge it leaves at the right of the frame answers here too** — - a press anywhere on it opens the column again. With no foreground command to keep, - `ctrl+g` does that too; while a command can be kept, the key backgrounds that command. - Within the column, its own lines are asked before its task rows: a `+ /task` or - `+ /standing` row types that command into your message box, and a row in the - `standing` section opens `/standing` with the cursor already on that order. + a press anywhere on it opens the column again; `alt+l` does that too. + Within the column, its own lines are asked before its task rows: the header's words + (the other word brings its view to the front, and the `alt+l` at the right closes the + column), a needs-you band row (it opens its thing), a group heading (it opens or folds + the group), a Traffic row, a `+ /task` or `+ /standing` row (it types that command into + your message box), and a row in the `standing` section (it opens `/standing` with the + cursor already on that order). Whatever lights under the pointer is exactly what a press + there does. 9. The figures on the status row: the **money figure** (`$0.14`) and the cache beside it, which open the **Spending** tab of `/settings`; and the **context meter** (`66.8k/1.3M · 5%`) and the compaction forecast, which print `/status`. Each brightens @@ -2743,8 +2805,8 @@ the wheel walks the **cursor** rather than a scroll offset of its own, because o window follows the cursor. **The task column on the right scrolls under the pointer** and leaves the conversation -beside it where it is. It moves the column's own window — running work stays pinned at the -top, and the `tasks` label with it — unless the column is holding the keyboard (`alt+t`), +beside it where it is. It moves the column's own window (the header and the needs-you band +stay pinned at the top) unless the column is holding the keyboard (`alt+t`), in which case the window is already following the cursor and the wheel walks that instead. Reaching the bottom **re-arms sticking**, so new replies follow along again. Scrolling @@ -2875,14 +2937,13 @@ status line says what was copied instead of opening anything. See "selecting tex your mouse" above. **There is nothing under the pointer.** A click on empty space does nothing anywhere on -this surface, including the gap between two words of the tab bar and the blank rows of a -task's page. A click in copy mode acts on nothing at all, because those rows are a frozen +this surface, including the air around the place words on the top line and the blank rows of +a task's page. A click in copy mode acts on nothing at all, because those rows are a frozen snapshot. -**The terminal is too narrow for the word you are aiming at.** The tab bar gives up words -as the frame narrows, and at its narrowest it carries only the place you are standing in — -so on a narrow window there is no other place-word on screen to click. `tab`, `shift+tab` -and `alt+1`…`alt+7` still go everywhere. +**The terminal is too narrow for the word you are aiming at.** The top line folds its +trailing places into `more ▾` as the frame narrows; click `more ▾` and pick the place from +its menu. `tab`, `shift+tab` and `alt+1`…`alt+9` still go everywhere. **A file path is your terminal's click, not codeaf's** — usually **cmd+click** (ctrl+click on Linux). If a plain click on a path does nothing, that is why. @@ -3100,7 +3161,7 @@ answer: | `alt+e` | **Bound**, on three surfaces: it moves how hard the thing you are standing on thinks — this conversation from the message box, a task, or a standing item on home. The machine's own default is the `thinking` row of `/settings` and is not on this chord. See "The thinking chip above the message box" and "alt+e — how hard the thing you are looking at thinks". Anywhere else it does nothing. On macOS it is shown as `opt+e`; the terminal must send Option as Alt/Meta, as for the other Option shortcuts | | `ctrl+x` | Bound in three places: it drops a harness design from inside its room; on home it stops a standing item for good; and on a `tasks` row of home that this window holds it asks to stop that task (`ctrl+x stop it` on the `alt+.` map; the foot under a field row is the resting sentence and does not name it). Not bound anywhere else | | `ctrl+y`, `ctrl+z` | Not bound | -| `ctrl+<digit>` | **Bound as a second spelling of the place keys, on the terminals that report they can send it.** `ctrl` and a digit has no encoding in the scheme most terminals speak — which is why `alt+1` … `alt+7` (`opt+1` … `opt+7` on a Mac) are the first spelling and always will be — but a terminal running the kitty keyboard protocol sends it and says so, and where that report arrives `ctrl+1` … `ctrl+7` reach the same seven places. The map's line says `alt+1…7 or ctrl+1…7 go to a place` exactly when the alias is live. Where the terminal has said nothing, the chord does nothing and is never drawn | +| `ctrl+<digit>` | **Bound as a second spelling of the place keys, on the terminals that report they can send it.** `ctrl` and a digit has no encoding in the scheme most terminals speak, which is why `alt+1` … `alt+9` (`opt+1` … `opt+9` on a Mac) are the first spelling and always will be, but a terminal running the kitty keyboard protocol sends it and says so, and where that report arrives `ctrl+1` … `ctrl+9` reach the same eight places. The map's line says `alt+1…9 or ctrl+1…9 go to a place` exactly when the alias is live. Where the terminal has said nothing, the chord does nothing and is never drawn | | `ctrl+.` | Two meanings, on two screens that cannot both be up. In a conversation it is every task this project has run (`/history`); while a place is standing it draws the key map, on the terminals that can send `ctrl+<digit>` | | `alt+<letter>` | Bound **only where a place says so, and only on that place**. `alt+s` changes the shelf on the memory place; `alt+b` and `alt+f` are the word jumps inside every box and are never taken by a place. Every other `alt+<letter>` does nothing | | `shift+←` `shift+→` `shift+↑` `shift+↓` | The **time window** of a place that has one: `shift+←→` moves it by its own length, `shift+↑↓` changes how coarse it is. Three places have one — tasks (when it ran), standing (when it fired) and spend (which days) — and each draws the same control on its head row, `shift+← aug 12 – aug 25 →` with `shift+↑ coarser` beside it. Anywhere else, on a terminal too narrow to draw the control, and (for the zoom alone) on a line with no room for its clause, they do nothing | @@ -3141,8 +3202,8 @@ When more than one command is running at once, `ctrl+g` takes **the one that has been running longest**, which is the one you are waiting on. While a command can be kept, this meaning takes precedence over hiding or restoring the -task column, so the column stays where it was. With no such command the key belongs to -the column as described above. `ctrl+b` is copy mode and `esc` interrupts; neither changes. +task column, so the column stays where it was. With no such command the key does what +`alt+l` does: it closes the column or brings it back. `ctrl+b` is copy mode and `esc` interrupts; neither changes. ## When a settings change lands diff --git a/internal/manual/chat/models-and-cost.md b/internal/manual/chat/models-and-cost.md index d610020560..2003f688d8 100644 --- a/internal/manual/chat/models-and-cost.md +++ b/internal/manual/chat/models-and-cost.md @@ -2228,7 +2228,7 @@ covers the requests made before the restart. ## Is there a record of what I spent across all my conversations, by day or by model -Yes — a file on disk, and **the spend place reads it**. Press `alt+3`, or `tab` to it from any +Yes, a file on disk, and **the spend place reads it**. Press `alt+5`, or `tab` to it from any other place, and it draws that file: which days, which models, and what the money was for. Every cost line written into a conversation's transcript is also appended to one file for the @@ -2284,7 +2284,7 @@ breakdown; `/spend` opens the ledger for the whole machine. ## The spend place — what days and models cost, and what the money was for -`alt+3` opens it. It reads the machine-wide ledger above when you walk in and again on the +`alt+5` opens it. It reads the machine-wide ledger above when you walk in and again on the same three-second beat every place runs on, and it draws three things: - **the window and its total** — `14 days came to $34.10 · 41.2M tokens` on the left of the @@ -2846,7 +2846,7 @@ the same registry row, so what you set through one is what the others show: | --- | --- | | `/budget`, also `/limits` | opens the tab with the cursor on `per day` | | the money segment on the status line | press `$0.14` — it opens the tab. It brightens under the pointer to say it is a door | -| the spend place (`alt+3`) | `enter` on its first line, the dim `today $3.42 of $500 · /budget sets the limits` — the same figure the top line of every place draws | +| the spend place (`alt+5`) | `enter` on its first line, the dim `today $3.42 of $500 · /budget sets the limits`, the same figure the top line of every place draws | | the spend place, from a row | `→` opens the verb strip, where `b` is `the limits` | | a refused turn | the message names `/budget` | | the first-run setup | its `Models and spending` screen, whose **Daily limit** row writes this same row. It asks about the day's limit only — `per plan` and `per conversation` keep their defaults there and are changed here | @@ -2910,7 +2910,7 @@ Spending tab and `/cost` are the two readings — `/cost` is this conversation, the whole machine since midnight. The machine's day is drawn in **three** places and they are **one reading of one file**: -`today` on the Spending tab, `today $3.42 of $500` on the spend place (`alt+3`), and the +`today` on the Spending tab, `today $3.42 of $500` on the spend place (`alt+5`), and the green figure on the **top line of every place** — `$3.42 / $500.00`, beside the clock. All three sum the same rows of the machine ledger, so they cannot come apart, and the top line says the same thing whichever place you are standing on. @@ -3472,7 +3472,7 @@ it adds up to, and where to see it. There is exactly one request codeaf makes that its own money figures do not count: the **one-token measurement** it sends while you are typing, to warm the connection and time the provider your next message is heading for. Your provider bills you for it. `/cost`, -the status line, the spend place (`alt+3`) and the total at the end of `codeaf do` all +the status line, the spend place (`alt+5`) and the total at the end of `codeaf do` all leave it out, and so do the call-log rows and `codeaf-census`. **Why it is missing.** Those figures are all counts of the **call log**, and the diff --git a/internal/manual/chat/places.md b/internal/manual/chat/places.md index 7a620aeec2..68f32bf21d 100644 --- a/internal/manual/chat/places.md +++ b/internal/manual/chat/places.md @@ -1,50 +1,78 @@ # Places -## What a place is, and the seven of them +## What a place is, and the eight of them -A **place** is a full-screen room in codeaf that is not this conversation. There are seven, -and they are always in the same order — the four on the tab bar, then the three reached by -their command: +A **place** is a full-screen room in codeaf that is not this conversation. There are eight, +and they are always in the same order: the words on the top line, then the three reached by +their command, with `chats`, the way back to your conversations, third on the line: -`home` · `sessions` · `spend` · `settings` · `standing` · `memory` · `search` +`home` · `teams` · `chats` · `sessions` · `spend` · `settings` · `standing` · `memory` · `search` -**The tab bar draws four:** `home tasks spend settings`. Standing, memory and search are +**The top line draws six places:** `home teams chats sessions spend settings`. **Teams** is +right after home: your teams, what waits on you from them, and the selected team's manager +conversation (the **Teams page** of this manual has all of it). `chats` is not a room: it is +the way back to your conversations (*The `chats` word on the bar* below). Standing, memory and search are places all the same — `/standing`, `/memory`, `/search`, their digit, the map and the typed box all reach them — and while you are standing in one its word is on the bar after the -four, so the bar always says where you are. +six, so the bar always says where you are. -They are drawn as a **tab bar** on the second row of every place, under the top line — the -row of words at the top of the screen, `home tasks spend settings`, is this bar. The -one you are standing in wears a filled band; the rest are dim. Nothing else on the surface -looks like that bar, so "which place am I in" is one glance. +They are drawn on the **top line of every page**, right after the `codeaf` wordmark, on a +place and in a conversation alike. This manual still calls that row of words **the bar**: -Every place is drawn in the same frame: +``` + >● codeaf home teams chats sessions spend settings 3 moving · $1.20 thu 10:31pm +────────────────────────────────────────────────────────────────────────────────────────── +``` + +The place you are standing in is **lit in the accent colour**; the other words are muted. +Inside a conversation the lit word is `chats`. Nothing else on the surface looks like that +row, so "which place am I in" is one glance, and the words sit in the same cells on every +page, so moving between a place and a chat never moves the top of the screen. -1. the top line — this machine's own signs: what is on watch, what today has cost, the time -2. the tab bar — the four words, and the one you are in when it is not one of them -3. a dim rule -4. the place's own body -5. a rule, then the **composer** — one line you can type into, wherever you are -6. the hint line — what the keys do here +Every place is drawn in the same frame. A place spends three rows before its body. A +conversation spends four, because the tab strip is that conversation's own row: + +1. the top line: the wordmark, the places, and on the far end this machine's own signs, + what wants you, what is moving, what today has cost, the time. This row does not move. +2. a dim rule, then a blank. In a conversation the **tab strip** of your open chats sits + between the top line and that rule. A place does not draw it. +3. the place's own body, one row higher than a chat's body +4. a rule, then the **composer**, one line you can type into, wherever you are +5. the hint line: what the keys do here `esc` leaves a place and puts you back in the conversation you were in. Places are not stacked: opening one closes whichever was up, so `esc` is always one press from the chat. +## The `chats` word on the bar: how do I get back to my conversation from a place + +**`chats` is the third word on the bar, and it is the way back.** Click it, press `alt+3` +(`opt+3` on a Mac), or walk the bar's cursor onto it and press `enter`: the place closes and +the conversation that was in front before you opened it is in front again, with its draft +and its scroll where you left them. With no conversation open at all, it opens the new-chat +page instead, so the word never leads nowhere. + +It is not a room. It is the lit word while you are in a conversation, because that is where +the tab strip of your chats is drawn; `tab` and `shift+tab` step over it (they walk the rooms), and it has +no count. Its hint says `every conversation, one at a time`, which is how it differs from +`▦ All` on the strip: that one is the grid of the tabs you have open, all at once. `esc` still goes to home, as on every place. +`alt+k` is a different key: it opens the chats switcher to choose *which* conversation, while +`chats` on the bar goes straight back to the one you were in. + ## How to get to a place — the keyboard shortcut to jump between pages -Four ways, and they all reach the same seven rooms: +Four ways, and they all reach the same eight rooms: - **`tab`** — the next place **on the bar**, round again from the last. **`shift+tab`** — the one before. From standing, memory or search, `tab` goes on round the bar to home. -- **`alt+1`** … **`alt+7`** (**`opt+1`** … **`opt+7`** on a Mac) — jump straight to one, **from a - place or from a conversation**. `alt+1` … `alt+4` are the tab bar's own order — home, - tasks, spend, settings — and `alt+5`, `alt+6`, `alt+7` are the three places off the bar: +- **`alt+1`** … **`alt+9`** (**`opt+1`** … **`opt+9`** on a Mac) jump straight to one, **from a + place or from a conversation**. `alt+1` … `alt+6` are the tab bar's own order (home, + teams, chats, sessions, spend, settings), and `alt+7`, `alt+8`, `alt+9` are the three places off the bar: standing, memory, search. Hold `alt` and press the digit. macOS draws the modifier as `opt` because that is the key's name on a Mac keycap; Linux and Windows draw it `alt+`, and it is the same chord either way. `tab` and the shift-arrows are not like them: in a conversation those already belong to path completion and to the caret, so the digits are the one class of place key that means the same thing wherever you are standing. -- **`ctrl+1`** … **`ctrl+7`** — the same jump, on the terminals that can send it. `ctrl` and +- **`ctrl+1`** … **`ctrl+9`**: the same jump, on the terminals that can send it. `ctrl` and a digit has no encoding in the scheme most terminals speak, so this is a second spelling and never the first: it works only where the terminal runs the kitty keyboard protocol and says so (kitty, ghostty, WezTerm, foot, Windows Terminal are the usual ones). `ctrl+.` draws the @@ -61,10 +89,11 @@ Four ways, and they all reach the same seven rooms: to count, or nothing in it, says `a place` alone. - **a command** — `/home`, `/history`, `/standing`, `/memory`, `/settings`. Each opens the place it names. -- **click the word** — the tab bar itself is the control. A press on a place's word goes - there; a press in the gap between two words does nothing, and a press on the word you are - already standing on does nothing (going there would throw away what you have typed and - the row you are on). +- **click the word**: the top line itself is the control, from a place or from a + conversation. Each word is a button a cell wider than the word on both sides, and a press + anywhere on that button goes there; a press on the air before the first word or after the + last does nothing, and a press on the word you are already standing on does nothing (going + there would throw away what you have typed and the row you are on). `alt+<digit>` arrives in every terminal codeaf runs in. `ctrl+<digit>` does not exist as a thing a terminal can send, which is why the numbers are on `alt`. @@ -83,7 +112,7 @@ over one line: `work you send off with /task lands here, and its record stays`. ## How do I move between the tabs with the arrow keys — the tab bar is a row the cursor can stand on **Press `↑` from the first row of the page you are on.** The cursor leaves the list and -lands on the **tab bar** — the row of place words under the top line — and from there: +lands on the **bar**, the row of place words on the top line, and from there: | Key | What it does on the bar | | --- | --- | @@ -91,9 +120,9 @@ lands on the **tab bar** — the row of place words under the top line — and f | `enter` | go into the place under the cursor | | `↓` | the same as `enter` — go in | | `esc` | back into the page, on the row you walked up from | -| `↑` | nothing. There is nothing above the bar but the top line, which is a reading rather than a control | +| `↑` | nothing. The bar is the top line; there is nothing above it | | `tab` `shift+tab` | the next and the previous place, exactly as everywhere else | -| `alt+1` … `alt+7` | jump straight to one, exactly as everywhere else | +| `alt+1` … `alt+9` | jump straight to one, exactly as everywhere else | | any printable key | goes to the composer, and the cursor comes back down into the page with it | **The word your cursor is on wears the cursor's band**, in place of the mark the word you @@ -121,27 +150,71 @@ page; a second `esc` is the page's own, and that one leaves. ## Does the tab bar do anything when I hover over it — the pointer on the words -**Yes: the word under your pointer lifts.** Resting the mouse on a place's word paints that -word in the brighter ink the word you are standing in wears, without the band under it — so -the bar says "this one is a door" without pretending you are already in it. Moving the -pointer off the word puts the ink back, and moving it into the gap between two words lifts -nothing, because the gap belongs to no room. +**Yes: the word under your pointer takes a ground**, the same hover ground every button on +this surface wears, and the ground covers the button's pad cells too, so what lights is +exactly what a press acts on. On a plain or 16-colour terminal, where a ground cannot show, +the word wears a `·` in the cell before it instead. Moving the pointer off the word puts it +back. + +**The hint line says what the word opens and its key** while the pointer rests on it: +`alt+2 teams · the teams you hand work to`, `alt+3 chats · every conversation, one at a +time`. On `more ▾` it says `more · the places this row has no room for`; on the strip's +`▦ All` it says `The grid of your open tabs, and your teams · alt+v`. + +**A resize drops that hint.** Widening the window so `more ▾` is no longer drawn clears +the hover, and the hint line stops saying `more · the places this row has no room for` +without waiting for the pointer to move. The same is true of a place word the new row +may not draw. + +## The hint line stayed after I resized, stale hover, more hint after widening + +**Resizing the window forgets a hover that pointed at a door the new layout may not +draw.** That is `more ▾` once the places fit on the row, and a place word that folded +away. The hint line reads the hover, so leaving it would keep naming a door that is +gone until the pointer moved. After the resize the hint no longer says `more`. + +**Hovering moves nothing else at all.** No cursor, no page, no window, no focus. If the +keyboard cursor is standing on the bar as well you will see both marks at once: the +cursor's band on the word the cursor is on, the hover ground on the word the pointer is on. -**Hovering moves nothing else at all.** No cursor, no page, no window — the pointer -previews the tab words; list rows instead share one selection with the keyboard. If the -keyboard cursor is standing on the bar as well you will see both marks at once: the band on -the word the cursor is on, the lifted ink on the word the pointer is on. +**The wheel over the bar walks the places** while you are on a place, one room a turn: +`tab` and `shift+tab` under the hand that is already there. It is one room a notch and not +three, because each step opens a room, and two rooms nobody asked to see is two filters +thrown away. -**The wheel over the bar walks the places**, one room a turn — `tab` and `shift+tab` under -the hand that is already there. It is one room a notch and not three, because each step -opens a room, and two rooms nobody asked to see is two filters thrown away. +**Clicking still opens.** A press on a word goes there; a press on the air around the words +does nothing; a press on the word you are already standing on does nothing. -**Clicking still opens.** A press on a word goes there; a press in the gap does nothing; -a press on the word you are already standing on does nothing. +## Where did the places go: the top line holds the places, and why chat tabs are not showing on the home page + +**The places sit on the top line, after the `codeaf` wordmark. The tab strip of your chats +is drawn only while a conversation is in front.** It is not on home, teams, sessions, spend, +settings, or any other place. Chat tabs on the home page are not a thing this screen does. +`chats` on the top line, `alt+k`, and home's sessions list are how you get to one. + +The places used to be a row of their own under the top line on a place, and the chat strip +took that same row inside a conversation. For a while after that the strip stayed on every +page, which repeated the teams rail and home's sessions. Now: + +- **The top line** is the wordmark, the six places, and the machine's signs on the far end. + It is identical on every page; only which word is lit changes. It never moves. +- **The second line of a chat** is the tab strip: the team chip (` ● harbor ▾ `, or a quiet + ` teams ▾ `), `◆ Manager`, your tabs, `+` and `▦ All`. It has no `home` piece, since home + is the first word of the line above. +- **On a place the second line is the rule**, then a blank, and the page starts on the next + row. A click there is the page's. There is no invisible tab under it. + +## Why is there no tab strip on the teams page + +**The tab strip is a chat's row.** Teams is a place, like home, sessions, spend and +settings, so the row under the top line is the rule, then a blank, and the page starts +there. The manager's conversation in the pane does not bring the strip back. `chats` on +the top line, `alt+k`, and home's sessions list open a conversation, and the strip is on +that chat. ## The mouse on a place — clicking a row, hovering, and the wheel -Three gestures, the same on all seven places: +Three gestures, the same on all eight places: - **List rows have one selection.** On home, tasks, standing, memory, spend and search, moving the mouse onto a row selects it. Keyboard navigation immediately takes over @@ -323,8 +396,8 @@ may not name a key it has not bound. Six classes, and a key belongs to exactly o | `↑` `↓` `enter` `esc` `tab` | move, open, back out, next place — and `↑` off the first row of the page moves onto the **tab bar**, which is a row the cursor can stand on (*How do I move between the tabs with the arrow keys*) | | any printable key | goes to the composer, always | | `alt+enter` | send what you typed off as a task | -| `alt+1` … `alt+7` (`opt+1` … `opt+7` on a Mac) | jump straight to a place | -| `ctrl+1` … `ctrl+7` | the same jump, only on terminals that report they can send it | +| `alt+1` … `alt+9` (`opt+1` … `opt+9` on a Mac) | jump straight to a place | +| `ctrl+1` … `ctrl+9` | the same jump, only on terminals that report they can send it | | `alt+<letter>` | change how THIS place is shown | | `alt+p` `alt+o` | inside the composer layer only: move the task, change its model | | `shift+←` `→` `↑` `↓` | move this place's time window | @@ -434,16 +507,16 @@ Neither of them ever ends in `…`, and neither ever cuts inside a word. Press `alt+.` and the whole key map appears **in the cells you were already reading**: -- the tab bar's words grow their numbers — `1 home`, `2 tasks`, `3 spend`, `4 settings` — - and the three places off the bar are drawn after them with theirs: `5 standing`, - `6 memory`, `7 search` +- the tab bar's words grow their numbers, `1 home`, `2 chats`, `3 tasks`, `4 spend`, + `5 settings`, and the three places off the bar are drawn after them with theirs: + `6 standing`, `7 memory`, `8 search` - the hint line becomes the chord list `?` over an empty box draws the same map, which is what that key means on a place — show me the keys for where I am standing. In a conversation the same key opens the `/help` sheet. **The chord list is built from the place you are on.** It reads -`alt+1…7 go to a place · alt+enter send it off as a task · → show what this row can do · esc close` +`alt+1…9 go to a place · alt+enter send it off as a task · → show what this row can do · esc close` — and the `→` clause is left out on a place whose rows have no verbs, such as search, rather than naming a key that would open nothing there. @@ -473,6 +546,19 @@ approvals and `alt+k` for chats; `alt+g` and `alt+q` are unbound there. Clicking Home’s `since you left` heading opens memory. Questions appear as amber `?` bullets on the conversation or task, with no separate `needs you` heading. +## teams: your teams, what waits on you, and each team's manager + +The second place on the bar, right after home. On the left is a **rail**: your teams as a +tree (a sub-team indented under its parent), each with its colour, and a mark only when +something is happening in it: a dim `⠿` while one of its members is working, and an amber +`? 2` while two things wait on you. Under the tree are `+ New team` and `✦ Organize`, and +at the foot a folded `▸ Closed · N` holds the teams you closed. On the right is the team +you chose: a header with what it has spent today against its cap and three buttons, +`Settings`, `Close…` and `Open ▦`; a line of its members, every one of them, open in this +window or not; the decisions waiting on you, as cards you answer with one press; and the +team manager's own conversation, which you talk to right there. `/teams`, `alt+2` and a +click on the word open it. The **Teams page** of this manual has the whole of it. + ## tasks — the tasks page, and how to get to it without a command The full-screen conversation tree groups every chat and its tasks into **running** and @@ -483,7 +569,7 @@ completed; new work moves it back. Each task retains its own state word. Both sections default to newest activity first; click the age heading to reverse. Conversation titles match Home, and the same bullets mark running work, unread replies and unanswered questions. Every conversation and nested task starts expanded, with connecting tree lines and fold arrows immediately after titles in the left column. Projects -have their own column. You can fold a branch yourself. `/history`, `ctrl+.` and `alt+2` open it. +have their own column. You can fold a branch yourself. `/history`, `ctrl+.` and `alt+4` open it. **Typing here narrows the list.** While this place is up every printable key goes to its filter — the one exception being `1` and `2` over a row the record pane beside the list is @@ -522,7 +608,7 @@ them. Its existing stop action remains available when that engine supports it. The orders that fire on their own, on four shelves each under its own heading: this conversation's, this project's, the machine's, and then `in other projects` — everything else standing on this computer that does not reach the conversation you are in. -`/standing` and `/orders` open it, and so does `alt+5`. It is not on the tab bar. +`/standing` and `/orders` open it, and so does `alt+7`. It is not on the tab bar. `enter` opens where an order was asked for. `→` opens the row's verbs — `p pause`, `s stop`, and `n not here` on the three shelves that reach this conversation. Those three used to be @@ -543,7 +629,7 @@ The standing orders page has the whole of it. ## memory — what is held true What codeaf holds true about you and this machine, with what kind of thing each line is, how -it has done — `helped 19 · bore on 3` — and how old it is out at the right. `/memory` and `/memories` open it, and so does `alt+6`. It is not on the tab bar. +it has done, `helped 19 · bore on 3`, and how old it is out at the right. `/memory` and `/memories` open it, and so does `alt+8`. It is not on the tab bar. The page is **shelves** — you, this project, this machine — biggest first, with the biggest one open and the rest rolled up. Type to filter what is already on the page, **every letter @@ -567,7 +653,7 @@ machine · /remember adds a line`. ## spend — what it cost, and why it counts another session or another machine -What this machine has cost, by the day, by the model, and by what it was for. `alt+3` opens +What this machine has cost, by the day, by the model, and by what it was for. `alt+5` opens it. It reads one machine-wide ledger — a line per model call — so the figures are the bill and not an estimate. @@ -615,7 +701,7 @@ different thing — its head row stays, with the arrows that page it back. ## search — finding anything said or run, and what it matches when memory is off -Everything that has been said on this machine. `alt+7` opens it — it is not on the tab +Everything that has been said on this machine. `alt+9` opens it; it is not on the tab bar — and typing searches: the matches come back with the conversation they were said in, how long ago, and the project it belongs to, with your own words picked out in the line. @@ -625,16 +711,16 @@ read happens after the box has been quiet for a moment, never on the keystroke, never waits on a search. `enter` opens the conversation the matching turn was said in, and **the foot says so**: -`enter opens it at that turn · ↑↓ pick · type to search · esc clears the words · tab next +`enter opens it at that turn · ↑↓ pick · type to search · esc clear the words · tab next place`. With nothing typed there is no row to stand on, so the foot drops to `type to -search · esc clears the words · tab next place` — `enter` is not named where it does +search · esc clear the words · tab next place` — `enter` is not named where it does nothing. (This foot used to be the router's own default, which said `enter talk about it` and was wrong in both states.) Above the results, a legend counts the projects the matches came from. Twelve conversations are shown and the rest fold into one line, `▸ 38 more`; `enter` or a click on it draws them all, and `▾ 38 fewer` folds them back. A new search starts folded. -**`/search` is the typed door onto this place**, beside `alt+7` and the map. It +**`/search` is the typed door onto this place**, beside `alt+9` and the map. It takes no argument: the place is a box, and typing in it searches. With nothing typed the place is its heading `search` over one line saying what to do: @@ -664,49 +750,47 @@ would be two rankings that could disagree. ## settings — how this machine is set Every setting, in sections, with a search that crosses all of them. `/settings`, `/set` and -`/config` open it, and so does `alt+4`. +`/config` open it, and so does `alt+6`. It has a **second bar** under the place bar: its own sections. Those two bars are not a repetition — the upper one is the places, the lower one is settings' own pages. `←` and `→` move between sections. `tab` does **not**: it is the way to the next place, here as everywhere. -## Why the tab bar looks squashed on a narrow terminal — the places at 60 columns +## Why the tab bar looks squashed on a narrow terminal: the places at 60 columns, and what does more on the top line do -**All four words are on the bar at 60 columns, and down to 31.** The four words with the -padding each chip carries and the air between them are 34 cells; under that the bar gives up -the *air between the chips* before it gives up a place, so a 31-column pane draws +**The top line gives things up in a fixed order as the window narrows**, and the air between +the words never changes (two blank cells between two words, one blank cell at each end of +the line): -``` - home tasks spend settings -``` +1. the clock goes first, and the `on <machine>` name with it over `--host`; +2. then `3 moving`; +3. then the words of `2 want you`, which becomes `2 ?`, the same count in the same amber; +4. then the allowance behind the day's figure (`$1.20 / $20` becomes `$1.20`); +5. then the trailing places fold, one at a time from the right, into a **`more ▾`** word; +6. and then the day's figure itself. -with two cells between the words instead of three. Nothing else changes: the band under the -word you are standing in, the counts, `tab`, `←` `→` and `alt+1`…`alt+7` all mean exactly -what they mean on a wide screen. - -**Under 31 columns the bar carries what it can and counts the rest.** It keeps the place -you are standing in, the word the cursor is on, and any place wearing a count, then fills in -the bar's own order until the row is full and ends with a dim `▸ 2` — the number of the -bar's words that are not on the row (standing, memory and search are never counted: they -are not the bar's to give up): +**The count of things waiting on you never goes.** `2 ?` outlasts the money and the places, +at every width. At 80 columns all six places fit beside `2 ? · $1.20 / $20`. At 60, with +nothing waiting on you, they read ``` - home tasks ▸ 2 + >● codeaf home teams chats sessions more ▾ $1.20 ``` -`▸ 3 more` where there are cells for the longer spelling, `▸ 3` where there are not — the -same fold mark every other list on this surface puts over the rows it is not drawing, so a -count on the bar reads as the same idea as `▸ 11 more` at the foot of the spend place. The word gives -way before the mark does: `▸` is what says there is more behind the row. **The -count is a sign and not a button** — pressing it does nothing, because it stands for several -places at once and no single one of them is the answer. +**`more ▾` is a door.** Click it and a small menu hangs under it listing exactly the places it +folded, each with its key (`spend alt+5`, `settings alt+6`). The pointer lights a row and a +click goes there; `↑` `↓` and `enter` do the same from the keyboard; `esc`, or a click +anywhere off the menu, puts it away and leaves everything else as it was. + +**The wordmark and the place you are standing in never fold**, and neither does the word the +bar's cursor is on or a place wearing a count. `alt+1`…`alt+9` still go straight to a place +whether or not its word is on the row, and the numbers never move: the six on the bar are +`alt+1`…`alt+6`, then standing, memory and search are `alt+7`…`alt+9`. -**The key that reaches them is `tab`**, and it is named on the foot of every place — -`… · tab next place` — which is the last clause a narrow foot gives up. `alt+1`…`alt+7` -still go straight to a place whether or not its word is on the row, and the numbers never -move: the four on the bar are `alt+1`…`alt+4`, then standing, memory and search are -`alt+5`…`alt+7`, whatever happens to be drawn. +The tab strip, drawn only inside a chat, keeps its own narrowing: long names are cut at a word, +the names shrink until every tab fits, then the strip scrolls with `‹` `›`, and `+3` counts +the tabs it could not spell. ## Why a nearly-empty place says what it is for — why is the tasks page empty @@ -717,8 +801,8 @@ names what arrives there and the one thing that puts it there, the way home's em do. It never says the place is empty. **Every place opens, always.** There is no state of the machine in which a word on the bar, -or any of the seven digits, is a key that does nothing. On a machine codeaf was installed on -an hour ago, `alt+2`, `alt+5` and `alt+6` all open: +or any of the nine digits, is a key that does nothing. On a machine codeaf was installed on +an hour ago, `alt+4`, `alt+7` and `alt+8` all open: - **sessions**, headed `sessions`: `work you send off with /task lands here, and its record stays` @@ -738,7 +822,7 @@ never cut, and never ends in `…`. The moment the first thing arrives the line the same heading; nothing above it moves. - **spend**, **search** and **memory** over `--host` each say one dim line where their rows would be — see *The places over --host* below for the exact words and why three of the - seven still say them. + eight still say them. There is no "coming soon", no greyed-out list and no empty table with headings over it. A page that draws the furniture of a feature it does not have looks like a bug rather than like @@ -777,10 +861,10 @@ walk in. ## The rewind timeline is not a place `/rewind` (also `/undo`, `/back`) opens a full-screen page too, and it is deliberately **not** -one of the seven. It is something you do to *this conversation* — pick a point and cut back +one of the eight. It is something you do to *this conversation*: pick a point and cut back to it — rather than a room in the machine, so it has no tab and `tab` does not walk to it. -## The places over --host — whose machine am I looking at +## The places over --host: whose machine am I looking at, and what `on spark` at the end of the tab bar means **A place is a listing of one machine's disk, and over `--host` that machine is the one your session runs on.** Home lists the conversations under `~/.codeaf/v3`; tasks lists the work @@ -796,6 +880,7 @@ their readings have not crossed: | Place | Over `--host` | |---|---| | **home** | the far machine's projects and conversations | +| **teams** | the far machine's teams, their packets and their spend; the team card's settings rows are that machine's, and `Wrap up first` is offered only when its engine answers the wrap-up doors | | **sessions** | the far machine's work, out of the same reading | | **standing** | the far machine's orders — both what stands on this conversation and what stands anywhere else on that machine | | **settings** | this computer's rows; the sheet says the far conversation reads its profile on the other machine | @@ -809,10 +894,12 @@ say why. A screen full of the wrong machine's work is a confident lie, and one h sentence is better than eight rows and a total in dollars that belong to somebody else's afternoon. -**The tab bar says whose machine it is.** Over a connection the right end of the bar reads -`on <machine>` — the same name you typed after `--host`, and the same one the status line's -place segment and the legend under the box already carry. On a local session it is not there -at all: a machine name is worth a word only when there is more than one machine in play. +**The top line says whose machine it is: `on spark` at the end of the tab bar.** Over a +connection the far end of the top line, where the places are, reads `on <machine>`, just +before the clock: the same name you typed after `--host`, and the same +one the status line's place segment and the legend under the box already carry. On a local +session it is not there at all: a machine name is worth a word only when there is more than +one machine in play. On a narrow window it goes with the clock, before anything else. ## Why is home empty over ssh when I connect to another machine — space space over --host diff --git a/internal/manual/chat/questions.md b/internal/manual/chat/questions.md index abeb890f7e..5a21e10a42 100644 --- a/internal/manual/chat/questions.md +++ b/internal/manual/chat/questions.md @@ -1270,13 +1270,13 @@ has all of the above: the digits, `esc` for later, the chip, the receipt, the settle guard, the narrow card and the phone sheet. `permissions` is its own page and states what each answer banks. -**So does the standing card** — `wants to keep an eye on:` with `1 yes, set it up`, -`3 just once` where the item can be done once at all, and `0 no`. What is left in -the conversation is the card itself: your own words, the `when ·`, `where ·` and -`costs ·` bands, and the meter where the engine put a deadline on it. The answers -are up above the box with everything else you are being waited on for, and each -one says what it costs beside it. `o` starts an updated request — it turns -the box into the correction lane, and `enter` sends your words back to be +**So does the standing card.** The first line says the kind: `wants to remind you`, +`wants to set up a repeating check`, `wants to watch for something`, or +`wants to keep a rule`. Under that is what it does, then when and what one time +costs, and the `where ·` band. The answers sit above the box. A repeating check's +yes is `Set it up · <cadence>`, its once is `Only now, don't repeat` (this used +to say `just once`), and its no is `Don't set it up`. A reminder and a rule have +no once. `o` starts an updated request. `enter` sends your words back to be re-proposed. **`esc` on a standing card means *later* now, and it used to mean no.** It is diff --git a/internal/manual/chat/running-on-another-machine.md b/internal/manual/chat/running-on-another-machine.md index 86b853593c..599d932528 100644 --- a/internal/manual/chat/running-on-another-machine.md +++ b/internal/manual/chat/running-on-another-machine.md @@ -272,7 +272,7 @@ that conversation beside the one you are in — the engine gives it a connection and the chat you came from keeps running, the same door `codeaf resume` uses locally. The right end of the tab bar reads `on <machine>` so you can see whose afternoon you are looking at, and it is not there at all on a local session. -Three of the seven places still read the machine this window is running on, and each says so +Three of the eight places still read the machine this window is running on, and each says so in one line where its rows would be: **spend**, **search** and **memory**. The whole table, and why the look-stamp behind each tab's number is kept per machine, is on the Places page under *The places over --host*. @@ -454,11 +454,14 @@ exact sentence each one says. travels on the wire like every other answer; nothing about it needs a browser or a port. This is the one entry on the list that is a capability, not a limit. -5. **`/settings` opens anyway, and says one sentence as it opens.** Half these rows are - this surface's own — the mouse, the timestamps, the draft — and genuinely apply; the - other half govern the conversation, which reads them from the far machine's profile. It - says exactly: - `these rows are this machine's — the ones that govern the conversation are read from the profile on the other one` +5. **`/settings` opens anyway, and says whose rows these are.** Every tab but Teams writes + this machine. The Teams tab is saved on the other machine when that machine can take the + change. Opening on any other tab says exactly: + `these rows belong to this machine; the Teams tab is saved on the other one.` + On the Teams tab it says only what is true there: + `these rows are saved on <machine>.` + An older engine, where the Teams tab cannot be saved over the connection, says exactly: + `these rows belong to this machine; this conversation reads its profile on the other one.` ## More of what does not work over --host @@ -574,7 +577,7 @@ The task roster lists this far conversation's work. Its rows come from the far keep it, or drop it — goes back the same way. Running a harness that already exists was never affected. -13. **Three of the seven places still read this machine.** Spend adds up the ledger every +13. **Three of the eight places still read this machine.** Spend adds up the ledger every model call on the machine this window runs on writes into, search reads the index of what was said here, and memory reads what sessions here learned — and there is no door on the wire for any of the three yet. Each place opens, keeps its head, its bar and its box, and @@ -671,21 +674,51 @@ browser and no port, so that road stays open over `--host`. ## Settings over --host -`/settings` opens over a connection and says one sentence as it opens: +`/settings` opens over a connection. On any tab but Teams it says exactly: ``` -these rows are this machine's — the ones that govern the conversation are read from the profile on the other one +these rows belong to this machine; the Teams tab is saved on the other one. ``` -Half the rows are this surface's own — the mouse, the timestamps, the draft — and those -genuinely apply to what you are looking at. The other half govern the conversation, and -the conversation reads them from the profile on the far machine. Change those over there. +On the Teams tab it says only what is true there: + +``` +these rows are saved on <machine>. +``` + +An older engine, where that tab cannot be saved over the connection, says exactly: + +``` +these rows belong to this machine; this conversation reads its profile on the other one. +``` + +The rows on every tab but Teams are this machine's, and those changes apply to what you +are looking at. The Teams tab is the other machine's when the connection can save it. **Asking codeaf to change a setting goes the other way.** `settings` and `change_setting` -run inside the session, which is on the far machine, so they read and write **that** -machine's profile — which is the profile the conversation actually obeys. So over a +run inside the session, which is on the far machine, so they read and write that +machine's profile, which is the profile the conversation actually obeys. So over a connection the two doors land in two different files: the panel edits this laptop, and -asking edits the machine the work is on. +asking edits the machine the work is on. The Teams tab is the exception on the panel. +It saves on the other machine, the same place asking would write a team default. + +## Can I change the Teams settings on another machine, and where do team defaults go over a connection + +The **Teams** tab is the exception. Team defaults over a connection are what every team on +the far machine inherits, so the tab shows that machine's values and a change is saved +there, not on this computer. A value reads `from Settings`, the same words a team's own +card uses when the team has not overridden it. + +You can change `questions go to the manager`, `team messages wake`, `daily cap per team`, +`team depth` and `sub-team share`. The foot line says +`a team can override any of these on its card · saved on <machine>`. The note on this tab +says exactly `these rows are saved on <machine>.` + +An older engine, one that can show the teams but cannot take this change, keeps the tab +read only. The note says exactly +`these rows are on <machine>. changing them is not available over this connection.` +The foot line says `changing them is not available over this connection`, and +pressing enter on a row says the same sentence. Nothing is written on either machine. ## Approvals over --host diff --git a/internal/manual/chat/screen.md b/internal/manual/chat/screen.md index 05ee19a1fa..a74b228230 100644 --- a/internal/manual/chat/screen.md +++ b/internal/manual/chat/screen.md @@ -28,42 +28,42 @@ line above the message box* below, and *The thinking chip above the message box* keys page). The tray is drawn only when it has something on it: with nothing attached, the row is not there and the box sits straight under the gap. -Beside the conversation, on the right, the column — the right-hand bar, sidebar, task -panel, whatever you call it — takes 30 columns (24 on a narrower frame) -from the session's first keystroke, before any tasks exist. An untouched empty +Beside the conversation, on the right, the column (the right-hand bar, sidebar, task +panel, whatever you call it) takes a quarter of the frame, 28 to 40 columns (30 at 120), +from the session's first keystroke, before any tasks exist. It is the same column in every +chat, and its header is `Tasks N`, or `Tasks N · Traffic N new` in a chat in a team. An untouched empty conversation opens without it: no column, no doors, no rule, no telemetry, just the centred greeting with the message box inside it (see *The empty screen* page); the column stands the moment you type, or at once if a standing order or a task is already -here. It carries `tasks`, the -roster of work, and `standing`, the orders standing over this conversation. A section's -dim lowercase label appears only when that section has rows. Work fills the column -rather than raising it, and the work it fills with is **this conversation's alone**. -An empty column keeps only its typeable `+ /task` and `+ /standing` doors; where -the project has a record from earlier sessions, one dim line at the foot of the column -reads `ctrl+. earlier` and opens the task page. With no foreground command that can be -kept, `ctrl+g` closes the column and opens it again, remembered between sessions, and the -column's hide control above `+ /task` says so: `❯ ctrl+g hide`. While a command can be kept, that -command takes the key and the column stays where it was. With the column closed the -conversation is laid out at the full width of the terminal, running work still draws -the strip along the top, and the keys row under the box reads `ctrl+g tasks` once the -session has tasks to come back to and no running-turn line owns that row. - -**Seven places take the whole frame instead of sharing it**, at every width: home, tasks, -standing, memory, spend, search and settings. Four are on the tab bar — `home tasks -spend settings` — and `tab` walks those; `alt+1` … `alt+7` (`opt+1` … `opt+7` on a Mac) jump -straight to any of the seven from wherever you are standing — a place or a conversation — +here. Under the header, a needs-you band when anything needs you; then the roster of +work grouped by state, and `standing`, the orders standing over this conversation. Work +fills the column rather than raising it, and the work it fills with is **this +conversation's alone**. An empty column keeps only its header and its typeable `+ /task` +and `+ /standing` doors; where the project has a record from earlier sessions, one dim line +at the foot of the column reads `ctrl+. earlier` and opens the task page. `alt+l` closes +the column and opens it again, remembered between sessions, and the header names it at its +right: `alt+l`. `ctrl+g` does the same while no foreground command can be kept. With the +column closed the conversation is laid out at the full width of the terminal, running work +still draws the strip along the top, and the keys row under the box reads `alt+l tasks` +once the session has tasks to come back to and no running-turn line owns that row. + +**Eight places take the whole frame instead of sharing it**, at every width: home, teams, +sessions, standing, memory, spend, search and settings. Five are on the tab bar with the way back to the chats, `home teams chats +sessions spend settings`, and `tab` walks the five rooms; `alt+1` … `alt+9` (`opt+1` … `opt+9` on a Mac) jump +straight to any of the eight from wherever you are standing, a place or a conversation, and each -has commands of its own (`/home`, `/history`, `/standing`, +has commands of its own (`/home`, `/teams`, `/history`, `/standing`, `/memory`, `/settings`). The rewind timeline (`/rewind`) takes the frame the same way and is -deliberately not one of the seven — it is something you do to this conversation rather than +deliberately not one of the eight: it is something you do to this conversation rather than a room in the machine. While any of them is up nothing else is drawn — no conversation, no box, no status line — and `esc` gives the frame back. **Only one is ever up:** opening any one closes the rest. -Every place is drawn in one frame, top to bottom: the machine's own top line, the tab bar -naming the four (and the one you stand in, when it is off the bar), a dim rule, the place's body, a rule carrying the place's own count or note, and -the hint line last. See the **Places** page. +Every place is drawn in one frame, top to bottom: the top line (the `codeaf` wordmark, the +six places with the one you stand in lit, and the machine's own signs on the far end), the +tab strip of your chats, a dim rule, the place's body, a rule carrying the place's own count +or note, and the hint line last. See the **Places** page. **Only home has a box under that rule.** Its seam starts with the model, a colon and its effort word and approvals: `z-ai/glm-5.3-flash:auto · ◇ asks`. Conversation seams use @@ -99,23 +99,42 @@ while preserving the content's indentation. ## Conversation tabs — switching conversations by clicking, the tab strip over a chat, clicking a chat name -**The header begins with `home` and the conversations this window has been in**, drawn as -tabs in a row of their own, with a thin rule separating navigation from reading: +**The header's second line, inside a chat, is the conversations this window has been in**, +drawn as tabs in a row of their own under the top line, with a thin rule separating +navigation from reading. The strip is that chat's row. Home, teams, sessions, spend, +settings and every other place do not draw it: ``` - home openrouter price scrape Refactor the rail sco… [Shipping the parser] × + +2 - ──────────────────────────────────────────────────────────────────────────────────────── + >● codeaf home teams chats sessions spend settings $1.20 / $20 · thu 10:31pm + openrouter price scrape Refactor the rail scope... Shipping the parser × + ▦ All + ────────────────────────────────────────────────────────────────────────────────────────────────── ``` -Each tab is a **padded target** separated by quiet space. The filled surface includes -one blank cell before its status icon and after its close mark; the leading inset -selects the tab and the trailing inset belongs to the close target. The gaps do nothing. -Every tab has a filled background. The active tab reverses the surface contrast -and has stronger text; brackets identify it on -terminals without background color. **Every tab reacts to the pointer**, -including the one you are already in, and the highlight it wears as the *chosen* tab stays -put when the pointer leaves. Without color, hovering adds a dot beside the tab’s -close mark; Home, `+`, and the scroll arrows gain a pointer dot. +While a team is shown its chip, `● harbor ▾`, comes first on the strip, before the tabs it +narrows, with the team's `◆ Manager` after it (see *The team switcher on the tab strip*). +The strip is not on a place, so there is no unlit tab there and a press on that row is +the page's. + +Each tab is a **padded target**, and **one blank cell separates any two pieces of the +row**: the team chip and the first tab, two tabs, the last tab and `+`, `+` and `▦ All`. +The row's first piece starts in the same column with a team chip or without one. A tab is +the same width on both sides of its name: one blank cell, the status mark's cell and a +space lead it, and a space, the `×` cell and one blank cell close it (` ◐ name × `). The +status and `×` cells are kept even while they are empty, so a tab never changes width when +work starts or the pointer arrives. The leading cells select the tab and the `×` and the +cell after it close it. The gaps do nothing. Every tab has a filled background. The active +tab reverses the surface contrast and has stronger text; brackets identify it on terminals +without background color. **Every tab reacts to the pointer**, including the one you are +already in, and the highlight it wears as the *chosen* tab stays put when the pointer +leaves. Where colour cannot show a ground (16 colours or none), the tab under the pointer +wears `·` in its first cell, as a top-line word does, and shows its `×`; `+` and the scroll +arrows gain the same dot. + +**Every piece of the strip says what it does on the hint line** while the pointer rests +on it: a tab says `Go to openrouter price scrape · running · click` (the same sentence its +square in the dock says), its `×` says `Close this tab · the work keeps running · click` +(`ctrl+w` on the tab you are in), `+` says `New chat · ctrl+t`, and `‹` `›` say +`More tabs to the left · click` and `More tabs to the right · click`. **Clicking a tab goes to that conversation** — the same switch `alt+k` makes. Clicking the tab you are already in does nothing while you are in the conversation itself, and takes you @@ -128,9 +147,11 @@ them, so the one you reached for a minute ago is still in the same place. At mos remembered; past that the one you have not been in for longest falls off, and the tab you are in never does. This is a presentation limit, not a limit on running work or history. -**Many tabs scroll horizontally instead of shrinking their names.** On a roomy strip, -`‹` and `›` appear at the edges when more tabs exist in that direction (`<` and `>` in -ASCII). Click an arrow, or wheel vertically or horizontally over the header, to browse +**Names shrink first, then the tabs scroll.** A long name is cut at a word where one is +near (`Refactor the rail...`, not `Refactor the rail scop...`). While every tab still fits +with at least 16 cells each, the names shrink so every tab stays on the row, as a browser's +tabs do. Past that the strip scrolls: `‹` and `›` both appear at the edges, the one with +nothing further in its direction dim and inert (`<` and `>` in ASCII). Click an arrow, or wheel vertically or horizontally over the header, to browse the names. This changes neither the conversation, its draft nor the transcript position. The selected tab may leave view while you browse; choosing a conversation or closing a tab brings the selection back. Narrow frames keep the selected tab without spending its @@ -179,17 +200,14 @@ door that had to close the conversation to leave it. ## Why did my tabs disappear on a small terminal — how wide and tall the tab bar needs **The tab strip stands down below 12 columns or below 16 rows.** At 16 rows and taller, -the conversation keeps the same four-row head as every place: the machine pulse, the tabs, -a rule, and a blank. From 6 through 15 rows the whole head stands down, while the blank and +the conversation keeps the same four-row head as every place: the top line with the places +and the machine pulse, the tabs, a rule, and a blank. From 6 through 15 rows the whole head stands down, while the blank and rule above the message box remain. Below 6 rows those give way too, leaving the conversation, the box, and the status line. Blank rows cannot activate the content beneath them. -**`home` at the left opens the home page**, keeping your conversation and unsent words. -Its lowercase label and padded click target stay in the same columns on the dashboard -and in conversations, including while hovered. -It is separate from the tabs and breadcrumbs. Space twice on an empty composer still -opens Home. Home disappears when the connection cannot open conversations, and on -very narrow frames the current tab takes priority. +**`home`, the first place on the top line, opens the home page**, keeping your +conversation and unsent words. It is separate from the tabs and breadcrumbs, and it is on +the top line of every page. Space twice on an empty composer also opens it. The switcher floats on a separate background inside a rounded outline, with space above and below its contents when the window is tall enough. `>` marks the keyboard @@ -848,7 +866,8 @@ slot and the standing line wins whenever both would show. While the spelling-out out, the slot turns a small spinner in front of the same words. Neither ever moves the message box: this line is on the frame in every state. -One line in that slot is not about the next keystroke: `ctrl+g tasks`, which appears +One line in that slot is not about the next keystroke: `alt+l tasks` (`alt+l traffic` in a +manager's chat), which appears when you have closed the task column, this session has run something, and no active running-turn hint has the slot. It is the whole of what the frame says about a roster that is not on screen, and it says nothing at all when nothing has been run. @@ -1386,39 +1405,36 @@ On top of those eight: preview blocks under a pending call are capped at 4 rows ## What the top line of home drops when it is narrow — the clock goes first -Home's top line is the program's name on the left and the machine's vital signs on the -right: +The top line is the program's name and the places on the left, and the machine's vital +signs on the right: ``` - codeaf 2 want you · 4 moving · $0.55 / $20.00 · thu 1:11pm + >● codeaf home teams chats sessions spend settings 2 want you · 4 moving · $0.55 / $20 · thu 1:11pm ``` -When there is not room for all of it, the segments give way **one at a time, in a fixed -order**, exactly the way the status line's do: +When there is not room for all of it, things give way **one at a time, in a fixed order** +(the owner's order, 2026-09-24): ``` -clock → the allowance ($20.00) → the day's spend → moving → want you +clock (and `on <machine>`) → moving → `2 want you` becomes `2 ?` → the allowance → the places fold into `more ▾` → the day's spend ``` -So the clock is the first thing off the line and `2 want you` is the last. The reason is -one sentence: the terminal's own bar, the window and the wall clock all say what time it -is, and nothing anywhere else says that two things have stopped and will not move until -you look — a cell that could carry either carries the one you can only get here. Within -that, `want you` outranks `moving` because a stopped thing needs you and a moving one does -not, and the day's spend outranks the allowance because a figure is a fact and a fraction -is that fact plus a bound. +So the clock is the first thing off the line, `moving` goes next, and the places fold only +after that, into a `more ▾` word that opens a menu of exactly the places it folded. The +day's figure goes after the places. **The count of things waiting on you never goes**: its +words shorten to `2 ?`, the same count in the same amber and the mark a waiting tab wears, +and that is on the line at every width. `moving` goes first because a stopped thing needs +you and a moving one does not. -**The allowance goes by respelling, not by slicing.** `$0.55 / $20.00` becomes `$0.55` — +**The allowance goes by respelling, not by slicing.** `$0.55 / $20` becomes `$0.55`, never `$0.55 /` and never a bound with nothing in front of it. And when the money segment goes entirely there is **no `$` left on the line at all**: a narrow top line never says `$0.00`, because that would be the line reporting a figure it had actually given up on. (The one `$0.00` on the whole surface is the live status line of a conversation, so its segments do not jump sideways as the first money arrives. It is a different line.) -**The name never gives way.** A window too narrow even for `2 want you` beside it draws -` codeaf` alone. This used to be all-or-nothing — everything, or the name by itself — so a -sixty-column window spent twelve cells on `thu 12:01am` and then, one segment later, said -nothing about the machine whatsoever. +**The name and the place you are standing in never give way.** Nor does the air: two blank +cells between two place words and one at each end of the line, at every width. ## Other width thresholds worth knowing @@ -1428,10 +1444,10 @@ Beyond the four tiers, these are the exact points where parts of the screen give | --- | --- | | the status row's right edge may wrap to its own row | below width 100 | | the ledger drops its compaction forecast | below width 70 | -| full task rail, 30 columns off the conversation | width 120 | -| slim task rail, 24 columns | width 100 | -| no rail column at all — `alt+t` overlays the roster instead | below width 100 | -| no rail column at any width — you closed it with `ctrl+g` | your choice, remembered | +| the side column, a quarter of the frame, 28 to 40 columns | width 100 | +| `alt+w` widens the side column by 16 columns | width 120 | +| no side column at all; `alt+t` or `alt+l` lays it over the body | below width 100 | +| no side column at any width: you closed it with `alt+l` | your choice, remembered | | task strip | width 24 **and** height 6 | | a room's pinned header | width 12 and a non-zero breathing gap | | the empty screen's greeting (wordmark, model line, centred message box, try line, recent sessions) | not drawn below height 12 or width 40 | @@ -2248,8 +2264,8 @@ long time `↓` starts from what that window holds and counts up from there. A room opened on a task that was already running shows `↑` from the newest request in its record and `↓` from the moment the task writes anything. The column leaves when the task finishes. -The price and the token count on the task's row in the task column move at each -step that spends, not only when the task changes state. +The price and the token count on the hint line over the task's row in the task column +move at each step that spends, not only when the task changes state. A run's read-only transcript inside an adaptive run's page draws no column: it is a record being read back, not work being watched. @@ -2928,10 +2944,10 @@ back to plain ASCII (`!` `*` `o` `-` `+`) and the screen still reads. ## alt or option or opt — how the chords are spelled on a Mac, on Linux and on Windows, and why not the option symbol **It is one key and two spellings, and codeaf picks the spelling from the platform it is -running on.** On macOS every chord is drawn with `opt+` — `opt+1`…`opt+7`, `opt+.`, +running on.** On macOS every chord is drawn with `opt+`, `opt+1`…`opt+9`, `opt+.`, `opt+enter`, `opt+g`, `opt+q`, `opt+s`, `opt+w`, `opt+o` — because the key that Mac keycap calls **option** is the key you press. On Linux, on Windows, and everywhere else the same -chords are drawn `alt+1`…`alt+7`, `alt+.`, `alt+enter` and so on. Every hint line, the key +chords are drawn `alt+1`…`alt+9`, `alt+.`, `alt+enter` and so on. Every hint line, the key map, the composer layer's rows and the key sheet `/help` draws read that one spelling, so what is on your screen is what is on your keyboard. @@ -2964,7 +2980,7 @@ appears under the list: It names the terminal you are actually in, it is said once, and the first real chord that arrives retires it for the rest of the session. The first-run setup says the same thing ahead -of time, as a condition rather than a diagnosis: `the seven places answer opt+1…opt+7 · if opt types +of time, as a condition rather than a diagnosis: `the places answer opt+1…opt+9 · if opt types a character instead, turn on "use option as meta" in …`. **`alt+b` and `alt+f` do not retire it, and that is deliberate.** iTerm2's Natural Text @@ -2996,8 +3012,8 @@ are worth the one setting. **And on kitty, ghostty and WezTerm there is a way in that needs no setting at all.** Those terminals run the kitty keyboard protocol and report it, and where that report arrives codeaf -binds `ctrl+1` … `ctrl+7` as a second spelling of the jump and `ctrl+.` as a second spelling of -the map. The map's own line says `alt+1…7 or ctrl+1…7 go to a place` exactly when the alias is +binds `ctrl+1` … `ctrl+9` as a second spelling of the jump and `ctrl+.` as a second spelling of +the map. The map's own line says `alt+1…9 or ctrl+1…9 go to a place` exactly when the alias is live, so you never have to guess. `ctrl+<digit>` has no encoding in the older scheme, which is why it can only ever be the second spelling and never the first — a terminal that has said nothing is never promised it. @@ -3081,38 +3097,51 @@ are one. ## What the task column looks like: quiet rows, its footer lines and its one door -The right-hand task column is read at a glance, so it is drawn as one bright thing and a -lot of quiet ones. (This is its `tasks` section. The same column's other section, -`standing`, is described under *What is that column on the right*.) +The right-hand column is read at a glance, so it is drawn as one bright thing and a lot of +quiet ones. This is its Tasks view; *What is that column on the right* has the whole column, +and the team manager page has its Traffic view. +``` +Tasks 14 · Traffic 3 new alt+l +? Port the parser · your call · nobod… +✕ parser bench incomplete +────────────────────────────────────── +Running 4 + ⠙ rebase the parser onto dev 2m + ⠙ bench the lexer at p99 +Queued 3 ▸ +Done 6 ▸ ++ /task +``` + +- **The header** is the column's two words in a chat in a team, one word elsewhere. The + word in front is bold ink and the other is dim, and each keeps its count; a count of `0` + is dim, and a count of new traffic, `3 new`, is in ink. The `alt+l` at the right is dim. +- **The needs-you band** is the one place with colour of its own: what is waiting on you + leads with its `?` in the needs-you amber, and a failure nobody has opened leads with its + `✕` in ordinary ink. A thin dim rule closes it. With nothing waiting it is not drawn. +- **Group headings** (`Running 4`, `Done 6 ▸`) are muted with a dim count; the `▸` of a + folded group and the `▾` of an open one are muted too. `Running` wears no mark, because + it does not fold. - A **running** task's name is in ink, the body colour. **Queued, waiting and finished** - names are muted — a step quieter — and the room you are standing in is the one name in - the accent and bold, with a colour band across its whole row. -- The tree connectors (`├─ `, `└─ `, `│ `), the id at the end of a row (`#7`), every - detail line under a title, and every footer line are dim. The one loud exception is a - branch that did not merge: `conflicted · task/fix-nil` is in the bad hue. + names are muted, a step quieter, and the room you are standing in is the one name in the + accent and bold, with a colour band across its whole row. The time at the right of a row + is dim. - The state glyph at the head of a row takes its own identity ring hue and no role colour, so a glyph can never be misread as a state paint. -**Rows that are running never scroll off**, however long the list gets: they are pinned to -the top of the column and everything under them scrolls. The `tasks` label above them is -pinned too, so the heading is still there when you have scrolled a long way down. +**The header and the band never scroll**, however long the list gets: they are pinned to +the top of the column and everything under them scrolls. -**A task that has finished is one line.** While a task is running, waiting on you, or -held, its row carries the detail lines under its title — what it is doing, what it is -costing, what it waits on, where a job's log is going. Once it is over, the row is its -glyph, its name and its `#7` and nothing else, so the column's height goes to what is -still moving rather than to a day's history. Queued work is not finished and keeps its -`waiting on Collect sources` line; a finished task that is still **your call** — -`your call · conflicts with your branch`, `your call · nobody could check it` — keeps its -line too, because it is something to act on rather than something that is over. -Nothing is thrown away: see *Opening a finished row on the task column*. +**Every task is one line**, running or finished. What a row used to carry underneath +(what it is doing, what it is costing, what it waits on, the reason it is your call, the +merge word, the branch) is on the hint line while the pointer is on the row, with the whole +name first. So the column's height goes to rows rather than to a day's history. Nothing is +thrown away: see *Opening a finished row on the task column*. **The roster is this conversation's work and nothing else.** No rows of the project's -record are drawn under it. It used to carry a dulled footnote of up to six of them — a -sample of two thousand, standing where this conversation's task rows go, with the -cursor walking out of this conversation into another one without the column saying so. -What stands in their place is **one dim door** at the foot of the column: `ctrl+. earlier`. +record are drawn under it. What stands in their place is **one dim door** at the foot of +the column: `ctrl+. earlier`. **Everything earlier lives one press away.** `ctrl+. earlier` opens the full-screen task page (`ctrl+.`, `/history`), which holds every task the project has ever run, across every @@ -3120,70 +3149,66 @@ session, with the filter, the cards and the mention. Home (`/home`, or space twi empty box) is the other place old work is listed. Running work belonging to *other* windows is not on the column at all, and never was; `/history` carries that too. -The footer is up to three dim lines of counts — `3 running · 1 needs you`, `148 waiting · -12 done` — then the standing count `◦ 2 standing orders` when anything stands over this -project, and then up to two more dim lines, each of which is a button as well as a key: +The footer has no counts: the header counts the work and each heading counts its group. +It is the standing count `◦ 2 standing orders` when anything stands over this project, and +then up to two dim lines, each of which is a button as well as a key: ``` ctrl+. earlier alt+w widen · click seam ``` -**The first of them is one door with two spellings, never two doors.** It is drawn only -when the full-screen task page (`/history`) has something this column cannot give, and the -words on it say which: `ctrl+. earlier` when the project's record holds work this -session never ran, and `ctrl+. view more` when the only thing held back is a family the -column has folded. There is never more than one such line. -`alt+w widen · click seam` appears only while a title is actually being cut by its own -indent, **and only from 120 columns up** — that is the only width with a wider tier to -offer, so on a 100-to-119 column frame there is no line and the column's two leftmost -cells are part of the row rather than a handle. The `❯` hide control sits immediately above `+ /task`, after the visible task rows. -Its `❯` is drawn in ink rather than dim -because it is the control the pointer presses. With no foreground command to keep it -reads `❯ ctrl+g hide`; while a command owns that chord it reads only `❯ hide`, because -a hint may name only a key that works on that frame. +**The first is drawn only when the full-screen task page has work this session never +ran.** There is never more than one such line, and there is no `view more` line any more: +a folded group is opened by its own heading. `alt+w widen · click seam` appears while the +column holds the keyboard or the pointer is on it, **and only from 120 columns up**: that +is the only width with a wider column to offer, so on a 100-to-119 column frame there is no +line and the column's two leftmost cells are part of the row rather than a handle. The +column's way out is the `alt+l` at the right of its header. + +**A plain or sixteen-colour terminal gets the linear marks**: `x` for `✕`, `-` for the +band's rule, `>` and `v` for the folds, and `*` for a running glyph. The amber is the one +colour the band leans on, and where there is none the `?` still says it. ## Opening a finished row on the task column: how to see the log path of a job that already finished, and where the merge word, price or branch went -A finished task's row is one line, and the line it used to carry underneath is **folded, -not deleted**. It is the same fold a family of tasks uses, on the same keys and the same -cell: - -- **From the keyboard:** `alt+t` hands the column the keyboard, `↑` and `↓` walk to the - row, `→` opens it, `←` folds it away again. `esc` gives the keyboard back. -- **With the pointer:** hover the row and its state glyph turns into `▸`; click that one - cell to open it, and `▾` in the same cell to close it. Clicking anywhere else on the - row opens that task's room, as it always did — and so does that same cell on any frame - where the triangle is **not** drawn in it, because then it is holding the row's state - and a state is not a control. -- The fold is remembered per row, exactly as a family's fold is, and it lasts as long as - the conversation does. - -What comes back is that task's own last word: `merged · $0.42` for work that came home -clean. A background job is not a finished task row: it lives in the `jobs` section, and -its log path is on the job's page, not folded under a roster line. A row with nothing to -say — a task that ended with no merge word and no price — offers no `▸` at all, because a -mark that answered a press with silence would be a lie. The full record of any task is on -the task page (`ctrl+.`, `/history`) whether the row is folded or not. +A finished task's row is one line, and the line it used to carry underneath is **on the hint +line, not deleted**. Point at the row and the hint line under the message box says the +whole of it: the whole name, then that task's own last word (`merged · $0.42` for work that +came home clean, the branch it kept, the reason it is your call), then `click opens it`. +There is no fold on a task row and no `▸` in its state cell; the cell is the task's state, +and a press on it opens the task's room like the rest of the row. + +With the keyboard, `alt+t` hands the column the keyboard and `↑` `↓` walk to the row; the +room behind `enter` has everything the row does and more. + +Finished work sits under `Done`, which starts folded to its heading: press `Done 6 ▸`, or +`enter` on it, to open it, and it stays open for the session. + +A background job is not a finished task row: it lives in the `jobs` section, and its log +path is on the job's page. The full record of any task is on the task page (`ctrl+.`, +`/history`). ## Scrolling the task column: the mouse wheel over the sidebar, and the keys that walk it **Turn the wheel with the pointer over the column and the column scrolls.** It moves the column's own window and leaves the conversation beside it exactly where it was; a wheel turned over the conversation still scrolls the conversation. Three rows a notch, the same -as everywhere else on this screen. Work that is running is pinned to the top and does not -scroll away, and the `tasks` label stays with it. - -From the keyboard it is `alt+t` to take the column, then `↑` `↓` to walk it — the window -follows the cursor — `→` `←` to open and fold, `enter` to walk into a task's room, `alt+w` to -widen the column, and `esc` to give the keyboard back. The column's hint line says the -same: `↑↓ move · →← tree · enter open · alt+w wide · esc`, and it gains `alt+e think harder` -before the `esc` while the row under the cursor is work that has not finished — that chord -moves the task's own thinking rung. And on a row that says **`your call`** the whole slot -becomes that row's own answers and an `esc` — `a` says yes to what it is asking, `n` says -no — and those letters answer that landing from the column without opening its room. -While the column holds the keyboard the wheel walks that cursor instead of the window, so -the two never fight. +as everywhere else on this screen. The header and the needs-you band are pinned to the top +and do not scroll away. + +From the keyboard it is `alt+t` to take the column, then `↑` `↓` to walk it (the band, the +group headings and the tasks; the window follows the cursor), `enter` to walk into a task's +room or to open or fold a group, `←` `→` to switch between Tasks and Traffic in a chat in a +team, `alt+w` to widen the column, and `esc` to give the keyboard back. The column's hint +line says the same: `↑↓ move · enter open · x stop · alt+w wide · esc`, led by +`←→ tasks/traffic · ` in a chat in a team, and it gains `alt+e think harder` before the `esc` +while the row under the cursor is work that has not finished; that chord moves the task's +own thinking rung. And on a row that says **`your call`**, in the band or in the list, the +whole slot becomes that row's own answers and an `esc` (`a` says yes to what it is asking, +`n` says no), and those letters answer that landing from the column without opening its +room. While the column holds the keyboard the wheel walks that cursor instead of the window, +so the two never fight. Widen is `alt+w` and not the bare letter `w`: the roster is read before the message box, so a bare `w` there ate the `w` out of every sentence somebody typed with the column still @@ -3192,103 +3217,121 @@ no message box on the screen at all. There is **one scrollbar-less window and no second one**: the wheel, the arrow keys and a landing task all move the same offset. What the window cannot show is said at the foot of -the column — the totals, and `ctrl+. earlier` onto the full task page. +the column: `ctrl+. earlier` onto the full task page. ## What is that column on the right — tasks, standing, jobs and an empty rail -The column beside the conversation carries the two things that govern a conversation, and -a third for the background work that conversation started. -A section with rows earns a dim lowercase label; an empty section keeps only its dim `+` -door. (An untouched empty conversation has no column at all until the first keystroke, -a task, or a standing order — *The empty screen* page says why.) Once it stands: +The column beside the conversation is one column in every chat. It carries this +conversation's work, the orders standing over it, and the background work it started, and +in a chat in a team it carries the team's Traffic as its second view. (An untouched empty +conversation has no column at all until the first keystroke, a task, or a standing order; +*The empty screen* page says why.) Once it stands: ``` -tasks -⠙ Fix the nil-map #7 -❯ ctrl+g hide +Tasks 3 · Traffic 2 new alt+l +? Port the parser · your call · nobo… +────────────────────────────────────── +Running 1 + ⠙ Fix the nil-map 4m +Done 1 ▸ + /task standing ◦ keep the tests green -◦ never touch the public API everywhere +◦ never touch the public API everywhere + /standing ▸ jobs · 1 running · 4m12s -1 running · 1 needs you ◦ 2 standing orders ctrl+. earlier ``` -- **`tasks`** is the roster — this conversation's work, one line per task, a click on a row - opening that task's room. Workers under a task are rows of that roster too — a task's - parts, an adaptive run's workers — hung under their parent with connectors, folded and - walked like any other row; there is no separate preview list beneath a row. When more - than one worker is running, the label itself says the count, such as `tasks · 4 working`; - at zero or one it remains simply `tasks`. +- **The header** is `Tasks N`, and in a chat in a team `Tasks N · Traffic N new`. The word + in front is bold ink and the other dim; each is a button with a hover ground and a hint, + and the other word keeps its count, so what arrives on the Traffic while you read the + tasks still says `2 new`. Which word is in front is remembered for the session per kind + of chat: a manager's chat opens on the Traffic, every other chat on the Tasks. The `alt+l` + at the right closes the column. +- **The needs-you band** is everything that needs you now, from both views: a task whose + next step is yours, a member's question to you, a decision put to you (each led by `?` in + amber), and a task that failed while you watched and that you have not opened (its `✕` in + ordinary ink). Three rows, then `+N more`; gone when empty; nothing in it is drawn again + below it. Each row opens its thing. +- **The Tasks view** is the roster: this conversation's work under `Running`, `Queued`, + `Waiting` and `Done`, one line per task, newest first. Running is always open; the others + start folded to one heading line, and a press on the heading opens it for the rest of the + session. A click on a task row opens that task's room. Workers under a task (a task's + parts, an adaptive run's workers) are rows of their own in the same groups; there is no + tree and no preview list beneath a row. +- **The Traffic view**, in a chat in a team, is what passes in the team, one line a row, + newest first, with a thin `new` line under what arrived since you last looked. The team + manager page has the whole of it. - **`standing`** is the standing orders reaching this conversation, one line each: a mark, what the order is called, and a dim tail naming its reach **only when that reach is not - the ordinary one** — `everywhere` for machine-wide, `just here` for this conversation - only, and nothing at all for an order governing this project. A row's mark becomes the + the ordinary one** (`everywhere` for machine-wide, `just here` for this conversation + only, and nothing at all for an order governing this project). A row's mark becomes the spinner while that order is being checked or fired right now. Clicking one opens `/standing` with the cursor already on it. -- **`jobs`** is this conversation's background work — a server, a build, a watch, a render — - as a third section under the other two, collapsed by default to one line (`jobs · 2 - running`, `jobs · 1 running · 4m12s` when exactly one is live, `jobs · 6 ran` when - nothing is). Enter or a click toggles it. Expanded, every running job draws, then - finished ones fill whatever room is left, newest first, with `▸ N earlier` counting the - rest. Zero jobs draws nothing at all — no label, no empty row, no `0 jobs`. A click on a - job opens its page, not a chat. The tasks page has the whole of it under *Background - jobs on the column*. +- **`jobs`** is this conversation's background work (a server, a build, a watch, a render) + as a section under the other two, collapsed by default to one line (`jobs · 2 running`, + `jobs · 1 running · 4m12s` when exactly one is live, `jobs · 6 ran` when nothing is). + Enter or a click toggles it. Expanded, every running job draws, then finished ones fill + whatever room is left, newest first, with `▸ N earlier` counting the rest. Zero jobs draws + nothing at all. A click on a job opens its page, not a chat. The tasks page has the whole + of it under *Background jobs on the column*. - **The `standing` section keeps its rows however long the roster gets.** The sections - do not compete for the column: the roster is given what is left over after the label, - the doors, the standing rows and the jobs section have been reserved, and it is the - roster that scrolls. A session with forty tasks in it still shows the orders standing - over it, and the jobs that are running, without scrolling. -- **At most three orders are drawn, and the label counts the rest** — `standing · 7 more`, - in the same shape as `tasks · 4 working`. Past a handful the rows stop being read one at - a time; `+ /standing` (or `/standing`) opens the page that lists them all. A section - showing every order it has says nothing extra: the label is simply `standing`. + do not compete for the column: the roster is given what is left over after the doors, + the standing rows and the jobs section have been reserved, and it is the roster that + scrolls. A session with forty tasks in it still shows the orders standing over it, and + the jobs that are running, without scrolling. +- **At most three orders are drawn, and the label counts the rest**: `standing · 7 more`. + Past a handful the rows stop being read one at a time; `+ /standing` (or `/standing`) + opens the page that lists them all. A section showing every order it has says nothing + extra: the label is simply `standing`. - On a **short terminal** the standing rows give way one at a time so that the roster keeps at least six rows, and under that the whole standing section stands down rather than drawing a label over nothing. Live jobs are reserved before standing spends: a running job is not a thing this column hides to make room for furniture. -- **An empty section has no label and no absence sentence.** When tasks and standing are - both empty, only `+ /task` and `+ /standing` remain as the discoverable doors. Jobs add - no `+` door — a job is started by a tool, not typed. +- **An idle column draws nothing to mark an absence**: no `none` rows, no empty group + headings, no band. The header keeps its words with a dim `0`, and `+ /task` and + `+ /standing` remain as the discoverable doors. Jobs add no `+` door; a job is started by + a tool, not typed. - **The `+` rows type, they do not arm.** Pressing `+ /task` or `+ /standing` puts that - command and a space at the head of your message box and hands the keyboard back — plain + command and a space at the head of your message box and hands the keyboard back: plain text you can edit or delete, no mode, no form. -Under the sections come the column's dim totals and its door lines. The separation between -the sections is one blank line: this surface separates with whitespace and never with a -rule. On a build with no ambient side the `standing` section is absent entirely. +**It is one width everywhere**: a quarter of the frame, never under 28 columns or over 40, +the same in every chat and in either view, so nothing drawn in it moves the conversation. +The separation between the sections under the list is one blank line; the band's rule is +the one rule in the column. On a build with no ambient side the `standing` section is +absent entirely. -## The right edge: the chevron that opens and closes the task column +## The right edge: the chevron that brings the task column back, and the key that closes it -**The right edge always carries one chevron, and clicking it goes both ways.** +**The column closes from its header and comes back from its edge**, and the pointer can go +round the whole cycle without touching the keyboard. -- While the column **stands**, the line immediately above `+ /task` reads `❯ ctrl+g hide` when no - foreground command can be kept, and `❯ hide` while a command owns that key. The - `❯` is drawn in ordinary ink, not dim, because it is a control and not a reading; - the words beside it stay dim. Click the line and the column closes either way. +- While the column **stands**, its header ends in the key itself, `alt+l` (`opt+l` on a + Mac), dim, at the right. It is a button: under the pointer it takes a ground and the hint + line says `Hide this column · alt+l`. Press it and the column closes. - While the column is **away**, what is left is **two columns down the right of the frame** - with a `❮` handle at the middle of them, also in ink. The whole strip is a door: click - anywhere on it and the column comes back. + with a `❮` handle at the middle of them, in ink. The whole strip is a door: click + anywhere on it and the column comes back. Under the pointer the handle brightens further + and the strip takes a background, which is how everything pressable on this screen says + so. On a terminal that cannot draw it the handle is `<`. -So one control in two states — `❯` to close, `❮` to open — and the pointer can go round the -whole cycle without touching the keyboard. With no foreground command to keep, `ctrl+g` -does the same thing from the keyboard; while one can be kept, the key backgrounds it. -Under the pointer the chevron brightens further and its line -takes a background, which is how everything pressable on this screen says so. On a terminal -that cannot draw them the two chevrons are `>` and `<`. +`alt+l` does the same thing from the keyboard in both directions, and `ctrl+g` does too +while no foreground command can be kept; while one can, `ctrl+g` backgrounds it. One cell above the closed edge's handle carries what the work is doing while there is -anything to carry — `?` in the question colour for a task waiting on you, `◐` in the accent -for something running, and nothing at all otherwise. Those keep their own colours; they are -about the work, not about the door. The edge costs the conversation its two columns, so the -text re-wraps around it and nothing is ever drawn underneath. Under 100 columns there is no -edge, because at that width there is no column to bring back. +anything to carry: `?` in the needs-you amber for a task or a team member waiting on you, +`◐` in the accent for something running, and nothing at all otherwise. In a chat in a team, +two cells below the handle count what arrived on the Traffic since you last had it in front +of you. Those keep their own colours; they are about the work, not about the door. The edge +costs the conversation its two columns, so the text re-wraps around it and nothing is ever +drawn underneath. Under 100 columns there is no edge, because at that width there is no +column to bring back; `alt+t` or `alt+l` lays the column over the body. ## Light terminals, and why there is no theme setting @@ -3799,7 +3842,7 @@ nothing for it to open — `nothing made yet.` from `/files`, or `no subharnesses here yet — a subharness is a saved program for work that comes round again.` from `/subharness`. None of them is ever sent to the model. -The **seven places** are not among them: `/standing`, `/history` and `/memory` open their +The **eight places** are not among them: `/standing`, `/history` and `/memory` open their page whatever is in it and let the page say so, rather than writing a line here (the Places page states the law). diff --git a/internal/manual/chat/standing-orders.md b/internal/manual/chat/standing-orders.md index 4c140654f8..63f175534f 100644 --- a/internal/manual/chat/standing-orders.md +++ b/internal/manual/chat/standing-orders.md @@ -339,7 +339,7 @@ Where you said it sets the default; the words in your sentence can move it: So "always run the tests before you say you are done, everywhere" said in a chat stands over every project, and "keep this branch green, just in this conversation" dies when the chat does. If you say nothing about it, the card still tells you which one it picked -before anything stands — read the `where ·` band before you press `1 yes, set it up`. +before anything stands. Read the `where ·` band before you press `1`. **And if the reach is wrong, change it on the card.** `o other` turns the box below into a place to say either one: "only in this project", "everywhere", "just this @@ -558,7 +558,7 @@ empty standing page* below has them. ## Nothing stands here yet — the empty standing page -A machine nothing stands on **still opens the page**. `alt+5`, `/standing` and +A machine nothing stands on **still opens the page**. `alt+7`, `/standing` and `/orders` all reach it, and what they reach is the page's heading and one dim line naming what arrives there and what puts it there: diff --git a/internal/manual/chat/tasks.md b/internal/manual/chat/tasks.md index ae2f28e48d..0a5a1877f7 100644 --- a/internal/manual/chat/tasks.md +++ b/internal/manual/chat/tasks.md @@ -66,7 +66,8 @@ because the question about a design is the card at the end of it. The page on sa of work has it in full. A task can also break its own brief into smaller tasks when it finds independent parts in -it, and those are drawn as a family under it — see *When a task splits its own work*. +it, and those are rows of their own on the column, each under what it is doing (see *When a +task splits its own work*). **And a copy of its own is the ordinary task, not every task.** The other kind is the **quick task**: no copy of the folder, no branch, no check and no merge — it works in the @@ -358,9 +359,9 @@ tasks queue behind it with everything else. ## A quick task started inside a task — a quick row appeared under my task, and who reads its answer -A quick task started by a task hangs **under that task** on the column, in its family, -folding and unfolding with it. Its row reads the same `quick · 2/4 · …` it would read -anywhere. +A quick task started by a task is a row of its own on the column, under what it is doing, +beside the task that started it; its room names that task in its breadcrumb trail. Point at +its row and the hint line reads the same `quick · 2/4 · …` it would read anywhere. **Its answer goes to the worker that started it, not to you.** The note with its last message in it is delivered to its parent, which reads it and carries on — the same road a @@ -696,7 +697,7 @@ answer — with three more that belong to this moment alone: - **Nothing on a message with pictures in it.** A task is given words, so a message carrying images is always answered here, where they can be looked at. -## Handing work over in the middle of an answer — this one wants more hands +## Handing work over in the middle of an answer — this one wants more hands, why it handed my answer to a team of workers **Work can leave an answer that already started it.** A turn begins as an ordinary reply, a few tool calls go by, and the material turns out to be wider or longer than one answer. @@ -1783,8 +1784,8 @@ instant — the stamp is **absent** rather than invented. `incomplete · the check found gaps: …`. Its branch is kept. The row is dim unless something actually broke, in which case it reads `incomplete · a fault: <the error>` and is coloured bad. **There is no `failed` on any card** — that word is the engine's own. -- **`your call`** — a `?` in the accent colour. Its family rises above running work on the - roster. The `?` is deliberately neither a tick nor a cross: it claims neither a finding +- **`your call`**: a `?` in the accent colour. On the column it is in the needs-you band + above all the work, in amber. The `?` is deliberately neither a tick nor a cross: it claims neither a finding nor a judgement nobody made. The card carries the reason it is asking on its own row and the answers under that — unless you have set `task.settle` to `auto`, in which case the reason row says `codeaf is deciding` and the answers are drawn beside it. @@ -1869,7 +1870,7 @@ The strip is one row under the pinned header — a tab bar of doors into live wo It appears only while something is running, and goes away the moment nothing is. It needs a frame at least 24 columns wide and 6 rows tall. It is the narrow-frame door: wherever the roster stands — as the right column or open over the whole frame — the strip stands down. -A column you closed with `ctrl+g` is a roster standing down, so the strip comes back and +A column you closed with `alt+l` is a roster standing down, so the strip comes back and running work stays reachable. The one exception is a running sub-harness: its chip raises the strip even beside a standing roster, because the roster's rows are tasks and a harness run is not one — the chip is the only place on the screen that run exists. @@ -1884,7 +1885,7 @@ appear on it — the strip is the live set, the roster is this session's whole r A chip carries one glyph and the name cut to 18 cells, and nothing else: no clock, no spend, no tool name, no tree connector, no cursor mark, and no stop button. The room you are standing in takes a colour band. The strip is one flat row even when a task has -children; the roster is where the family tree is drawn. +children, and so is every row of the roster; a task's own page has its family. The strip is pointer-only and adds no keys or cursor of its own. @@ -1904,143 +1905,171 @@ land between chips a few cells apart, so the phone tier trades the tab row for o ## The roster: the column of all the work -The roster is the **top section of the column on the right**, separated from the pinned -hide hint by one blank row. There is no `sessions` heading. Under it the same column carries a second section labelled `standing` — -the orders standing over this conversation — and, when this conversation has started any, -a third labelled `jobs`. The standing orders page has that half; *Background jobs on the -column* below has the jobs section. +The roster is the **Tasks view of the column on the right**. The column is one column in +every chat, with one header, and it reads like this: + +``` +Tasks 14 · Traffic 3 new alt+l +? Port the parser · your call · nobody co… +✕ parser bench incomplete +────────────────────────────────────────── +Running 4 + ⠙ rebase the parser onto dev 2m + ⠙ port the key table 40s +Queued 3 ▸ +Done 6 ▸ ++ /task +``` + +**The header is the column's two words.** `Tasks 14` is this conversation's work, counted +whole. `Traffic 3 new` is what passes in the team this chat is in; a chat in no team has +only the first word. The word in front is bold ink and the other is dim, and the other one +keeps its count, so traffic that arrives while you read the tasks still says `3 new` on the +header. Each word is a button with a hover ground and a hint (`Show this chat's tasks · +click`); press the other word to bring it to the front. A count of `0` is dim. At the right +of the header is the column's own key, `alt+l` (`opt+l` on a Mac), and it is a button too: +press it and the column goes away (*Hiding the task column* below). + +**Which word is in front is remembered for the session, per kind of chat.** A manager's +chat opens on the Traffic and every other chat opens on the Tasks. Change it in a member's +chat and every member's chat you visit this session opens the same way; the manager's chat +keeps its own answer. The team manager page has the Traffic view. + +**Under the header is the needs-you band**, when anything needs you, and nothing at all +when nothing does: + +- a task whose next step is yours (a landing nobody could judge, a branch that + conflicted), led by its own state mark, `?` for your call, in the needs-you amber; +- in a chat in a team, a member's question to you, or a decision put to you, led by `?` in + amber; +- a task that failed while this window watched it and that you have not opened yet, led by + its `✕` in ordinary ink. A failure is news, not a demand, so it is never amber. + +The band draws at most three rows. A fourth item is drawn as a fourth row, and five or +more show the first three and a `+2 more` row; press it to show them all, and `fewer` to go +back to three. A thin rule closes the band. **An item in the band is not drawn again in +the list under it**, and opening a failure is looking at it: it leaves the band and takes +its place under Done. Each band row opens its thing: a task's room, the member's chat at the +question, or the teams page for a decision. + +**Under the band the work is grouped by what it is doing:** `Running`, `Queued` (nothing in +its way but a slot), `Waiting` (behind other work) and `Done`. Running work is always open +and its heading wears no mark, because it does not fold. The other three start folded to +one line, `Done 6 ▸`; press the heading, or `enter` on it, to open the group (`Done 6 ▾`) +and again to fold it. What you open stays open for the rest of the session, through new +work, new landings and switching chats. A group with nothing in it is not drawn at all; +there are no empty headings and no `none` rows. + +**Every task is one line**: its state glyph two cells in, its name cut with `…` where the +column is too narrow, and how long it has been at it (or how long it took) in the muted ink +at the right, `40s`, `2m`, `1h`. The time gives way before the name does: it is left off +rather than cut a name that would fit whole without it. Inside each group the newest work +is first. Point at a row and the hint line says the whole of it: the whole name, then what +the row has no room for, the way it used to be written under it (what it is doing, what it +waits on, how its branch came home, what it cost), then `click opens it`. The roster holds every task **this conversation** has admitted, not just the live ones. -Background jobs are **not** rows among the families: they have their own section under -`standing`. Tasks -*other* sessions ran are not on it; the -page `/history` opens is the one that has them, and one dim line at the foot of the column, -`ctrl+. earlier`, is the door onto it. Work finishing never puts the column away, and -neither does `/new` — that takes this session's tasks with it and leaves the column -standing, with the door onto the project's record still at its foot. With no foreground -command to keep, `ctrl+g` closes it and leaves the work exactly where it was. While a -command can be kept, that command takes the key instead; the column's `❯` pointer door -still closes it. The pinned top line names whichever keyboard action is available. - -The column is permanent: it stands from the session's first keystroke, before any task -exists, at a frame width of 100 columns or more — 30 columns wide from 120 up, a slim 24 -columns from 100 to 119. Work fills it rather than raising it. The one frame without it is -the untouched empty conversation, which opens on a centred greeting and no column at all -until you type, a task lands, or a standing order reaches it (*The empty screen* page). A conversation that has run nothing -draws no empty label or absence sentence, **whatever the project has behind it** — the -typeable `+ /task` door remains, and in a directory whose earlier sessions ran tasks the door -`ctrl+. earlier` sits at the foot of the column. Under 100 columns there is no -column, and `alt+t` opens the same roster over the body instead once this session has -tasks. - -Closed with `ctrl+g` when no foreground command owns the key, the column leaves a -two-column edge at the right of the frame that opens it again on a click — see *The task -bar disappeared* below. - -The roster is a forest. Each root task is followed by its whole family, with children -joined by three-cell connectors (`├─ `, `└─ `, `│ `). Root tasks appear in creation -order, oldest first, and children keep creation order within their parent. Changes in -state do not move rows. The kin line on a task's page uses the same child order. - -The sidebar begins with `❯ ctrl+g hide`, pinned above the task list. New tasks and -scrolling never move that control. `+ /task` follows the task list, above any standing -orders or jobs. The footer keeps state totals, such as `3 running · 2 needs you · 12 done`. - -Folding belongs to each node. Families with a running, needs-you, or queued member start -open. Settled families and families containing only waiting work start folded to their -root; the root then carries the family's aggregate state glyph and a `▸ +N` badge for the -hidden descendants. - -**Workers under a task are the family's own rows and nothing else** — there is no second, -smaller list drawn beneath a row. A task that split itself into parts, and an -adaptive run and its workers, each announce themselves as tasks with a parent, so every one -of them is an ordinary row of the forest above: its own state glyph, its own name, its own -`#id`, reachable with `↑`/`↓` and openable with `→`. A worker you can see is a row you can -walk to. - -The blank row above the tasks stays blank even while several workers are running. - -**A run's rows are on this column too.** The column draws this conversation's own tree, and -under the conversation that started a run it draws that run's tree out of the same reading: -one line per task — the connector, the state mark and the fitted title — with -`waits: <that task>` at the end of a line held behind named work, and the run's own row -ending in the dot row (*what are the dots next to a task?* has the cells). While a task's -worker is on a step, its row spends one line under it — the running glyph `◐`, the shell -lead `$` and the command its worker is on right now — and nothing else, because the steps -and the cost are the tasks place's own rows. That page (the page `/history`, `ctrl+.` and -`alt+2` open) has the run whole. +Tasks *other* sessions ran are not on it; the page `/history` opens is the one that has +them, and one dim line at the foot of the column, `ctrl+. earlier`, is the door onto it. +Work finishing never puts the column away, and neither does `/new`: that takes this +session's tasks with it and leaves the column standing. + +Under the task list the same column carries `+ /task`, then a section labelled `standing` +(the orders standing over this conversation) and, when this conversation has started any, a +third labelled `jobs`. The standing orders page has that half; *Background jobs on the +column* below has the jobs section. The header and the band stand still at the top while +the list under them scrolls. + +**The column is permanent** from 100 columns up: it stands from the session's first +keystroke, before any task exists, and work fills it rather than raising it. It is a +quarter of the frame, never under 28 columns or over 40: 28 at 110, 30 at 120, 40 at 160. +It is the same width in every chat and whichever word is in front, so switching words, +opening a group, a new row and the band appearing never move the conversation beside it. +From 120 columns up `alt+w` widens it by 16 columns, when the conversation keeps at least +56. The one frame without it is the untouched empty conversation, which opens on a centred +greeting and no column at all until you type, a task lands, or a standing order reaches it +(*The empty screen* page). Under 100 columns there is no column and no edge, and `alt+t` (or +`alt+l`) lays the same column over the body instead. + +**Workers under a task are rows of their own.** A task that split itself into parts, and an +adaptive run and its workers, each announce themselves as tasks, so each one is an ordinary +row of the list under the group it is in: its own state glyph, its own name, reachable with +`↑`/`↓` and opened with `enter`. The column draws what each piece of work is doing, not a +tree of who started whom; the task's own page (its kin line) and the task page have the +family. + +**A run's rows are on this column too.** Under the conversation that started a run, the +column draws that run's tree out of the tasks place's reading: one line per task (the +connector, the state mark and the fitted title) with `waits: <that task>` at the end of a +line held behind named work, and the run's own row ending in the dot row (*what are the +dots next to a task?* has the cells). While a task's worker is on a step, its row spends one +line under it: the running glyph `◐`, the shell lead `$` and the command its worker is on +right now. That page (the page `/history`, `ctrl+.` and `alt+4` open) has the run whole. ## What is the diamond symbol next to each task? — why the sidebar has no diamond, the mark on the cards **On the column at the right there is no diamond.** A task's row there opens with one cell, -the **state** glyph, which changes as the work does. Then the name, then its id as `#7`, -dim, at the far end — and the id stands down when the name would be left under 12 cells. -Every row of that column leads the same way, family rows included, so it reads downward as -one column of states. +the **state** glyph, which changes as the work does. Then the name, then how long it has been +at it, muted, at the far end. There is no `#7` on the row: the hint line names the task +whole when you point at it. Every row of that column leads the same way, so it reads +downward as one column of states. The `◆` is still on the surfaces that hold more than tasks: the proposal card, the card that lands, the notes in the conversation, and a queued task's chip on the strip above the conversation. It is one marker, the same on every task, saying only that this row is a -piece of work — which is worth a cell where tasks sit among other things, and worth nothing -in a column that is only tasks. It used to be on the column too, where it cost two of the -twenty-two cells the name has and pushed each row's detail line two cells out of line under -its own title. On a terminal with no colours or no unicode the marker is `#`. +piece of work, which is worth a cell where tasks sit among other things and worth nothing +in a column that is only tasks. On a terminal with no colours or no unicode the marker is +`#`. The marker used to be one of eight shapes in one of six colours, picked from the task's id, so that a given task wore `◆` teal everywhere. That is gone. It had to be learned, it was relearned every session because ids start again in each conversation, and it told you -nothing you could act on — the `#7` already says which task, and the state glyph and its -word already say what it is doing. +nothing you could act on: the state glyph and its word already say what the task is doing. -**The name is the task's own title, cut to its first three words** — `Fix the nil-map`, -`Collect the sources` — and that is the name it wears everywhere: the column, the strip +**The name is the task's own title, cut to its first three words** (`Fix the nil-map`, +`Collect the sources`), and that is the name it wears everywhere: the column, the strip above the conversation, its room's header, the card that lands, the home card and the task page. Three words is also what the `taskname` call is asked for, so a named task fits the column whole rather than being cut to fit it. A row reading **`task 19`** means one thing only: nothing has told codeaf what that task is called yet. It is a name you can still say -out loud, and the row takes the real one the moment the title arrives — including a room you -already have open on it. Under the row, at -most two more: what it is doing, what is holding it, what it waits on, or how its branch -came home. `conflicted · task/fix-nil` in the bad hue is the one loud row on the column. - -**The row of the room you are standing in is picked out.** Walk into a task — from the -roster, a strip chip, a spawn card or a `task 7` link — and that task's row in the column -takes a colour band across its whole width, every line of it, with its title in the accent -and bold. It is the same mark the strip puts on the chip of the room you are in, so the two -lists of the work never disagree about which door you went through. It follows you: opening -another task's room moves it, and `esc` back to the conversation clears it. With no room -open no row is marked at all. On a terminal with no background colours the accent title is -what is left of it. +out loud, and the row takes the real one the moment the title arrives, including a room you +already have open on it. **Nothing is drawn under a row.** What it is doing, what is holding +it, what it waits on, or how its branch came home (`conflicted · task/fix-nil`) is on the +hint line while the pointer is on the row, and a branch that needs you is in the band at the +top of the column. + +**The row of the room you are standing in is picked out.** Walk into a task (from the +roster, a strip chip, a spawn card or a `task 7` link) and that task's row in the column +takes a colour band across its whole width, with its title in the accent and bold. It is the +same mark the strip puts on the chip of the room you are in, so the two lists of the work +never disagree about which door you went through. It follows you: opening another task's +room moves it, and `esc` back to the conversation clears it. With no room open no row is +marked at all. On a terminal with no background colours the accent title is what is left +of it. There is no subtitle here. The column is a presence list; the proposal card and the landing card both carry the sentence. -Under the task rows, one dim `+ /task` row closes the section — press it and `/task ` is -typed into your message box. Then a blank line, then the column's `standing` section. +Under the task rows, one dim `+ /task` row closes the list; press it and `/task ` is typed +into your message box. Then a blank line, then the column's `standing` section. There are +no state totals at the foot: the header counts the tasks and each group's heading counts its +own. The session's spend and tokens are on the status row. When anything stands over this +project, a `◦ 2 standing orders` line follows and opens `/standing`. -At the bottom, under the sections, up to three dim lines count the roster in its own words: -`3 running · 1 needs you`, `148 waiting · 12 done`. Zero counts are left out entirely. The -session's spend and tokens are on the status row instead; there is no `Σ` line here. When -anything stands over this project, a separate `◦ 2 standing orders` line follows and opens -`/standing`. - -Below those are up to two door lines: `ctrl+. earlier` or `ctrl+. view more` when the -full-screen page holds something this column does not, `alt+w widen · click seam` when a -wider column would stop cutting a title. The column's own way out is pinned at the top, -above every task. It reads `❯ ctrl+g hide` when no foreground command can be kept and -only `❯ hide` while a command owns that key. Click either form and the column goes away. -The task list scrolls below it in creation order; `+ /task` stays below the visible list. +Below those are up to two door lines: `ctrl+. earlier` when the full-screen page holds work +this column does not, and, while the column holds the keyboard or the pointer is on it, +`alt+w widen · click seam` from 120 columns up. The column's own way out is the `alt+l` at +the right of its header. **Non-running rows are drawn quieter.** A running task's name is in the ordinary text -colour; queued, waiting and finished names are muted, the tree connectors and every detail -line are dim, and the room you are standing in is the one row in the accent. Nothing is -hidden by this — the column is a record and keeps everything — but a glance at it lands on -what is moving. +colour; queued, waiting and finished names are muted, headings are muted with dim counts, +and the room you are standing in is the one row in the accent. A glance at the column lands +on what is moving. ## Background jobs on the column — the jobs list on the right, what is running in the background, why a long command shows on the right, the row for a server, build or watch **A background job is not a row among the tasks.** It used to sit in the roster with the -families. It is now a **third section** on the same column, under `tasks` and `standing`, +tasks. It is now a **third section** on the same column, under the tasks and `standing`, labelled `jobs`. This covers everything the `jobs` tool can list except a task's own worker, which already has a roster row of its own: @@ -2283,9 +2312,9 @@ around it. holding `fix the flaky test` becomes `/task fix the flaky test`, which is the line you were about to type anyway. - **Pressing it twice does nothing the second time** — the word is already at the front. -- It is drawn whether or not this conversation has run anything, under the column's own - `tasks` label, and it is the **pointer's** row: the roster's keyboard cursor (`alt+t`) - walks task rows and skips it. From the keyboard you type the command, which is what the +- It is drawn whether or not this conversation has run anything, under the Tasks view's + last row, and it is the **pointer's** row: the roster's keyboard cursor (`alt+t`) walks + the band, the headings and the task rows and skips it. From the keyboard you type the command, which is what the row is teaching. Finish the sentence and send it and it is `/task <brief>` like any other: codeaf sizes the @@ -2311,7 +2340,7 @@ still size, shape and start the work directly, with no proposal card in between extra question. There is no third form: `/task adaptive` is retired. **There is still no `/tasks` command**, though `sessions` is the name of the PLACE `/history` -opens — `alt+2` and `tab` get there without typing anything. As a slash word the plural is not one this surface answers to; +opens, `alt+4` and `tab` get there without typing anything. As a slash word the plural is not one this surface answers to; the two things a bare `/task` and a `/task <brief>` do are the pair of errands a person has about tasks — go and look at the work, or give codeaf some. @@ -2326,28 +2355,26 @@ ctrl+. earlier ``` - **It is a door and not a note.** Press `ctrl+.`, or click that line, and the full-screen - sessions place opens with every task this machine has run on it, grouped by what you do next - — `running` and `completed`. `/history` is the same page. -- **It says what is behind it.** With a record behind it the line reads `ctrl+. earlier`; - with no record, on a column that has merely folded a family away, the same line reads - `ctrl+. view more`. There is only ever one such line. + sessions place opens with every task this machine has run on it, grouped by what you do + next: `running` and `completed`. `/history` is the same page. - **It is drawn only when there is something behind it**, and never as `0 earlier` or any - other count of nothing. + other count of nothing. There is only ever one such line. - **A task of your own is not behind it twice.** A task this conversation ran, running or - landed, is on the column above in its own family; the door is offered for work this - session never ran, and for a family the column has folded. -- It is dim, like the totals above it, and it is a button as well as a key. + landed, is on the column above under its group; the door is offered for work this session + never ran. A group folded to its heading is not a reason for the line: its heading opens it + in place. +- It is dim, and it is a button as well as a key. -**The column used to footnote the record** — up to six dulled `earlier` rows under this +**The column used to footnote the record**: up to six dulled `earlier` rows under this session's work, walkable with `↓`, each opening a card. They are gone. Six rows out of a -record that runs to two thousand is a sample; they stood where the column's own -`no tasks yet` label goes; and the cursor walked out of this conversation's work into -another one's without the column ever saying it had. Everything they offered is on the -other side of the door, whole: every row, the filter, the cards, and `m` for the mention. +record that runs to two thousand is a sample, and the cursor walked out of this +conversation's work into another one's without the column ever saying it had. Everything +they offered is on the other side of the door, whole: every row, the filter, the cards, and +`m` for the mention. **Where old work is listed now:** the task page (`ctrl+.`, `/history`, or that line), and home (`/home`, or space twice on an empty box). The chat can also read the whole project -record for you with its `tasks` tool — just ask. +record for you with its `tasks` tool; just ask. **Running work in another codeaf window** is on no surface but the task page. An ordinary task writes nothing into the project's file until it lands, so the window next door is the @@ -2357,14 +2384,17 @@ only place that work can be read from, and `/history` is the page that reads it. **Reopening a conversation re-draws its own tasks, and the jobs it ran.** `/resume`, `codeaf resume`, and switching back behind home all rebuild the column from the record: -every task admitted here comes back as a row in its family — finished work included, and -work that was interrupted comes back saying so on its card — and the `jobs` section +every task admitted here comes back as a row under its group (finished work included, and +work that was interrupted comes back saying so on its card), and the `jobs` section redraws the jobs this conversation started, settled. Tasks and jobs are not lost when the terminal closes; the column is rebuilt, not carried. **Quick tasks are in that too** — a finished one comes back `done` with its answer, and a conversation that ran them is never left with an empty column, which it was until this was fixed (*A quick task after a restart* has the whole of it). +A failure that comes back this way is under `Done` and not in the needs-you band: it is +news from before you left, and the band carries only what failed while this window watched. + The rebuilt row reads its start and landing times from that same record. Work that landed in a previous session therefore keeps the time it actually landed instead of taking the time you reopened the conversation. A record made before those times were kept still @@ -2377,42 +2407,42 @@ twice — a row on the column is not also an `earlier` row. ## Hiding the task column: closing the right sidebar, panel or task bar -With no foreground command that can be kept, `ctrl+g` closes the column of tasks on the -right and gives its columns back to the conversation. Press it again and the column -comes back with the current state of the work in it, including anything that started or -finished while it was gone — nothing here is a snapshot; the column is redrawn from the -tasks every frame. While a foreground command can be kept, that command takes the key -instead and the column stays exactly where it was. +`alt+l` (`opt+l` on a Mac) closes the column on the right and gives its columns back to the +conversation. Press it again and the column comes back with the current state of the work +in it, including anything that started, finished or arrived on the Traffic while it was +gone: nothing here is a snapshot; the column is redrawn every frame. It is the same key in +every chat, whichever word is in front. `ctrl+g` does the same when no foreground command +can be kept; while one can, `ctrl+g` keeps the command instead and the column stays where it +was. -**The pointer can do the whole cycle on its own.** The line immediately above `+ /task` reads -`❯ ctrl+g hide` with no foreground command to keep and `❯ hide` while one owns the -key. The chevron is in ink: click either form and the column closes. What is left -behind is a thin edge carrying `❮`: click that and the column comes back. One control, two -states — `❯` to close, `❮` to open — so a closed column is never a thing you need to know a -chord to recover. See *The task bar disappeared* below. +**The pointer can do the whole cycle on its own.** The column's header ends in the key +itself, `alt+l`, dim, at its right; it takes a ground under the pointer, the hint line says +`Hide this column · alt+l`, and a press closes the column. What is left behind is a thin +edge carrying `❮`: click that and the column comes back. So a closed column is never a thing +you need to know a chord to recover. See *The task bar disappeared* below. The choice is remembered. It is written to your profile the moment the column moves, as the `ui.task_column` setting, which also appears in the settings panel (`ctrl+,`) on the Display tab as **task column**. A change made in the panel lands the next time codeaf -starts; `ctrl+g` acts immediately and wins for this session. +starts; `alt+l` acts immediately and wins for this session. On the teams page the column +starts folded, because that page has a rail of its own on the left, and `alt+l` there opens +it for that visit only. With the column closed, work is still visible: -- Anything **running** draws the task strip along the top — `⠙ Fix nil-map · ◆ Auth tests - · +2` — because the strip stands up wherever the roster stands down. Click a chip for +- Anything **running** draws the task strip along the top (`⠙ Fix nil-map · ◆ Auth tests + · +2`), because the strip stands up wherever the roster stands down. Click a chip for that task's room, or the `+N` for the whole roster. -- The keys row under the message box carries `ctrl+g tasks` for as long as - this session has any tasks at all, running or not. A session that has run nothing says - nothing there — the column you closed was empty, and `ctrl+g` still brings it back. +- The legend's hint slot under the message box carries `alt+l tasks` (`alt+l traffic` in a + manager's chat) for as long as this session has any tasks at all. A session that has run + nothing says nothing there; the column you closed was empty, and `alt+l` still brings it + back. - `alt+t` still works: asking for the roster brings the column back and gives it the keyboard in one press. -When no command can be kept, `ctrl+g` works whether or not the session has tasks — the -column stands empty, so an empty column is still a column to close. It does nothing, and -is not swallowed, only when there is no roster on the frame at all: a frame under 100 -columns where nothing has raised the roster over the body. On -the untouched empty screen, where no column has stood yet, the key is a first keystroke -first — the greeting goes — and then closes the column as usual. +`alt+l` works whether or not the session has tasks: the column stands empty, so an empty +column is still a column to close. Under 100 columns, where there is no column beside the +conversation, it lays the column over the body instead, and a second press takes it off. ## The task bar disappeared — how do I get the task column back @@ -2424,108 +2454,100 @@ rather than dim so the eye can find it: …and the parser suite passes now. ❮ ``` -**Click anywhere on that edge and the column comes back** — the whole strip is the door, -not just the handle, so there is nothing to aim at. It is the column act `ctrl+g` performs -whenever no foreground command can be kept. +**Click anywhere on that edge and the column comes back**: the whole strip is the door, not +just the handle, so there is nothing to aim at. `alt+l` does the same from the keyboard. - Under the pointer the handle brightens further and the whole two-cell strip takes a - background, which is how everything pressable on this screen says so. -- **The chevron points the way the column goes**, and it is the same control in its other - state: `❮` while the column is away, `❯` above `+ /task` while it stands. - That line says `ctrl+g hide` only when the key is available, and says `hide` otherwise. - Clicking one gives you the other, so the pointer goes round the full cycle. On a terminal - that cannot draw them they are `<` and `>`. + background, which is how everything pressable on this screen says so. The hint line says + `Show this column · alt+l`. - **One cell above the handle says what the work is doing**, while there is anything worth - saying: `?` in the question colour when a task is waiting on you, `◐` in the accent when - something is running. Nothing at all otherwise — a session with nothing running and - nothing waiting leaves the edge silent, and so does one that has run no work. + saying: `?` in the needs-you amber when a task or a team member is waiting on you, `◐` in + the accent when something is running. Nothing at all otherwise: a session with nothing + running and nothing waiting leaves the edge silent. +- **In a chat in a team, two cells below the handle count what arrived on the Traffic** + since you last had it in front of you, dim, up to `99`. The hint says it too, `3 new in the + traffic`. - The edge costs the conversation two columns, exactly as the column it stands for costs it its own width. The text re-wraps; nothing is ever drawn underneath it. - **On a frame narrower than 100 columns there is no edge**, because there is no column at - that width to bring back. The roster still opens over the whole frame with `alt+t`. -- The edge is for the hand that does not type chords. With no foreground command to keep, - `ctrl+g` is the keyboard's way around the same cycle; with one, it backgrounds the command. + that width to bring back. `alt+t` or `alt+l` lays the column over the whole frame. +- On a terminal that cannot draw `❮` it is `<`. -The legend above the message box also carries `ctrl+g tasks` while the column is away and +The legend above the message box also carries `alt+l tasks` while the column is away and this session has run something. ## Using the roster from the keyboard -`alt+t` (`opt+t`) hands the keyboard to the roster. It is asked for, never taken: the draft is the -rest state, so a person who starts typing is typing, not navigating. +`alt+t` (`opt+t`) hands the keyboard to the column. It is asked for, never taken: the draft +is the rest state, so a person who starts typing is typing, not navigating. The cursor starts +on the first row that is work: a band row if there is one, else the first task. | key | what it does | | --- | --- | -| `↑` `↓` | walk the visible tree | -| `→` | open a folded family, or step to the first child | -| `←` | fold an open family, or jump to the parent row | -| `enter` | open the task's room, or a job's page; on the `jobs` label, toggle the section | -| `alt+w` | toggle the wider 46-column tree (bare `w` only on the full-frame roster) | +| `↑` `↓` | walk the rows: the band, the group headings, the tasks, then the jobs | +| `enter` | on a task, open its room; on a folded or open heading, fold or open that group; on a band row, open its thing; on a job, its page; on the `jobs` label, toggle the section | +| `←` `→` | in a chat in a team, switch between Tasks and Traffic; the cursor goes to the first row of the other view | +| `x` | stop the task under the cursor, where it can be stopped | +| `alt+w` | toggle the column 16 columns wider (bare `w` only over the full frame) | | `esc` or `alt+t` | give the keyboard back | -| `ctrl+g` | keep a foreground command when one can be kept; otherwise close the column altogether, or bring it back — this one works whether or not the roster holds the keyboard | +| `alt+l` | close the column altogether, or bring it back; this one works whether or not the column holds the keyboard | -The legend hint while it holds the keyboard is `↑↓ move · →← fold · enter open · esc`. -When depth has forced a title to be cut, the footer adds `alt+w widen · click seam` (or +The legend hint while it holds the keyboard is `↑↓ move · enter open · x stop · alt+w wide · +esc`, led by `←→ tasks/traffic · ` in a chat in a team. On a row waiting on your look the +slot says that row's answers instead. The footer adds `alt+w widen · click seam` (or `alt+w narrow · click seam` once it is wide); that hint is clickable as well as available -from the keyboard, and so is the `❯` door line under it. The latter includes `ctrl+g` -only when no foreground command owns the chord. **Both the hint and the seam appear only -from 120 columns up**, which is the only width that lends a wider tier — on a 100-to-119 -column frame the footer says nothing about widening and the column's left edge is part of -the row, not a handle. - -Every other key is given back. The roster cannot take the keyboard while the exit -confirmation, a permission question, a task proposal, or any overlay is up, and with no -tasks **and no jobs** of this conversation's on the column, `alt+t` falls through rather -than being swallowed — including in a directory whose earlier sessions ran plenty. There -are no rows down there to put a cursor on; the door `ctrl+. earlier` at the foot of the -column is how that work is reached. A session that has only started a server still has -the jobs section to put a cursor on, so `alt+t` takes it. - -**The walk stops at this conversation's last job, after its last task.** `↓` walks the -families and then the jobs section under them, and clamps there rather than carrying on -into the project's record. `enter` on a task row opens that task's **room**; `enter` on a -job row opens that job's **page**; `enter` on the `jobs` label toggles the section. It -used to walk into six dulled `earlier` rows below, which meant holding `↓` took you out of -this conversation's work and into another one's; old work is walked on the task page now -(`ctrl+.`), where `enter` goes inside its card. - -The cursor follows the task, not the row, when families reorder or fold around it. +from the keyboard. **Both the hint and the seam appear only from 120 columns up**, which is +the only width that lends a wider column; on a 100-to-119 column frame the footer says +nothing about widening and the column's left edge is part of the row, not a handle. + +Every other key is given back. The column cannot take the keyboard while the exit +confirmation, a permission question, a task proposal, or any overlay is up, and with +nothing on it to put a cursor on, `alt+t` falls through rather than being swallowed, +including in a directory whose earlier sessions ran plenty. The door `ctrl+. earlier` at +the foot of the column is how that work is reached. A session that has only started a +server still has the jobs section to put a cursor on, so `alt+t` takes it. + +**The walk stops at this conversation's last job, after its last task.** `↓` walks the band, +the groups and then the jobs section under them, and clamps there rather than carrying on +into the project's record. Old work is walked on the task page (`ctrl+.`), where `enter` +goes inside its card. + +The cursor follows the task, not the row, when a task moves from one group to another. If +its group is folded, the cursor rests on that group's heading. With the pointer, a row takes the hover background step. The next section has the whole of what a click on the column does. ## Clicking the tasks on the right — I cannot open a task from the sidebar, clicking a row does nothing, the list jumps instead of opening -**Anywhere on a task's row opens that task's room.** The state glyph, the name, the `#7`, -the blank cells after it — the whole visible row is that one door, at every width the -column stands at. A click moves the column's cursor to what was clicked but does not hand -the roster the keyboard; the draft is still where you type. +**Anywhere on a task's row opens that task's room.** The state glyph, the name, the time, +the blank cells between them: the whole visible row is that one door, at every width the +column stands at, and the hover ground covers exactly that row. A click moves the column's +cursor to what was clicked but does not hand the column the keyboard; the draft is still +where you type. -Exactly two things on a row mean something else, and **both of them are drawn on the screen -at the moment you press them**: +The other things on the column that answer a press say so by lighting under the pointer: -- **The `▸ +N` badge** at the right of a folded family's root. It is what says work is - hidden under that row, so pressing it opens the family. It is on screen all the time. -- **The disclosure triangle**, which appears in the leading cell of a family root — and of - a finished row holding a detail block back — **only while the pointer is on that row** - (`▾` open, `▸` folded). While it is drawn, pressing it folds; the rest of the row still - opens the task. +- **A group's heading** (`Queued 3 ▸`, `Done 6 ▾`) opens or folds that group. The hint line + says `Show what is done · click` or `Fold what is done · click`. The `Running` heading does + not fold, wears no mark and does not light. +- **A band row** opens its thing: a task's room, the member's chat at the question, or the + teams page for a decision put to you. `+2 more` shows the whole band and `fewer` folds it. +- **The header's words.** In a chat in a team, the word that is not in front brings its view + to the front; the `alt+l` at the right closes the column. The space between them lights + nothing and does nothing. -With the pointer anywhere else, that leading cell is the task's **state**, and pressing a -state opens the work it is the state of. It used to fold the list instead, whether or not -a triangle was drawn there — so a press aimed at a family root or a finished task made the -list jump and opened nothing. It was easiest to hit straight after walking into or out of -another task, because that is when the surface forgets where the pointer is and the -triangle is not drawn. +There is no disclosure triangle on a task row and no `▸ +N` badge: a task row is never a +fold. The folds are the group headings, and a press on a task's state glyph opens the task. **Two other cells used to swallow presses and no longer do.** The column's two leftmost -cells are the resize handle only from 120 columns up; on a narrower frame there is no -wider tier to pull to, so those cells are part of the row like any other. And the column -answers only for the rows it actually draws — a press below its last row belongs to the -message box, the legend or the status line under it, not to the column. +cells are the resize handle only from 120 columns up; on a narrower frame there is no wider +column to pull to, so those cells are part of the row like any other. And the column answers +only for the rows it actually draws: a press below its last row belongs to the message box, +the legend or the status line under it, not to the column. -A click inside the column that lands on no task at all still belongs to the column and -does nothing, rather than closing the task page you are reading. +A click inside the column that lands on no row at all still belongs to the column and does +nothing, rather than closing the task page you are reading. **A second click on the selected row keeps its task open**, with the same draft and reading position. Press `esc` or the back control to return to the conversation. @@ -2542,11 +2564,10 @@ nothing else, so a task you ran last week, in a session you have closed, is nowh screen until you open this. **There is no `/tasks` command** — though `sessions` is what the PLACE this opens is called on -the tab bar, reached with `alt+2` or `tab`. `/task <brief>` starts work; `/history` opens the same sessions place +the tab bar, reached with `alt+4` or `tab`. `/task <brief>` starts work; `/history` opens the same sessions place started — and so does a **bare `/task`**, which opens this very page rather than printing a usage line. The page is also reached from the one dim door line at the bottom of the task -column — `ctrl+. earlier`, or `ctrl+. view more` where the column has merely folded a -family away. +column, `ctrl+. earlier`, whenever the project has work this conversation never ran. The page takes the whole frame, the way the settings panel does. `esc` closes it. Three pages here take the frame — the settings panel, this one, and `/home` — and **only one of @@ -2667,7 +2688,7 @@ it does not shrink as you type a filter. All levels start expanded. Folding a br hand adds the number of hidden rows to the section heading as `folded away`. **Every door onto this place opens it, on a machine that has run nothing too.** `/history`, -a bare `/task`, `ctrl+.`, `alt+2` and `tab` all reach the same page, and with nothing on it +a bare `/task`, `ctrl+.`, `alt+4` and `tab` all reach the same page, and with nothing on it the page is its heading and one line naming what arrives there, instead of counts: ``` @@ -3170,30 +3191,30 @@ A task **this** session ran opens its room instead, which is the live thing: the `enter`, a strip chip and a `task 7` link all land there. Only work from a conversation that is closed opens the card. -## The one door line at the bottom of the task column: `ctrl+. earlier`, `view more` +## The one door line at the bottom of the task column: `ctrl+. earlier`, and where `view more` went -When there is more work than the column is showing, the roster's footer grows one more dim -line above the column's final `❯` hide door: +When the project's record holds work this column is not showing, the roster's footer grows +one more dim line: ``` ctrl+. earlier ``` Click it, or press `ctrl+.`, and the full-screen task page opens. The column is left exactly -as it was — the page is somewhere you go and come back from, not a state the column enters. +as it was: the page is somewhere you go and come back from, not a state the column enters. -**There is exactly one such line, never two**, and the words on it say what is behind it: +**There is exactly one such line, never two.** It is drawn when the record holds tasks +**this session never ran**: work from an earlier conversation, or from a window still open +beside this one. This is the common case: any directory you have worked in before has one. -- `ctrl+. earlier` when the project's record holds tasks **this session never ran** — - work from an earlier conversation, or from a window still open beside this one. This is - the common case: any directory you have worked in before has one. -- `ctrl+. view more` when the only thing held back is a **folded** family, so the column - is standing one row for work it is not drawing, and there is no earlier work to promise. +**`ctrl+. view more` is gone.** It stood for a family the column had folded away. The column +folds its own groups now (`Done 6 ▸`), and the heading is the door: press it and the rows +open in place. -A landed task of this session's, already drawn on the column, does not earn the line: it -would be offering to show you what you are looking at. So a first-ever session in a fresh -directory, with nothing folded and no record behind it, has no door line at all, and that -is not a bug. It is never drawn as a count of nothing. +A landed task of this session's, already on the column, does not earn the line: it would be +offering to show you what you are looking at. So a first-ever session in a fresh directory, +with no record behind it, has no door line at all, and that is not a bug. It is never drawn +as a count of nothing. ## Which task a row opens — two tasks numbered 7, a row opened a different task, the wrong transcript @@ -3260,8 +3281,9 @@ far task id is itself the room door, including while the task is running. ## Task roster and rooms while running on another machine Over `--host`, the roster beside the conversation lists that far conversation's tasks -from the far machine's record. `ctrl+g` closes or restores it exactly as it does for -a local conversation; it never falls back to tasks on the machine holding the screen. +from the far machine's record, under the same header, band and groups. `alt+l` closes or +restores it exactly as it does for a local conversation; the column reads only what this +window already holds, so drawing it never waits on the connection, and it it never falls back to tasks on the machine holding the screen. The far engine **pushes** every task update to every window attached to that conversation, so a row appears when the work is admitted, moves when it starts running, @@ -3324,7 +3346,7 @@ local conversation the same page tails that log live. | how you stop the work | `esc` | `x` over an empty box, which raises the confirmation card | | the box's own line | the bare `› ` | a tinted segment naming the task, in its state's hue, then `› ` | | box placeholder | the draft prompt | `Steer this task… (esc: main)`, or `Steer <title>… (esc: main)` where the frame is too narrow for the segment | -| pinned top rows | the pulse line, the tab strip under it, one thin rule and a blank — the same four rows every place draws; a dim `+N` at the strip's right end counts the tabs it could not spell, and `alt+k` opens the chats card | the same four rows — pulse, tab strip, rule, blank — so the rule does not move when you walk in; then a breadcrumb row (conversation → ancestor tasks → current task) and a quiet facts row under it | +| pinned top rows | the pulse line, then the tab strip, one thin rule and a blank. That strip is the chat's own row, so a place draws three rows (pulse, rule, blank) and the page starts one higher. A dim `+N` at the strip's right end counts the tabs it could not spell, and `alt+k` opens the chats card | the same four rows as the conversation: pulse, tab strip, rule, blank. Then a breadcrumb row (conversation, ancestor tasks, current task) and a quiet facts row under it | | legend word | the model, effort and approvals, with the remote machine when connected | `room · esc/←← main`, and `room · esc your line back` while a history walk is on | | legend hint | `esc interrupt` while a turn runs | `x stop` while there is work to stop, `↑↓ history` mid-walk, nothing otherwise | | the model on the status row | the conversation's model | `task <the task's model>` | @@ -3657,8 +3679,8 @@ the nearest ancestor it hides. The current task is inert. Unknown parents are om the UI never substitutes a bare task id for a name. Guest ancestry remains visible but inert because this window cannot use another conversation's local task ids. -The roster shows children with their parent and state. That tree and the breadcrumbs -use the same parent links; the separate `part of:` sentence no longer repeats +The roster shows each child as its own row under what it is doing. The breadcrumbs use +the parent links; the separate `part of:` sentence no longer repeats the parent. A compact `handed out:` row still names children and their state. Prerequisites that hold work back are still named in the header's state. A task awaiting an actionable decision keeps its answer row. @@ -3690,7 +3712,8 @@ marked failed, because nobody watched what became of it. ## Mentioning a task in the conversation -Type `@` in the draft and a list drops up with task rows above the file rows. The sections +Type `@` in the draft and a list drops up. Teams and conversations come first, then +task rows above the file rows. The task sections are `running`, `recent` (ended inside 24 hours) and `older`, in that order; the `older` heading carries `older · N more` when the list was cut. At most 8 task rows are drawn, though the search itself goes 40 deep so a match three sections down is still counted. A @@ -3786,12 +3809,12 @@ task's own proposals begin the moment they are made. What you see instead is the Where they show up: -- **the strip along the top** keeps one flat row of live chips on narrow frames; it does - not draw the family tree. -- **the roster** draws the whole family together, with each piece joined to its parent by - tree connectors and carrying its own id and state. +- **the strip along the top** keeps one flat row of live chips on narrow frames. +- **the roster** draws each piece as a row of its own under what it is doing (`Running`, + `Queued`, `Waiting`, `Done`), with its own state; it does not draw a tree. The hint line + over a piece's row names it whole. - **the parent's room** shows the `propose_task` calls as they are made, and the parent's - own words when the reports come back; its children remain grouped on the roster. + own words when the reports come back; its header lists its children and their state. - **the piece's own room** names the parent in its breadcrumb trail, so a task you walked into knows it is a piece of something. @@ -4165,9 +4188,8 @@ own cost row. The standing orders page has the rest of what an unattended run is ## Where the parts show up on the screen, and how to stop them -**Where you see it:** the parts appear in the task column under their parent, joined by tree -connectors and carrying their own id and state, exactly as pieces handed out from the brief -do. Walk into the parent's room and its header lists each part by name with the state it is +**Where you see it:** the parts appear in the task column as rows of their own, each under +what it is doing, with their own state, exactly as pieces handed out from the brief do. Walk into the parent's room and its header lists each part by name with the state it is in; walk into a part and its breadcrumb trail names the parent. **Stopping.** Stop the parent and its unfinished parts stop with it, their branches kept. @@ -4219,7 +4241,8 @@ same time. The setting `task.parallel` exists for anyone who wants a number anyway — settings panel (`ctrl+,` or `/settings`), category "spending". Blank means no limit. A cap is a queue and never a refusal: work past the cap waits and starts when a slot frees, and while it waits -its roster row reads `waiting · slot`; a waiting-only family starts folded. +its roster row says `waiting · slot` on its hint line, and it sits under `Queued`, which +starts folded to its heading. What actually runs out is the machine, not a count of tasks. Two real ceilings hold new starts instead: @@ -4577,9 +4600,9 @@ files, the branch, the model, the cost, the done-condition and the report. **A nested task asks the same way — a sub-task needs my look, a piece of a bigger task nobody checked.** Depth changes nothing about whether you are asked: the card, the roster row and the sub-task's own room all offer the same answers from the moment it lands. What -depth changes is how LOUD it is. While the task above it is still running, the sub-task -**folds** under its family head, because that task's own agent is the one being asked and -has the diff to read; when the head settles, one line says the question changed hands +depth changes is how LOUD it is. While the task above it is still running, the sub-task is +**not in the needs-you band**: it sits under `Waiting`, because that task's own agent is the +one being asked and has the diff to read; when the head settles, one line says the question changed hands (`task 4 has finished, and the piece of work it handed out that nobody could check — task 6, Port the parser — is now waiting on you rather than on it.`). It is never filed under `done`. diff --git a/internal/manual/chat/team-manager.md b/internal/manual/chat/team-manager.md new file mode 100644 index 0000000000..26a7bbba42 --- /dev/null +++ b/internal/manual/chat/team-manager.md @@ -0,0 +1,403 @@ +# The team manager + +## What a manager is + +A team can have one **manager**: a conversation that runs the team for you. You talk to the +manager, and it hands work to the team's members, keeps track of what each is doing, and tells +you where things stand. It is an ordinary conversation with every ordinary tool, under the +same permission rules as any other; what makes it the manager is the team verbs below, an +instruction from codeaf on its first request that it is this team's manager (with its members' +handles and the rules under **Who outranks whom**), and a short account of its team that it +carries on every turn: each member's handle and state, the question a member is waiting on, the +files each has touched, and the last few lines of the team's traffic. It never carries members' +whole conversations. A member of a team with a manager is told the same way which team it is +in, its handle, and that it reports with `team_post`. + +Every member has a **handle**: one lowercase word that says what the conversation is about, +like `@security` for `santosh dev2 branch code complexity & security review`, `@milestones` +for `CodeAF repo issue tags & milestones` or `@gravity` for `quantum gravity research updates`. +The moment a member has a title it gets a quick guess from the title's words, so it can be +addressed at once; then, when the conversation's title is made, the same cheap model that +names conversations chooses the word, once, for a few tokens. A timeout or a dropped +connection is asked once more, a moment later; a refusal is not, and the guess stands. If another member of the team +already has that word, the member takes the model's second choice, or the word with one word +of its title in front, like `@api-security`. A handle a person or the manager gave, like the +one `team_start` names a new member by, is never replaced, and a handle the model chose is not +chosen again, so a line in the traffic keeps meaning the member it meant. Messages in a team +are addressed by handle. + +Handles made before this were guesses, and each is chosen again the same way on its +conversation's next turn. Every change is written to the team's traffic as +`codeaf @review is now @security`, which the manager and every member are told at their next +step, and the manager's account of its team shows the new handle. Over `--host` the choosing +happens on the far machine, where the conversation and the model are. + +In the manager's replies, in the team's quoted cards and in a team tool's call, every member's +handle is a link: point at it for its title in the hint line, press it to open that member, +which resumes it first when this window does not have it open. A team's name in those same +places, written as a team (`team harbor`, `the harbor team` or `"harbor"`), is a link too. A +press opens the **teams page** with that team selected. The hint says `Open harbor on the +teams page · click`. Over `--host`, against an engine with no teams doors, the press opens the +conversations view on that team instead, and the hint says so. + +## Making a manager + +The **teams page** (`/teams`, `alt+2`) offers `+ Manager` on every team that has none, and +`All teams` offers one manager over every team. Choosing a team there puts its manager's +conversation in the page's pane, where you talk to it beside the tree of your teams. + +A team has no manager until you make one, and until then nothing about managers costs anything. +While a team is shown, the first place on the tab strip is the manager's, pinned at the left +like a pinned browser tab so it never scrolls away: + +- **`+ Manager`**, a quiet button, while the team has none. A press starts a new conversation + in the team's folder and makes it the manager. Point at it and the hint line says so. On a + window under 100 columns the button leaves the strip; the team switcher still offers it. +- **`◆ Make this harbor's manager`** in the team switcher (the `● harbor ▾` chip) makes the + conversation in front the manager, and in a tile's Teams list on the conversations view makes + that one the manager. When the team already has one, the row says which one it replaces: + `◆ Make this harbor's manager (replaces Shipping the parser)`. On the manager itself the row + reads **`◇ Make an ordinary member`**, which turns it back into an ordinary conversation with + all its history. + +Once there is a manager the place reads **`◆ Manager`**, and on the conversations view its tile +comes first, titled `◆ Manager · <its title>`. Point at the tab to see the team and the title in +the hint line. `alt+m` goes to the manager from any conversation in the team. + +## The manager's screen + +While the manager is in front, the message box says `to ◆ manager`, and keeps saying it on the +rule above the box once you start typing: everything you type goes to the manager and nowhere +else. With a member in front the box says `to @web` the same way. + +On the right is the conversation's column, the same one every chat has. Its header is two +words, `Tasks 14 · Traffic 8` with `alt+l` at its right: the word in front is in bold ink and +the other is dim, each is a button (point at it for what it shows, press it to bring it to +the front), and while the tasks are in front the Traffic word keeps counting what arrived, +`Traffic 3 new`. With the manager in front the column opens on the **Traffic**; with a member +in front it opens on the tasks. Each kind of chat remembers the word you last chose for the +rest of the session. With the column holding the keyboard (`alt+t`), `←` and `→` switch the +words. Nothing here moves the conversation: both words are drawn in the same columns. + +Under the header is what needs you, from both words: a member's question to you (`? @model → ◆ +keep the old schema?`), a decision put to you, and your tasks that are waiting on +you, in the needs-you amber; a task that failed and that you have not opened yet is its `✕` in +ordinary ink. Three rows at most, then `+2 more`; a line closes the band, and when nothing +needs you there is no band at all. Pressing a question opens the member at the question; a +decision opens the teams page. What is in the band is not drawn again under it. + +In the manager's chat the Traffic is the team's **work**, one line each, the newest at the +top. Every row reads who it is from and who it is for, then the words: + +``` +Tasks 14 · Traffic 8 alt+l +? @model → ◆ keep the old schema? 3m +✕ parser bench incomplete +────────────────────────────────────────── +◆ → @scrape +2 Please provide a st… ▸ 2m +◆ → @model Refactor the rail… ▾ 1h + ↳ @model → ◆ ✓ done, 3 files… 4m + ↳ @model → ◆ working… now +General 2 msgs ▸ 1d +``` + +- A row is a thread (below): `◆ → @scrape +2` is the manager to the first member, and `+2` + for the ones that do not fit, then what it said. The state its answers leave it in + (`running`, `asking`, `done`, `failed`) and how many messages it holds sit at the right + when they fit, and the hint line always says them. How long ago sits at the right of + every row, dim: `now`, `2m`, `3h`, `1d`, the same words a task row uses. The band's + questions carry it too. In a narrow column the arrow and the names stay, then the age, + and only the words are cut, at a word, with `…`. +- `▸` lays the thread's replies open under it, one `↳` line per member, each `from → to` + the same way (`↳ @model → ◆ ✓ done, 3 files changed 4m`): `✓` on an answer from a member + that finished its turn, `✗` for one that failed, `working…` for a member the message woke + that has not answered. Each reply keeps its own age at the right. `▾` (or + `enter` on the row, with the column holding the keyboard) folds them. `▸` and `▾` are the + only part of a thread row that folds it. The rest of the row opens the message. +- Everything that answers nothing and is answered by nothing (notes, starts, stops, handle + changes, anything written before threads) is the one **General** thread, laid open the + same way. A start that made a sub-team reads `◆ manager started @api to run backend`; the + name is the team's name now, so a rename replaces `backend` on the next frame. +- A thin `new` line stands under what arrived since you last looked, and stays put while you + read. + +Every `@handle` is a link: point at it for the member's title in the hint line, press it to open +that member (resumed first when this window does not have it open) **scrolled to the +message**: a handle on a thread's row opens the member at the directive as it was told it, and a +handle on a reply opens it at its own post. A press anywhere else on the row opens the +conversation that message belongs to, at that message, and lifts it the same way. A message the +sender wrote opens the sender's chat: `◆ → all` opens the manager at that directive, and +`you → ◆` in a member's chat scrolls that chat to the reply. A message to you opens the +manager's chat. If that conversation is already in front, the row scrolls it in place and does +not open another. The hint says `Open ◆'s message · 2m ago · click` (or `Open your message` +when the row is yours, and `now` with no "ago" when it just arrived). The message is brought +into view and lifted for a moment; nothing here takes the keyboard, and nothing opens a new +window. A message from before the conversation's history opens it at the bottom, and the hint +line says `that message is older than this chat's history`. + +In a member's chat the Traffic is the messages to or from that member (and to the whole team), +one line each, newest first, and that member is `you`: `◆ → you parser numbers? 2m` from the +manager, `you → ◆ ✓ p50 41ms, p99 180ms now` back, `you → @gravity rebase done 3h` to another +member. Press the member's own line to scroll this chat to it. Press a line the manager wrote +to open the manager at it. General, laid open, uses the same `from → to` and the same age on +each of its lines. + +`alt+l` puts the column away and brings it back, and this window remembers the answer (`ctrl+g` +is the same key under its older name). Put away, the column is an edge down the right with a +count of what arrived in the Traffic since you last looked; press it or `alt+l` to bring it +back. On a window under 100 columns there is no column and no edge: `alt+l` lays the column +over the conversation, and `esc` or `alt+l` takes it off again. + +Over `--host` teams and the manager work as they do locally. The teams and their Traffic are +kept on the machine the conversations run on, and the window reads and writes them there, so +the Traffic is the team's own and a manager set from the laptop is the one the far session +follows. Against a far machine running an older codeaf, `+ Manager` and the menus say managers +are not available over `--host`, and the column has no Traffic word. + +When the manager starts a member with `team_start`, you are asked first, on a card that reads +`◆ manager wants to start @lexer`, with the brief under it and the clause `a new conversation; +it spends until it stops`. When you allow it, this window opens the new conversation in the +team's folder **behind** the one you are in, never in front of it: what you were typing stays +where it was. Its tab arrives at the end of the team's run, named `@lexer` until it has a title, +and its working mark is the only thing that moves. With the team's auto-wake on, the member +starts on its own: it is handed the brief on its first request, marked `◆ brief from manager`, +and its page shows the brief as a quoted card headed `◆ manager → @lexer`, never as your +message. With auto-wake off the conversation is still opened behind the one you are in, and +no turn is started; the traffic says `opened @lexer; this team's auto-wake is off, so no turn +was started. It reads the brief when it next runs.`, and the brief arrives on that next turn +the same way. When the manager stops a member, +this window stops it the way your own Stop would. Both happen only in a window that has those +conversations open. + +## Who a Traffic row is from and who it is to + +Every Traffic row reads `from → to`, then the words. The manager is `◆`. Several recipients +are the first handle and `+2` for the rest. In a member's chat that member is `you`, so a +question to it reads `◆ → you` and its answer reads `you → ◆`. A reply under a thread is the +same shape after `↳` (`↳ @model → ◆ working… now`). The band's question is the same shape in +amber (`? @model → ◆ keep the old schema? 3m`). How long ago is on the row, at the right, +dim, at every width: `now`, `2m`, `3h`, `1d`. A narrow column keeps the arrow and the names, +then the age, and cuts only the words, at a word, with `…`. Press a handle to open that +member at the message. Press anywhere else on the row to open the chat that message belongs +to, at that message. The hint says `Open @model's message · 3m ago · click`. + +## How old a Traffic row is, and what pressing it opens + +Every Traffic row ends with how long ago it was, dim and at the right: `now` (under a minute), +`2m`, `3h`, `1d`. The same words a task row and a home session use. It is on a thread +(`◆ → @scrape +2 Please provide… ▸ 2m`), on a reply (`↳ @model → ◆ ✓ done 4m`), on General, +on the band's question, and on a member's own lines (`you → ◆ now`). A narrow column keeps +the arrow, the names and the age, and cuts only the words, at a word, with `…`. + +Press anywhere on the row, not only on a handle, to open the conversation that message belongs +to, at that message. A message the sender wrote opens the sender's chat: `◆ → all` opens the +manager at the directive, and `you → ◆` in a member's chat scrolls that chat to the reply. A +message to you opens the manager's chat. If that chat is already in front, the row scrolls it +and does not open another window. The focus stays where it was. The hint says +`Open ◆'s message · 2m ago · click`, or `Open your message · now · click` for your own line. +`▸` and `▾` still only fold the thread. A handle still opens that member. + +## What members say without being asked + +A member of a team that has a manager tells the manager, through the traffic, three things it +would never write in a message: + +- `finished` when a turn ends, `stopped` when somebody stopped it, and `failed: ` with the + error's first line when a turn ends on one; +- when it starts waiting on you: the permission line for a permission prompt (`needs your ok + to run bash`), or `asks: ` and the question for anything else; +- `no longer waiting` when the last of those questions comes down. + +Each is one line of traffic per change, never one per step. They are the session's own words; +nothing you type is ever written to the traffic. `team_status` reads them too, so a member held +on a permission prompt shows as `asking` rather than `running`, for as long as some process +holds that conversation's transcript and the wait is under 30 minutes. + +## Why a member stays asking after it crashed + +It does not. `asking` means a live process is held on the prompt. If that process dies, the +transcript lock is free and the member reads as idle. The same happens when the wait is older +than 30 minutes, even if a process still holds the transcript: nothing is still asking. + +## Who a member reports to + +A conversation can be in more than one team, but it **reports to** exactly one manager, its +home: the nearest manager above it, picked for you and never changed by itself. Its home +manager directs it; every other manager whose team it is in is a **link**, which may read it +(`team_read`) and send it a note, and nothing more. A link's `team_send` of a directive, and +its `team_stop`, are refused with a sentence saying whose the member is; a directive to +`everyone` goes to the members who report to that manager and names the ones it left out. +In `team_status` a shared member reads `reports to dock`, and `busy for dock` while it runs. + +## Who outranks whom + +Your own words come first. What you say in a member's own conversation stands over anything +the manager tells it, then the manager's directives, then other members' messages. A member +reads a manager's message marked `◆ from manager` and a teammate's marked `from @web`, never +as if you had typed it. + +The manager **cannot answer a member's permission prompt**. Those are yours; a member waiting +on one waits for you. + +## The manager's verbs + +| Verb | What it does | Asks you first | +|---|---|---| +| `team_status` | every member's handle, title and state (running, asking, idle, failed), the question waiting, the files touched, and recent traffic | no | +| `team_read` | the end of one member's conversation, bounded; the member is not told | no | +| `team_send` | a message to one member, to several (one message, every handle in `to`), or to everyone, as a note (information, which waits) or a directive (an instruction, which starts an idle member) | no | +| `team_stop` | ends one member's current turn, the way your own Stop does: nothing is deleted, and its background tasks and jobs keep running | no | +| `team_start` | a new member conversation with a handle and a brief; it opens in the team's folder and is handed the brief, marked as the manager's, on its first request. With kind `team` it starts a sub-team instead (see **Sub-teams**) | yes | +| `team_decide` | answers a decision packet waiting on the manager, most often a member's question: an option, or its own words | no | +| `team_escalate` | sends a packet waiting on the manager up, to its own manager or to you, with the reason it is not the manager's to decide | no | +| `team_close_report` | brings you the team's closing report (done, left, where the files are) after you asked it to wrap up | no | +| `team_raise` | raises a conflict to the manager above every party (see **Conflicts between members and teams**); members have it too | no | + +`team_start` asks because a new conversation spends money for as long as it runs, and it is +refused while the team is at its daily cap. The others act only inside the team you made, and +every one of them is logged in the team's traffic. Questions, packets, caps and wrapping up are +on the page **Team questions, decisions and caps**. +Like any tool, each can be set to ask or allow in `/settings` under the tool approvals. + +## The member's verbs + +A member of a team that has a manager has `team_post`: a message to the room (every member and +the manager), to one teammate by handle, or to the manager. Members use it to report progress, +share a finding, ask a teammate, or say they are blocked. It also has `team_raise`, for a +conflict it cannot settle with the other side itself. + +## A manager is told when a member moves + +Moving a conversation from one team to another, or moving a team under another, writes one +line to the Traffic of each team it touches. The team that lost the member says +`@web moved to harbor`. The team that gained the member says `@web joined from ops`. For a +team moved under another, that is the moved team's Traffic and its new parent's. A manager +reads those lines the next time it wakes, in the Traffic it already reads. Nothing about the +move wakes it by itself, and a move that was refused writes no line. + +## Sub-teams + +A manager can start a **sub-team**: `team_start` with kind `team`, a name for the new team, a +handle and a brief for its manager, and optionally members of its own team to move into it. You +are asked first, on the same card as any start, which then reads `a new team "backend" under +yours`. When you allow it: + +- the new team is made under the manager's team, with its share of the pool: the parent's daily + cap times `sub-team share` (`/settings`, **Teams**; 50% by default), written on the new team. + A parent with no cap gives none, and the new team spends from whatever pool is above it; +- the members named move into it, and its manager is the new conversation, which opens behind + the one you are in like any start, is a member of the parent team, and is handed the brief + marked as the manager's together with the words `you were started to manage the team + "backend"`. It makes itself that team's manager and reports to the manager that started it; +- the traffic of both teams says so: the start in the parent's, and in the new team's a line + naming who made it and who runs it. + +It is refused, with the reason, past the team depth (`team depth` in `/settings` under +**Teams**, three levels by default, a team's own override first), under a closed team, at the +team's daily cap, or when the name or the handle is taken. + +**Orders go one level down, reports one level up.** A manager directs its own team's members, +and a sub-team's manager is one of them; it never directs a sub-team's members. A `team_send` +directive or a `team_stop` naming one is refused with a sentence that names the sub-team's +manager to send to instead. A message to `everyone` reaches the manager's own members only. A +manager may still read a conversation in a team under its own with `team_read`, naming it +`backend/@parser`. A sub-team's manager reports to the manager above: its `team_post` to the +manager and its own questions go there first. + +**A sub-team with no manager of its own** answers to the nearest manager above it: its members' +questions go to that manager, and their `team_post` to the manager reaches it, marked with the +team it came from. Their posts to the room stay in their own team. That manager does not direct +them; give the sub-team a manager, or move them up, for that. + +## The global manager + +With several top-level teams there is no one manager over all of them until you make one on the +teams page's `All teams` row. That conversation is the **global manager**: the manager of a +team that holds every other team. Its members are the managers of the top-level teams, and +only them: codeaf adds each one to `All teams` for you, its account of its team lists only +those managers, and its directives reach them and never their members. The top-level managers +report to it, so their questions and conflicts between teams come to it before they come to +you. It can start a new top-level team with `team_start` of kind `team`. Without a global +manager, nothing here changes: each top-level manager reports to you. + +## Conflicts between members and teams + +When two or more conversations need incompatible things (the form posts JSON, the endpoint +takes form data) and cannot settle it between themselves, one of them raises it with +`team_raise`: the question, the other parties by handle (`@api`, or `back/@api` for a member +of another team), its own side, and the options, each with what happens if it is chosen. A +conflict is never detected for you; a party declares it. + +It goes, as one decision packet, to the **lowest manager above every party** who is not one of +them, in one hop: two members of one team go to its manager, members of two sibling sub-teams to +the manager of the team both sit under, and two top-level teams to the global manager. With no +such manager it comes to you, in the inbox on the teams page. That manager is woken and handed +the packet whole; the other parties are told it was raised. It rules with `team_decide`, or +sends it up with `team_escalate`, never sideways. **The ruling reaches every party as a +directive**, marked as a ruling on that conflict, in each party's own team's traffic, and wakes +each of them, whoever ruled: a manager, or you. A party never decides its own case, even when +it manages the team the packet waits on. + +## Threads: what answers what + +Every line a member is handed carries its number, `◆ directive from manager #42: …`. A +member's `team_post` to the manager answers the last message the manager sent it, by itself; +to answer another it names it, `thread: #41`. The member's finishing, failing or asking, and +the wake that started it, answer the same message, which is how the Traffic and the chats draw +them under it. A message to several members is one message, so the question and its answers +are one thread however many were asked. + +**In the manager's chat** a `team_send` reads as the head of its thread, +`team_send ◆ to @agent @checking @review · do`, with the message quoted under it and each +answer attached under that in muted ink as it arrives, one line each. Press an answer's words +to read it in full and again to fold it; point at them for the whole text in the hint line; a +handle opens its member at the message: on an answer, at the member's own post, and on the +card's header, at the message as the member was told it. A turn that sent one is not folded into a `worked` chip, so the +thread stays where you can see it. The step over it is captioned as the work it is, +`messaged @agent @checking @review`, never by the tool's name, and a run of sends reads +`sending 3 messages`. + +The answers also reach the manager as its team's note. So nothing is shown twice, a note +whose answers are already under their question reads as one dim line, +`· @checking @review answered · in the thread above`; a line that answers nothing is drawn in +full as before. + +**In a member's chat** the manager's message is the quoted card it always was, headed +`◆ manager → @web do`, and the member's own answers to it hang under it the same way. + +## When messages arrive + +A message reaches a conversation at the start of its next step. When the conversation is +working, that is straight away. When it is idle, it depends on the kind of message: + +- A **directive** starts an idle member's turn. The member is handed the directive, marked + `◆ directive from manager`, never as if you had typed it. +- A **note** wakes nobody. An idle member reads it when it next runs, for whatever reason. +- A member's **reply to the manager** (`team_post` to the manager), and a member finishing, + failing or starting to wait on you, start an idle manager's turn. Replies that arrive within + a few seconds of each other are gathered into one turn rather than one turn each. + +A member no window has open is opened by codeaf in the background so it can run, and a window +that opens it later joins the running conversation. When that cannot be done, the traffic says +`could not wake @web:` and why, and the message waits for the member's next turn. + +Every wake is a line in the traffic, `◆ woke @web` or `@web woke ◆`, so the Traffic shows why a +conversation is running. A wake spends through the same limits a turn you start does, and two +more bound it: one conversation is woken at most 20 times an hour, and a manager woken 10 times +by its team with nothing from you stops being woken and asks you instead, as a waiting line in +the traffic. It is woken again after you next say something to it. + +A team's auto-wake can be turned off. `team messages wake` in `/settings` under **Teams** is +the default every team inherits (on), and a team can override it for itself and the teams +under it: its entry in `teams.json` in the profile carries `"wake": false` (or `true`). With it +off, every message waits for each conversation's next turn, and a member the manager starts +with `team_start` is opened and handed its brief on that next turn, with no turn started for +it. The traffic says so. + +A member busy in one long command reads a message when that command returns, which is what +`team_stop` is for. Nothing is delivered twice, and a conversation that joins a team is not +handed the team's earlier history. A conversation reopened later is handed what was said to it +while it was closed. + +The traffic itself is kept in the profile of the machine the conversations run on, in +`teams/<id>/traffic.jsonl`, one line per message, only ever added to. diff --git a/internal/manual/chat/team-questions-and-caps.md b/internal/manual/chat/team-questions-and-caps.md new file mode 100644 index 0000000000..fdc2607ce5 --- /dev/null +++ b/internal/manual/chat/team-questions-and-caps.md @@ -0,0 +1,107 @@ +# Team questions, decisions and caps + +## Where a member's question goes + +In a team with a manager, a member's clarifying question goes to **its manager first**, not to +you. When the member asks with `ask` (a question it needs answered to go on: which of two +shapes, what a word means, whether to go ahead), nothing appears on your screen: the question +becomes a **decision packet** for the manager it reports to, and the member is told it went +there. The manager answers it with `team_decide`, the member is handed the answer marked +`◆ answered: …` and carries on, and the traffic rail shows `answered @web: …`. A member that +was idle is woken by the answer. + +When the manager cannot or should not answer, it sends the question up with `team_escalate`: +to its own manager, or to you. It reaches you only when no manager above could decide it. + +**Permission prompts never go up.** A member asking to run a command or edit a file asks you, +always, and no manager can answer that for it. + +This is the setting `questions go to the manager` in `/settings` under **Teams**, on by default. +A team can override it for itself and the teams under it, on its card (the **teams page**); +with it off, a member's questions come to you as they always did. + +The **Teams** tab of `/settings` holds the defaults every team inherits: `questions go to the +manager`, `team messages wake`, `daily cap per team`, `team depth` and `sub-team share`. Its +dim line says `a team can override any of these on its card · saved to your profile`. Over +`--host` the same five rows are the other machine's, and a change is saved there. Each value +says `from Settings`, the same words a team's card uses when it inherits them. An older +engine that cannot take the change keeps the tab read only and says +`changing them is not available over this connection`. + +## What a decision packet is + +Everything that has to be decided above the conversation that met it travels as one packet you +can answer without reading a transcript: the question, who raised it and what each side said, +the options with what happens if each is chosen, and a recommendation with its reason. The same +packet is answered by a manager or by you. Packets waiting on you are in the **inbox** on the +teams page, one card each, with the options as buttons and `Your own answer…` for words of your +own. A packet waiting on a manager shows as `waiting on ◆ harbor`, and you can still decide it +yourself: you outrank every manager. + +A manager's own questions reach you the same way: as a packet addressed to you, in the inbox, +when it has no manager above it. Your answer is handed to the manager marked `◆ answered: …` +and wakes it. + +Packets are kept in the profile of the machine the conversations run on, in +`teams/<id>/decisions.jsonl` for the team each was raised from. Past a megabyte the file starts +a new one, keeping every packet still waiting. + +## A team's daily cap + +A team can have a daily cap: `daily cap per team` in `/settings` under **Teams** is the default +every team inherits (no cap), and a team can set its own. A cap counts the team and every team +under it together, one pool. + +When the pool reaches its cap: + +- nothing new starts in it: a directive no longer wakes a member, replies no longer wake the + manager, a new member's brief waits, and `team_start` is refused. A turn already running is + never cut off; it finishes, and what was held is delivered at each conversation's next turn; +- you are asked once, with a card `harbor reached its $5 cap today`: **Raise to $10** (the + team goes on until $10 today) or **Stop for today** (members finish their current turn and + start no new one until tomorrow), with a recommendation; +- your own messages in a member's conversation are never held; the cap is on the work the team + starts by itself. + +A manager can never raise a cap: money is yours. Every held wake is one line in the traffic, +`held @web: harbor reached its $5 cap today`. + +## Two windows ask once when a team reaches its cap + +You are asked once for that team, that day, and that ceiling. A second codeaf window, or a +wake while the terminal is closed, finds the card already raised and adds nothing, so you do +not get two copies of `harbor reached its $5 cap today`. The next day asks again. The same +day asks again only after you choose **Raise to $10** and the team then crosses that new +ceiling. + +## Wrapping up and closing a team + +`Close…` on the teams page, `Close team…` on a team's card, or `D` on the conversations view +closes a team; with nothing running it closes at once and offers Undo (the **teams page** has +every path). Closing a team with work running offers **Wrap up first**. The manager is asked to tell every +member to finish the piece in hand and commit, to answer what it can, and then to bring you a +**closing report** with `team_close_report`: what was done, what is left, where the files are, +and what the team spent today. It arrives as a card with **Close** and **Keep going**, and the +team closes only when you pick Close. + +The wrap-up has 15 minutes and $2 of team spend. When it runs out of either before the +manager reports, codeaf brings you the report itself, marked `wrap-up incomplete`, with +**Close now** and **Keep going**. + +## What if the wrap-up report could not be sent, the decisions file was busy + +A wrap-up that runs out of its 15 minutes or its $2 before the manager reports is +sent by codeaf itself, marked `wrap-up incomplete`, with **Close now** and **Keep +going**. If that write cannot take the decisions file because another writer still +holds it, the countdown stays due. The next look tries again. It does not wait for +a restart, and it does not send the report twice. A report that did go out clears +the countdown in memory and on disk, once. + +## What happens to a wrap-up when codeaf restarts, does a wrap-up keep going if I quit codeaf + +The countdown is kept with the team, in `teams.json`: the moment the wrap-up began, and the +15 minutes it was given. Quitting codeaf, or the engine restarting, does not drop it and +does not hand out another 15 minutes. The next time the manager's conversation is open, the +countdown continues with the time that is left. If that time already ran out while codeaf +was closed, codeaf brings the incomplete report once, the same way it does when the clock +runs out with codeaf open. Opening codeaf again does not bring that report a second time. diff --git a/internal/manual/chat/teams-page.md b/internal/manual/chat/teams-page.md new file mode 100644 index 0000000000..279960b45f --- /dev/null +++ b/internal/manual/chat/teams-page.md @@ -0,0 +1,365 @@ +# The teams page + +## What the teams page is, and how to open it + +The **teams page** is where you run your teams: every team you have, what waits on you from +them, and the manager of the team you choose, which you talk to right there. It is the second +place on the tab bar, right after home: `home teams chats sessions spend settings`. Open it with +`/teams`, `alt+2` (`opt+2` on a Mac), a click on the word `teams`, `tab` from home, or the map +(`alt+.`). A number beside the word on the bar counts the decisions waiting on you that arrived +since you last looked. + +A team is a group of conversations you name, and a team's **manager** is a conversation that +runs it for you (the **team manager** page). The conversations view (`alt+v`) is where you see +every conversation at once and group them; this page is where you steer the teams you made. + +## Where a team link in a chat opens + +A team link in a chat opens this page. That is a team's name written as a team (`team harbor`, +`the harbor team`, `"harbor"`), a team name on a team card or in a team tool's row, and a +`●harbor` you sent with `@`. A press selects that team: the rail's cursor on it, the pane +showing it. A closed team is selected inside `Closed`, and that fold is opened. The hint says +`Open harbor on the teams page · click`. Over `--host`, when the engine has no teams doors, +the press opens the conversations view on that team instead, and the hint says so. + +## The rail: your teams as a tree + +The left column is the **rail**: + +``` + All teams + Manager │ + ● harbor ◆ ? 1 │ + ● orbit ⠿ │ + ● docs │ + │ + + New team in harbor │ + ✦ Organize │ + │ + ▸ Closed · 2 │ +``` + +- **`All teams`** is the top row. With no manager over every team it offers `+ Manager`, + which starts one conversation that manages all of your teams: you talk to it, and it talks + to each team's own manager. Once there is one, the row is that manager's. +- **Every open team**, a sub-team indented under the team it belongs to, with its colour dot. + A team with a manager wears a dim `◆`. +- **A mark only when something is happening.** A dim `⠿` says a member of the team is + working; an amber `? 2` says two things wait on you from it or from a team under it: a + decision addressed to you, or a member stopped on a question only you can answer. A team + where nothing is happening draws no mark at all. +- **`+ New team`** makes a team of the conversation in front (the new-team card of the + conversations view). With a team chosen it reads **`+ New team in harbor`** and the new team + is made inside that team; on a narrow rail it takes two rows, `+ New team` and `in harbor`. + A team already at its depth limit dims it and says why. **`✦ Organize`** suggests teams for + your conversations and offers to close the quiet ones (see *Organize closes quiet teams* + below). +- **`▸ Closed · N`**, folded at the foot, holds the teams you closed. A press opens the fold + and lists them; a press on one shows what it left behind. + +`↑` `↓` walk the rail, `enter` or a press chooses a team, and `←` `→` cross between the rail +and the pane beside it. Choosing a team with a manager brings that manager's conversation in +front, in the pane. The tab strip is not drawn on this place. The conversation you were +in stays open behind: `chats` on the top line, or `tab`, brings it back, and its tab is +on the strip once that chat is in front. + +## The pane: the team you chose + +The right side is the team you chose, from the top: + +**The header** is one line: + +``` + ● harbor ◆ Manager @news ⠿ working @review ? asking +4 idle $0.42 today Settings Close… Open ▦ +``` + +The team's name; **`◆ Manager`**, a door to its manager (the conversation below it on this +page); then only the members that are doing something, each a door with its title and state +in the hint (`@news · weekly news digest · working · click opens`): `⠿ working`, `? asking` in +amber when a member is stopped on a question for you, `✗ failed` in red when its last turn +failed. Everyone else is one quiet word, **`+4 idle`**, or **`6 members`** when nobody is doing +anything, and a press on it opens the members card. Then what the team spent today, shown +only when there is a spend or a cap to compare it with: `$0.42 today`, or `$0.42 of $5 today` +under a daily cap. When the cap is inherited from the team above, the header names whose it +is, `$1.20 of $5 today · harbor's cap`, because a cap is one pool for a team and every team +under it. Then three word buttons: **`Settings`** (the team's card, `s`), **`Close…`** (`c`), +and **`Open ▦`** (the conversations view narrowed to this team, `w`). + +On a narrow screen the line gives up its parts in order: the idle word first, then the spend, +then the members' chips from the last, then `◆ Manager`, then the buttons from the right. The +team's name always stays. `p` opens the members card whatever the width. + +**The members card** (`+4 idle`, `6 members`, or `p`) is titled the way the header counts, +`harbor · ◆ Manager · 1 member`, and lists every member, one row each: its +handle, its title, what it is doing, when it last moved, and **`Open`** for a conversation this +window has open or **`Resume`** for one it does not. A member that reports to another team's +manager carries a small `also in test` tag, and its hint says `reports to test's manager`. +`Open` goes to the conversation. `Resume` opens it **behind**, in a tab of its own, without +moving you: the page says `@docs is open behind, in its own tab`, and the row turns to `Open`. +`↑` `↓` walk the rows, `enter` opens or resumes, `esc` or `Close` puts the card away. The +page never says `not open`: whether a conversation is open is a fact about this window, not +about the team. + +**What waits on you.** Each decision addressed to you is a card, led by the same `?` the rail +and the tabs use for something that needs you: + +``` + ? conflict · raised by @boss waiting on you + Which lexer do we keep? + @parser the new lexer is 3x faster and passes every test + @model the old one is what the grammar tool emits + Keep the new lexer we maintain a fork ✓ recommended + Keep the old lexer 3x slower, no fork + recommended because speed is the goal of this team + Your own answer… +``` + +One press on an option's word decides it, and the answer goes back to whoever raised it. +`Your own answer…` opens a line for words of your own; `enter` decides with them and `esc` +puts it away. A closing report shows what the team did, what is left, where the files are and +what it spent; a cap card shows `spent $5.20 of $5.00 today · harbor's cap` and offers +`Raise to $10` or `Stop for today`, which only you can decide. A member stopped on a +permission prompt shows `? @web asks` with the same answer buttons home offers for it, the +prompt's own options. The newest three cards show whole; older ones fold to one line each, +`▸ question · which port? waiting on you`, and a press unfolds one. While the manager's +conversation is under them, the cards take about a third of the window: the newest (or the +one you unfolded) is whole, older ones stay whole while they fit, and the rest fold, so +there is always room to read and steer the manager. A card waiting on a manager instead of +you leads with `◆`, reads `waiting on ◆ harbor`, dim, and you can still decide it: you +outrank every manager. The **team questions and caps** page says what a packet is and where questions +go. + +**The manager's conversation.** Under all of that is the team manager's own conversation, the +real one, with its transcript, its prompts and its message box, which says +`to ◆ harbor manager`. Typing talks to the manager. The conversation's right-hand column +(`Tasks` and `Traffic`) is folded on this page, because the teams rail already has the left; +`alt+l` or its edge unfolds it. A press on a handle in the Traffic goes to that member's +conversation, off the page, exactly as it does in the conversation's own screen. + +## Renaming a team updates the message box + +The box reads the team's name when it draws. After a rename it says +`to ◆ <the new name> manager` on the next frame, and a Traffic line +`to run <name>` does the same. Neither keeps the name from when the page opened. + +While the manager's conversation is on its way in, the pane says `opening ◆ harbor's +manager…`. It never waits silently: if the conversation cannot be opened, or has not answered +within four seconds, the pane says why, `couldn't open ◆ harbor's manager: <reason>`, and +offers **`Retry`** and **`Open in chats`** (the manager as an ordinary conversation, off the +page, where anything else wrong is said on its own line). When the manager's conversation is +gone from the disk, the pane offers **`+ Manager`** instead, which starts a new conversation and +makes it the team's manager. + +## The pane said the manager was open in another window + +A refusal about a conversation this window already holds is not said. That includes +a connection that keeps one conversation at a time: if the swap is told the +transcript is locked and this window already holds that manager, behind or in +front, the pane does not say `open in another window`. The manager is brought +forward instead. + +**A team with no manager** shows `+ Manager` under its members, beside one line on what a +manager does; a press starts a new conversation in the team's folder and makes it the manager. +Choosing `All teams` shows every decision waiting on you from any team. + +## Moving a team inside another team, and adding a chat to a team + +Teams nest: a team can sit inside another, the way `orbit` sits inside `harbor` on the rail. +You move a team by choosing where it goes. + +**Move into…** Choose a team on the rail and press `m`, or open the team's card and press its +**`Inside: harbor ▾`** row. A picker opens with every team as a tree and `Top level` first: + +``` +╭─ Move dock into ─────────────────────────────╮ +│ Filter ▏type to filter │ +│ ─────────────────────────────────────────── │ +│ Top level │ +│ ● harbor │ +│ ● orbit │ +│ ● dock │ +│ ─────────────────────────────────────────── │ +│ orbit is 2 levels deep · limit 2 · Settings │ +╰──────────────────────────────────────────────╯ +``` + +Typing filters the list and the tree keeps its indent. `↑` `↓` walk, `enter` moves, `esc` +cancels. **A team that cannot take the move is dimmed, not hidden**, and the line at the foot +(and the hint line) says why: the team itself (`a team cannot go inside itself`), a team inside +it (`orbit is inside dock`), a closed team, a team already at the **depth limit** +(`orbit is 2 levels deep · limit 2 · Settings`, and `set on harbor` when a team above set the +limit), or where it already is. The depth limit is `team depth` under **Teams** in +`/settings`, and any team can override it on its card. + +**Several teams at once.** `space` on a team's row picks it, and it wears `☑` in place of its +dot; `m` then moves every picked team with one choice. `esc` clears the picks. A picked team +inside another picked team moves along inside it. + +**Dragging.** On the rail you can also drag a team with the pointer. A drag starts only after +you move two cells with the button held, so a click still only chooses the team. While you +drag, only a team that can take it is highlighted, and the hint line says +`Drop to move dock into harbor`, or why the team under the pointer cannot take it. The empty +rail under the teams is the top level, marked `↳ Top level` while you drag. `esc` drops the +drag and nothing moves. + +**Adding a chat to another team.** Open the members card and drag a member's row onto a team +on the rail: the hint says `Add @crane to harbor`, and the conversation is **added** to that +team. It stays in the team it came from; a drag never takes a conversation out of a team. +Removing one is always its own step, in the team switcher or the conversations view. + +**When a move changes who is in charge, you are asked first**, in one line at the top of the +pane (or on the team's card): + +``` + dock will report to harbor's manager · its $3/day becomes part of harbor's $10 pool Move Cancel +``` + +It appears only when the move changes one of three things: which manager the team's +conversations report to, which capped pool its spending counts toward, or which manager decides +a conflict inside it. Any other move happens at once. + +**Every move can be undone.** For a few seconds after a move, confirmed or not, the pane (or the +card) says `dock is in harbor now Undo`; `Undo` or `u` puts it back where it was. + +## A move is written to Traffic + +When a move is kept, Traffic records it. The team that moved, and the team it left, each get +`@crane moved to harbor`. The team it joined gets `@crane joined from ops`. One line per +member, once. A move that was refused (the team could not go there) writes nothing. A manager +whose team gained or lost someone reads that line the next time it wakes, from the Traffic it +already reads. The move does not start a wake of its own. + +## Keys on the teams page + +While the manager's conversation has the message box, keys type into it, as in any +conversation. The page keeps these: + +| Key | What it does | +|---|---| +| `alt+↑` `alt+↓` | put the keyboard on the page's buttons and walk them (`opt+↑` `opt+↓` on a Mac) | +| `esc` | from the page's buttons, back to the message box | +| `tab`, `shift+tab` | the next or previous place | +| `alt+1` … `alt+9`, `alt+.` | jump to a place, draw the map | + +On the page's buttons, and on a team with no manager in the pane: + +| Key | What it does | +|---|---| +| `↑` `↓` | walk the rail, or the pane | +| `←` `→` | along a row, and across between the rail and the pane | +| `enter`, `space` | press the button the cursor is on | +| `s` | the chosen team's card (its settings) | +| `c` | close the chosen team | +| `w` | open the conversations view on the chosen team | +| `n` | new team (inside the chosen team) | +| `o` | Organize | +| `m` | Move into…: move the chosen team, or the picked ones, inside another team | +| `space` | on a team's row, pick it for a move of several | +| `p` | the members card | +| `M` | start a manager for the chosen team | +| `r` | reopen a closed team | +| `d` | delete a closed team (it asks first) | +| `u` | Undo a close or a move, while it is offered | +| `esc` | cancel a drag or a move's question, clear the picks, then back to the message box, or home when there is none | + +Any letter not in that list goes back to the message box and types there. + +## A team's card: its settings, and where each value comes from + +`Settings` on the header, `Team settings…` in the team switcher on the tab strip, `e` on the +conversations view, or `s` here opens the team's **card**: + +``` +╭─ Team settings ────────────────────────────────────────────╮ +│ Name orbit │ +│ Colour ◉ ● ● ● ● ● │ +│ ──────────────────────────────────────────────────────── │ +│ questions go to the manager on · from Settings │ +│ team messages wake on · from Settings │ +│ daily cap $5.00 a day · from harbor │ +│ team depth 2 levels reset │ +│ sub-team share 50% · from Settings │ +│ ──────────────────────────────────────────────────────── │ +│ Close team… Done ⏎ │ +╰────────────────────────────────────────────────────────────╯ +``` + +The card holds only what the team **overrides**. A value the team takes from somewhere else +is dim and says where: `· from Settings` for the defaults under **Teams** in `/settings`, or +`· from harbor` when a team above it set it. A value the team sets itself is drawn plain with +`reset` beside it, which gives the value back to what it inherits. `enter` on a row changes +it (the two on and off rows flip; the others take a figure), and `r` resets the row the +cursor is on. A cap is dollars a day (0 for none), a depth is 1 to 10 levels, a share is 1 to +100 percent. The name is edited as you type and kept with `enter` or when the card is put +away; `←` `→` choose a colour. `esc` or `Done` puts the card away. + +## Closing a team + +`Close…`, `c`, `Close team…` on the card, or `D` on the conversations view closes a team. + +- **Nothing running:** it closes at once, and `harbor is closed Undo` stays at the top of the + pane for a few seconds. `Undo` or `u` reopens it with its tabs. +- **Something running:** a card says who is still working and offers **Wrap up first**, + **Close now** and **Cancel**. When the team has a manager, `Wrap up first` leads: the manager + is asked to have everyone finish and commit and to bring you a closing report, which arrives + as a card on this page with `Close` and `Keep going`; the team closes when you choose Close. + `Close now` stops every member's turn and closes their tabs at once. `Cancel` or `esc` + changes nothing. + +Closing a team closes the teams under it. A conversation that is also in another open team is +never stopped by the close. The conversation you are looking at keeps its tab, so a close never +moves you. A closed team spends nothing, is not on the conversations view or the strip, and +waits under `▸ Closed · N`. + +Over `--host`, against an engine that does not offer the wrap-up, the card says +`Wrap up first is not offered over this connection` and offers `Close now` and `Cancel`. + +## Closed teams: reopening and deleting + +Open `▸ Closed · N` on the rail and choose a team. The pane shows when it was opened and +closed, its closing report when it closed on one (what was done, what was left, where the files +are, what it spent), and its members, each still a door to its conversation. Two buttons: + +- **`Reopen`** (`r`) opens the team again: its members' tabs come back and its manager is + brought in front. A team whose parent is closed too offers **`Reopen harbor too`**, because a + sub-team cannot be open under a closed team. +- **`Delete…`** (`d`) asks first, then forgets the team, its Traffic and its decisions. Its + conversations stay in your history. Only a closed team can be deleted. + +## Organize closes quiet teams + +`✦ Organize` on the rail (or on the conversations view) suggests teams for your conversations, +and when some teams have had no activity for a week and nothing waiting, it also suggests +**`Close 3 quiet teams`**, ticked like every other suggestion. Nothing closes until you Apply, +and `Undo` on the Teams row for a few seconds after reopens them. Organize never closes a team +by itself. Over `--host` this suggestion is not offered yet. + +## With no teams yet + +The page says what a team is in one sentence and offers two buttons: **`✦ Organize my +conversations`**, which suggests teams from the conversations you have open, and +**`+ New team`**. `o` and `n` press them. + +## Over --host + +Over `--host` the page shows the teams of the machine the conversations run on: their +decisions, their spend and their managers. The **Teams** tab of `/settings` edits that +machine's defaults, and each value says `from Settings`. An older engine keeps the tab +read only and says `changing them is not available over this connection`. A closed team's +report is not read over the connection yet, and the page says so where the report would be. + +## Why the page looks the way it does + +- **Marks appear only when something happens**, so a glance down the rail finds the one team + that needs you. Amber means a person is needed, and nothing else on the page is amber. +- **The pane is the manager's own conversation**, not a copy of it, because talking to the + team means talking to its manager. Everything you could do in that conversation you can do + here. +- **Choosing a team is the one thing that changes which conversation is in front.** Nothing + else on the page moves you, and resuming a member opens it behind. +- **A team moves by choosing where it goes**, not by indenting it: the rail keeps teams in the + order they were made, so a move changes one team's place and nothing else's. A drag adds a + chat and never removes one, so a slip of the pointer cannot lose a conversation from a team. +- **`m` is Move into…, so starting a manager is `M`.** The move is the everyday gesture; a + manager is started once per team. +- **A team is deleted only once it is closed**, so the everyday gesture is a close you can undo, + and the one that forgets things asks first. diff --git a/internal/manual/chat/what-i-remember.md b/internal/manual/chat/what-i-remember.md index 2fd5aacf9e..5962cd21af 100644 --- a/internal/manual/chat/what-i-remember.md +++ b/internal/manual/chat/what-i-remember.md @@ -37,7 +37,7 @@ Claude Code, Codex and other skill folders still reach the conversation, carried with a message that suits them and attached by `/skill` (`skills-from-other-tools` says how). -**The memory PLACE still opens with it off.** `alt+6` and `/memory` both reach it, and +**The memory PLACE still opens with it off.** `alt+8` and `/memory` both reach it, and what they reach is the heading `memory` and its one line, with that same sentence written once into the rule above the composer — *What the memory place shows when there is nothing in it* below. It used to refuse to open at all, which made the memory key on a fresh machine a key @@ -90,7 +90,7 @@ they are gone; nothing else keeps a second copy. ## How do I see what codeaf remembers about me? -Open `/memory` — or `/memories`, or `alt+6` from anywhere (memory is not on the tab bar). **Memory is a +Open `/memory`, or `/memories`, or `alt+8` from anywhere (memory is not on the tab bar). **Memory is a place**, one of seven, taking the whole screen with the tab bar above it and a composer at the foot. diff --git a/internal/manual/chat/worker-harness.md b/internal/manual/chat/worker-harness.md index 4cf60e4752..99113585d0 100644 --- a/internal/manual/chat/worker-harness.md +++ b/internal/manual/chat/worker-harness.md @@ -232,7 +232,7 @@ to the column's width; the glyph and the `$` are never spent on it. **The line is there only while a step is in flight.** A task that has not started, one held behind named work, and one that has landed all draw their ordinary row and no live line — the store clears the step the moment its command ends. These rows are a run's **plan rows**, drawn -in the tasks place (`/history`, `ctrl+.`, `alt+2`, and the roster raised over the frame), not +in the tasks place (`/history`, `ctrl+.`, `alt+4`, and the roster raised over the frame), not on the always-on column, which draws this conversation's own tree. ## What a run task's page shows while it runs diff --git a/internal/manual/chat_test.go b/internal/manual/chat_test.go index 81abc87aac..a604a098a7 100644 --- a/internal/manual/chat_test.go +++ b/internal/manual/chat_test.go @@ -29,6 +29,75 @@ func TestTheChatManualAnswersTheQuestionsPeopleAsk(t *testing.T) { page string }{ {"what can you do", "what-i-can-do"}, + {"why does a wrapped help line stay under its key", "keys"}, + // The conversations view and its teams (conversations-and-teams.md). + {"how do I see all my conversations at once", "conversations-and-teams"}, + {"what is the tabs dock under the message box", "conversations-and-teams"}, + {"how do I group conversations into a team", "conversations-and-teams"}, + {"how do I switch teams from the tab strip", "conversations-and-teams"}, + {"does deleting a team close its conversations", "conversations-and-teams"}, + {"where are my teams saved", "conversations-and-teams"}, + // The teams page (teams-page.md). + {"how do I see all my teams and what waits on me", "teams-page"}, + {"does renaming a team update the message box", "teams-page"}, + {"how do I close a team", "teams-page"}, + {"the pane said the manager was open in another window", "teams-page"}, + {"how do I reopen a closed team", "teams-page"}, + {"where do I change one team's settings", "teams-page"}, + {"what does the ? 2 mark on a team mean", "teams-page"}, + // Nesting on the teams page (teams-page.md). + {"how do I move a team inside another team", "teams-page"}, + {"can I drag a team onto another team", "teams-page"}, + {"how do I add a chat to another team from the teams page", "teams-page"}, + {"why is a team greyed out when I move a team", "teams-page"}, + {"how do I undo moving a team", "teams-page"}, + {"is a team move written to traffic", "teams-page"}, + {"what happens in traffic when I move a conversation between teams", "conversations-and-teams"}, + {"does the manager learn when a member moves to another team", "team-manager"}, + {"what does +4 idle mean on a team", "teams-page"}, + {"how do I mention a team or another conversation with @", "conversations-and-teams"}, + {"what does clicking a team name in a chat do", "conversations-and-teams"}, + {"where does a team link in a chat open", "teams-page"}, + // The team manager (team-manager.md). + {"what can the team manager do", "team-manager"}, + {"can the manager answer a member's permission prompt", "team-manager"}, + {"how does a member post to the room", "team-manager"}, + {"does a directive wake an idle member", "team-manager"}, + // Questions, packets, caps and wrapping up (team-questions-and-caps.md). + {"does a member's question go to the manager or to me", "team-questions-and-caps"}, + {"what is a decision packet", "team-questions-and-caps"}, + {"what happens when a team reaches its daily cap", "team-questions-and-caps"}, + {"why did two windows both ask me about the team cap", "team-questions-and-caps"}, + {"how do I wrap up a team before closing it", "team-questions-and-caps"}, + {"what happens to a wrap-up when codeaf restarts", "team-questions-and-caps"}, + {"does a wrap-up keep going if I quit codeaf", "team-questions-and-caps"}, + {"what if the wrap-up report could not be sent", "team-questions-and-caps"}, + {"can a manager direct a member of another team", "team-manager"}, + {"can a manager start a sub-team", "team-manager"}, + {"what is the global manager", "team-manager"}, + {"how do two members of different teams settle a conflict", "team-manager"}, + {"who decides a conflict between two sub-teams", "team-manager"}, + {"what happens when auto-wake is off and the manager starts a member", "team-manager"}, + {"why is a member still asking after it crashed", "team-manager"}, + {"does it ask again if the handle model times out", "team-manager"}, + {"how does a member reply to a thread", "team-manager"}, + {"why is the traffic rail drawn as threads", "team-manager"}, + {"open a member's chat at the message it answered from the traffic", "team-manager"}, + // The one column (sidecol.go): the two words in a team chat, and the + // band of what waits on the person above them. + {"how do I switch between tasks and traffic in a manager chat", "team-manager"}, + {"what does Traffic 3 new mean in the column header", "team-manager"}, + {"who is a traffic row from and who is it to", "team-manager"}, + {"how old is a traffic row", "team-manager"}, + {"what does pressing a traffic row open", "team-manager"}, + {"what does chats on the tab bar do", "places"}, + {"how do I get back to my conversation from a place", "places"}, + // The places sit on the top line. The chat strip is only inside a chat + // (places.md, head.go). + {"where did the places go", "places"}, + {"what does more on the top line do", "places"}, + {"why are my chat tabs showing on the home page", "places"}, + {"why is there no tab strip on the teams page", "places"}, {"can you use my claude code skills", "skills-from-other-tools"}, {"why is my claude code plugin skill missing", "skills-from-other-tools"}, {"do codex skills work here", "skills-from-other-tools"}, @@ -1046,6 +1115,8 @@ func TestTheChatManualAnswersTheQuestionsPeopleAsk(t *testing.T) { {"why does the status line not show the cost before I type", "empty-screen"}, {"what does try what is in this folder mean", "empty-screen"}, {"where did the recent sessions list go", "empty-screen"}, + {"why does home show a session id for an untitled chat", "home"}, + {"the hint line stayed after I resized", "places"}, // A task's page with heavy tool use, asked the ways the screenshot // provoked: the wheel doing nothing, the calls that are not there, and @@ -2187,6 +2258,8 @@ func TestTheChatManualAnswersTheQuestionsPeopleAsk(t *testing.T) { {"how do I cancel this card", "keeping-an-eye"}, {"I don't understand these options", "keeping-an-eye"}, {"what does just once mean", "keeping-an-eye"}, + {"what kind of standing card is this", "keeping-an-eye"}, + {"why did it say the reminder was never set up after I said just once", "keeping-an-eye"}, {"can I change everywhere to just this project", "standing-orders"}, // The twelfth wave: answering a question from home. Both are asked by // somebody looking at a `▲` row and wondering whether they have to walk @@ -2458,6 +2531,9 @@ func TestTheChatManualAnswersTheQuestionsPeopleAsk(t *testing.T) { {"how do I work on the same conversation from two computers", "running-on-another-machine"}, {"what is the difference between another window and another machine", "running-on-another-machine"}, {"does home work over --host", "running-on-another-machine"}, + {"can I change the Teams settings on another machine", "running-on-another-machine"}, + {"where do team defaults go over a connection", "running-on-another-machine"}, + {"can I edit team defaults over --host", "commands"}, // The wave that stopped a rebuild on the far machine from trapping // somebody. These are the words a person actually uses at the moment it @@ -2494,6 +2570,7 @@ func TestTheChatManualAnswersTheQuestionsPeopleAsk(t *testing.T) { {"can I paste an image from the clipboard", "attaching-files"}, {"can I drop a file after a slash command", "attaching-files"}, {"can I attach a whole folder", "attaching-files"}, + {"how do I mention a file, a team or another chat with @", "attaching-files"}, {"how do I download a file from my dev box", "opening-files-from-that-machine"}, {"can I drag a file onto the browse page to upload it", "opening-files-from-that-machine"}, {"where do the files I fetched from the other machine go", "opening-files-from-that-machine"}, diff --git a/internal/remote/callclass.go b/internal/remote/callclass.go index 41cd9c190d..60d368648f 100644 --- a/internal/remote/callclass.go +++ b/internal/remote/callclass.go @@ -146,7 +146,11 @@ func classify(method string) callClass { MethodPlacesWorld, MethodPlacesTask, MethodPlacesLedger, MethodPlacesSearch, MethodMemorySnapshot, MethodMemoryChanged, MethodMemoryList, MethodMemoryProvenance, MethodTaskRoom, MethodTaskPending, MethodTaskEffort, - MethodListDir, MethodStatPaths, MethodFetchFile: + MethodListDir, MethodStatPaths, MethodFetchFile, + // The wall's two model asks are reads of the naming role, asked off the + // update loop and bounded by the wall; queued behind a turn they would + // wait out the wall's patience and answer nobody. + MethodTeamsName, MethodTeamsPropose: return classGetter case MethodQuestionResolve, MethodQuestionHold, MethodConsent, MethodConsentRemember, diff --git a/internal/remote/delegation.go b/internal/remote/delegation.go new file mode 100644 index 0000000000..f202048a3a --- /dev/null +++ b/internal/remote/delegation.go @@ -0,0 +1,215 @@ +package remote + +import ( + "encoding/json" + + "github.com/Agent-Field/codeaf/internal/config" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE ENGINE HALF OF THE DELEGATION DOORS, AND THE SURFACE HALF ─────────── +// +// wire_delegation.go says what the doors are. This answers them from the +// engine's own profile and asks them, in a file of its own for teams.go's +// reason. + +// delegationCall answers the delegation methods, and says whether the method +// was one of them at all. +func (s *server) delegationCall(call Frame) (json.RawMessage, bool, error) { + switch call.Method { + case MethodTeamsDefaults, MethodTeamsApplyDefault, MethodTeamsPackets, MethodTeamsRaise, MethodTeamsDecide, + MethodTeamsEscalate, MethodTeamsSpend, MethodTeamsDelete, + MethodTeamsWrapUp, MethodTeamsAcceptClosing: + default: + return nil, false, nil + } + sess := s.session + sess.mu.Lock() + dir := sess.engine.ProfileDir + sess.mu.Unlock() + answer, err := delegationAnswer(dir, call) + if err != nil { + return nil, true, err + } + payload, err := json.Marshal(answer) + return payload, true, err +} + +// delegationAnswer is one delegation method answered from dir. +func delegationAnswer(dir string, call Frame) (any, error) { + switch call.Method { + case MethodTeamsDefaults: + return teamstore.DefaultsAt(dir), nil + + case MethodTeamsApplyDefault: + args, err := arg[TeamDefaultArgs](call) + if err != nil { + return nil, err + } + // THE SAME WRITE THE LOCAL TAB MAKES. ApplyTeamDefault is the registry + // row's own Apply, so a value the panel would refuse is refused here + // in the same words, and a value it would keep is the file the far + // session reads. + if err := config.ApplyTeamDefault(dir, args.Key, args.Raw); err != nil { + return nil, err + } + return teamstore.DefaultsAt(dir), nil + + case MethodTeamsPackets: + args, err := arg[PacketsArgs](call) + if err != nil { + return nil, err + } + // The stamp is taken before the read, for teamsRead's reason. + stamp := teamstore.PacketsStamp(dir) + if args.Stamp != "" && args.Stamp == stamp { + return PacketsReading{Stamp: stamp, Same: true}, nil + } + packets, _, err := teamstore.OpenPackets(dir, args.Scope) + if err != nil { + return nil, err + } + return PacketsReading{Stamp: stamp, Packets: packets}, nil + + case MethodTeamsRaise: + args, err := arg[teamstore.Packet](call) + if err != nil { + return nil, err + } + return teamstore.Raise(dir, args) + + case MethodTeamsDecide: + args, err := arg[DecideArgs](call) + if err != nil { + return nil, err + } + return teamstore.Decide(dir, args.ID, args.By, args.Decision, args.Reason) + + case MethodTeamsEscalate: + args, err := arg[EscalateArgs](call) + if err != nil { + return nil, err + } + return teamstore.Escalate(dir, args.ID, args.By, args.To, args.Reason) + + case MethodTeamsSpend: + args, err := arg[SpendArgs](call) + if err != nil { + return nil, err + } + day := args.Day + if day == "" { + day = teamstore.Today() + } + stamp := teamstore.TeamSpendStamp(dir, args.Team, day) + if args.Stamp != "" && args.Stamp == stamp { + return SpendReading{Stamp: stamp, Same: true}, nil + } + spend, err := teamstore.TeamSpend(dir, args.Team, day) + if err != nil { + return nil, err + } + return SpendReading{Stamp: stamp, Spend: &spend}, nil + + case MethodTeamsWrapUp: + args, err := arg[WrapUpArgs](call) + if err != nil { + return nil, err + } + return struct{}{}, teamstore.AppendTraffic(dir, args.Team, teamstore.WrapUpRequest(args.Text)) + + case MethodTeamsAcceptClosing: + args, err := arg[AcceptClosingArgs](call) + if err != nil { + return nil, err + } + p, err := teamstore.PacketByID(dir, args.ID) + if err != nil { + return nil, err + } + closed, err := teamstore.AcceptClosing(dir, p) + if err != nil { + return nil, err + } + return AcceptClosingReply{Closed: closed, Stamp: teamstore.Stamp(dir)}, nil + + default: // MethodTeamsDelete + args, err := arg[DeleteTeamArgs](call) + if err != nil { + return nil, err + } + gone, err := teamstore.Delete(dir, args.Team) + if err != nil { + return nil, err + } + return DeleteTeamReply{Gone: gone, Stamp: teamstore.Stamp(dir)}, nil + } +} + +// ── THE SURFACE HALF ──────────────────────────────────────────────────────── + +// TeamsDefaults is the engine profile's `teams.` defaults. +func (c *Client) TeamsDefaults() (teamstore.Defaults, error) { + return delegationAsk[teamstore.Defaults](c, MethodTeamsDefaults, struct{}{}) +} + +// TeamsApplyDefault writes one `teams.` row on the engine and answers the +// five defaults as they stand after the write. +func (c *Client) TeamsApplyDefault(key, raw string) (teamstore.Defaults, error) { + return delegationAsk[teamstore.Defaults](c, MethodTeamsApplyDefault, TeamDefaultArgs{Key: key, Raw: raw}) +} + +// TeamsPackets is the packets waiting on scope, or Same when the packet files +// are still at stamp. +func (c *Client) TeamsPackets(scope, stamp string) (PacketsReading, error) { + return delegationAsk[PacketsReading](c, MethodTeamsPackets, PacketsArgs{Scope: scope, Stamp: stamp}) +} + +// TeamsRaise records p on the engine and answers it as written. +func (c *Client) TeamsRaise(p teamstore.Packet) (teamstore.Packet, error) { + return delegationAsk[teamstore.Packet](c, MethodTeamsRaise, p) +} + +// TeamsDecide records a decision on the engine. +func (c *Client) TeamsDecide(id, by, decision, reason string) (teamstore.Packet, error) { + return delegationAsk[teamstore.Packet](c, MethodTeamsDecide, DecideArgs{ID: id, By: by, Decision: decision, Reason: reason}) +} + +// TeamsEscalate sends a packet up on the engine. +func (c *Client) TeamsEscalate(id, by, to, reason string) (teamstore.Packet, error) { + return delegationAsk[teamstore.Packet](c, MethodTeamsEscalate, EscalateArgs{ID: id, By: by, To: to, Reason: reason}) +} + +// TeamsSpend is team's spend on day ("" the engine's today), or Same when +// nothing moved since stamp. +func (c *Client) TeamsSpend(team, day, stamp string) (SpendReading, error) { + return delegationAsk[SpendReading](c, MethodTeamsSpend, SpendArgs{Team: team, Day: day, Stamp: stamp}) +} + +// TeamsDelete forgets a closed team on the engine. +func (c *Client) TeamsDelete(team string) (DeleteTeamReply, error) { + return delegationAsk[DeleteTeamReply](c, MethodTeamsDelete, DeleteTeamArgs{Team: team}) +} + +// TeamsWrapUp asks the engine's manager of team to wrap up. +func (c *Client) TeamsWrapUp(team, text string) error { + _, err := delegationAsk[struct{}](c, MethodTeamsWrapUp, WrapUpArgs{Team: team, Text: text}) + return err +} + +// TeamsAcceptClosing closes the team a decided closing packet reports on, +// on the engine. +func (c *Client) TeamsAcceptClosing(id string) (AcceptClosingReply, error) { + return delegationAsk[AcceptClosingReply](c, MethodTeamsAcceptClosing, AcceptClosingArgs{ID: id}) +} + +// delegationAsk is one round trip decoded as T. +func delegationAsk[T any](c *Client, method string, args any) (T, error) { + var out T + payload, err := c.call(nil, method, args) + if err != nil { + return out, err + } + err = json.Unmarshal(payload, &out) + return out, err +} diff --git a/internal/remote/delegation_test.go b/internal/remote/delegation_test.go new file mode 100644 index 0000000000..4593fc6aea --- /dev/null +++ b/internal/remote/delegation_test.go @@ -0,0 +1,210 @@ +package remote + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// THE DELEGATION DOORS CROSS, AND THEY ANSWER FROM THE ENGINE'S PROFILE AND +// LEDGER. The welcome says the engine has them; the defaults are the engine +// profile's; a packet raised over the wire lands in the engine's file; a read +// at the held stamp is a few bytes; a decision and an escalation cross; the +// spend is the engine's ledger; and a delete is refused for an open team and +// takes a closed one's files. +func TestTheDelegationDoorsCrossFromTheEnginesProfile(t *testing.T) { + t.Setenv("CODEAF_HOME", t.TempDir()) + loop, dir := teamsLoop(t) + if !loop.Client.Welcome().Delegation { + t.Fatal("an engine of this build does not say it has the delegation doors") + } + if err := os.WriteFile(filepath.Join(dir, "config.json"), []byte(`{"teams.cap_usd_day": 7}`), 0o600); err != nil { + t.Fatal(err) + } + d, err := loop.Client.TeamsDefaults() + if err != nil || d.CapUSDDay != 7 || d.DepthLimit != 3 || !d.QuestionsUp { + t.Fatalf("the engine's defaults: %+v, %v", d, err) + } + + session := "0123456789abcdef" + key := filepath.Join("/srv", session, "transcript.jsonl") + if err := teamstore.Save(dir, []teamstore.Team{ + {ID: "0a0a0a0a0a0a", Name: "harbor", Manager: "hm", + Members: []teamstore.Member{{Key: "hm", Handle: "boss"}, {Key: key, Handle: "web"}}}, + }); err != nil { + t.Fatal(err) + } + p, err := loop.Client.TeamsRaise(teamstore.Packet{Team: "0a0a0a0a0a0a", Kind: teamstore.PacketJudgement, + RaisedBy: "web", Question: "ship today?", + Options: []teamstore.Option{{Label: "yes", Consequence: "it ships"}, {Label: "no", Consequence: "it waits"}}}) + if err != nil || p.ID == "" || p.State != teamstore.PacketOpen { + t.Fatalf("raise: %+v, %v", p, err) + } + if on, _ := teamstore.PacketByID(dir, p.ID); on.Question != "ship today?" { + t.Fatal("the packet is not in the engine's file") + } + first, err := loop.Client.TeamsPackets("0a0a0a0a0a0a", "") + if err != nil || len(first.Packets) != 1 || first.Same { + t.Fatalf("packets: %+v, %v", first, err) + } + same, err := loop.Client.TeamsPackets("0a0a0a0a0a0a", first.Stamp) + if err != nil || !same.Same || same.Packets != nil { + t.Fatalf("a read at the held stamp: %+v, %v", same, err) + } + if raw, _ := json.Marshal(same); len(raw) > 64 { + t.Fatalf("an unchanged packets answer is %d bytes: %s", len(raw), raw) + } + up, err := loop.Client.TeamsEscalate(p.ID, "boss", teamstore.Person, "not mine to call") + if err != nil || up.Team != teamstore.Person { + t.Fatalf("escalate: %+v, %v", up, err) + } + if _, err := loop.Client.TeamsDecide(p.ID, "boss", "1", ""); err == nil || + !strings.Contains(err.Error(), "only the manager") { + t.Fatalf("the manager it left decided over the wire: %v", err) + } + done, err := loop.Client.TeamsDecide(p.ID, teamstore.Person, "2", "tomorrow") + if err != nil || done.State != teamstore.PacketDecided || done.DecidedBy != teamstore.Person { + t.Fatalf("decide: %+v, %v", done, err) + } + + day := teamstore.Today() + ledger := teamstore.UsageLedgerPath() + if err := os.MkdirAll(filepath.Dir(ledger), 0o700); err != nil { + t.Fatal(err) + } + line := `{"at":"` + time.Now().Format(time.RFC3339Nano) + `","day":"` + day + `","usd":1.2,"calls":1,"session":"` + session + `"}` + "\n" + if err := os.WriteFile(ledger, []byte(line), 0o600); err != nil { + t.Fatal(err) + } + spent, err := loop.Client.TeamsSpend("0a0a0a0a0a0a", "", "") + if err != nil || spent.Spend == nil || spent.Spend.USD != 1.2 || spent.Spend.Day != day { + t.Fatalf("spend: %+v, %v", spent, err) + } + quiet, err := loop.Client.TeamsSpend("0a0a0a0a0a0a", "", spent.Stamp) + if err != nil || !quiet.Same || quiet.Spend != nil { + t.Fatalf("a quiet spend: %+v, %v", quiet, err) + } + + if _, err := loop.Client.TeamsDelete("0a0a0a0a0a0a"); err == nil { + t.Fatal("an open team was deleted over the wire") + } + if err := teamstore.Update(dir, func(f *teamstore.File) error { + return f.Close("0a0a0a0a0a0a", time.Time{}, p.ID) + }); err != nil { + t.Fatal(err) + } + gone, err := loop.Client.TeamsDelete("0a0a0a0a0a0a") + if err != nil || len(gone.Gone) != 1 { + t.Fatalf("delete: %+v, %v", gone, err) + } + if _, err := os.Stat(teamstore.TeamDir(dir, "0a0a0a0a0a0a")); !os.IsNotExist(err) { + t.Fatalf("the team's files are still there: %v", err) + } +} + +// A TEAMS SETTINGS WRITE LANDS IN THE ENGINE'S PROFILE, and a key that is not +// one of the five defaults is refused. The value a team inherits still says +// it came from Settings. +func TestATeamDefaultWrittenOverTheWireLandsInTheEngineProfile(t *testing.T) { + t.Setenv("CODEAF_HOME", t.TempDir()) + loop, dir := teamsLoop(t) + if !loop.Client.Welcome().TeamSettings { + t.Fatal("an engine of this build does not say it can change team defaults") + } + d, err := loop.Client.TeamsApplyDefault("teams.questions_up", "off") + if err != nil || d.QuestionsUp { + t.Fatalf("apply: %+v, %v", d, err) + } + if teamstore.DefaultsAt(dir).QuestionsUp { + t.Fatal("the engine profile still has questions going up") + } + if words := (&teamstore.File{}).Effective("missing", d).QuestionsUpFrom.Words(); words != "from Settings" { + t.Fatalf("provenance %q", words) + } + if _, err := loop.Client.TeamsApplyDefault("daily_budget", "1"); err == nil { + t.Fatal("a row that is not a team default was written") + } +} + +// THE WRAP-UP'S DOORS CROSS: the request lands in the engine's Traffic as +// exactly the marker the manager's session reads, and accepting a decided +// closing report closes the team on the engine, once. +func TestTheWrapUpDoorsCrossToTheEngine(t *testing.T) { + t.Setenv("CODEAF_HOME", t.TempDir()) + loop, dir := teamsLoop(t) + if !loop.Client.Welcome().WrapUp { + t.Fatal("an engine of this build does not say it has the wrap-up doors") + } + if err := teamstore.Save(dir, []teamstore.Team{ + {ID: "0a0a0a0a0a0a", Name: "harbor", Manager: "hm", + Members: []teamstore.Member{{Key: "hm", Handle: "boss"}, {Key: "w", Handle: "web"}}}, + }); err != nil { + t.Fatal(err) + } + if err := loop.Client.TeamsWrapUp("0a0a0a0a0a0a", ""); err != nil { + t.Fatal(err) + } + log, err := teamstore.ReadTraffic(dir, "0a0a0a0a0a0a", "", 0) + if err != nil || len(log) != 1 || !teamstore.IsWrapUp(log[0]) { + t.Fatalf("the engine's traffic: %+v %v", log, err) + } + p, err := teamstore.Raise(dir, teamstore.Packet{Team: teamstore.Person, Origin: "0a0a0a0a0a0a", Kind: teamstore.PacketClosing, + RaisedBy: teamstore.FromManager, Question: "close harbor?", Report: &teamstore.ClosingReport{Done: "all of it"}, + Options: []teamstore.Option{{ID: teamstore.OptionClose, Label: "Close", Consequence: "it closes"}, + {ID: teamstore.OptionKeepGoing, Label: "Keep going", Consequence: "it stays"}}}) + if err != nil { + t.Fatal(err) + } + if _, err := loop.Client.TeamsDecide(p.ID, teamstore.Person, teamstore.OptionClose, ""); err != nil { + t.Fatal(err) + } + reply, err := loop.Client.TeamsAcceptClosing(p.ID) + if err != nil || !reply.Closed { + t.Fatalf("accept: %+v %v", reply, err) + } + if again, err := loop.Client.TeamsAcceptClosing(p.ID); err != nil || again.Closed { + t.Fatalf("a second accept: %+v %v", again, err) + } + f, _ := teamstore.Load(dir) + if team, _ := f.Team("0a0a0a0a0a0a"); !team.Closed() { + t.Fatal("the engine's team did not close") + } +} + +// A CONFLICT RAISED AND RULED OVER THE WIRE REACHES EVERY PARTY ON THE ENGINE. +// The window's Teams.Raise and Teams.Decide are the engine's own store calls, +// so the ruling is written as a directive to each party in its own team's log +// on the engine, and a manager who is a party is refused there too. +func TestAConflictRuledOverTheWireReachesEveryPartyOnTheEngine(t *testing.T) { + t.Setenv("CODEAF_HOME", t.TempDir()) + loop, dir := teamsLoop(t) + if err := teamstore.Save(dir, []teamstore.Team{ + {ID: "0a0a0a0a0a0a", Name: "harbor", Manager: "hm", Members: []teamstore.Member{{Key: "hm", Handle: "boss"}}}, + {ID: "0b0b0b0b0b0b", Name: "front", Parent: "0a0a0a0a0a0a", Members: []teamstore.Member{{Key: "w", Handle: "web"}}}, + {ID: "0c0c0c0c0c0c", Name: "back", Parent: "0a0a0a0a0a0a", Members: []teamstore.Member{{Key: "a", Handle: "api"}}}, + }); err != nil { + t.Fatal(err) + } + p, err := loop.Client.TeamsRaise(teamstore.Packet{Team: "0a0a0a0a0a0a", Origin: "0b0b0b0b0b0b", Kind: teamstore.PacketConflict, + RaisedBy: "web", Question: "JSON or form data?", + Parties: []teamstore.Party{{Key: "w", Handle: "web", Team: "0b0b0b0b0b0b"}, {Key: "a", Handle: "api", Team: "0c0c0c0c0c0c"}}, + Options: []teamstore.Option{{Label: "JSON", Consequence: "the handler changes"}, {Label: "form data", Consequence: "the form changes"}}}) + if err != nil { + t.Fatalf("raise: %v", err) + } + if _, err := loop.Client.TeamsDecide(p.ID, teamstore.Person, "1", "matches the rest"); err != nil { + t.Fatalf("decide: %v", err) + } + for team, handle := range map[string]string{"0b0b0b0b0b0b": "web", "0c0c0c0c0c0c": "api"} { + log, _ := teamstore.ReadTraffic(dir, team, "", 0) + ruling := log[len(log)-1] + if !teamstore.IsRuling(ruling) || ruling.To != handle || ruling.From != teamstore.FromYou || !strings.Contains(ruling.Text, "JSON: the handler changes") { + t.Fatalf("%s on the engine: %+v", team, log) + } + } +} diff --git a/internal/remote/server.go b/internal/remote/server.go index fb5ac16abd..02b7b040b3 100644 --- a/internal/remote/server.go +++ b/internal/remote/server.go @@ -1184,6 +1184,18 @@ func (sess *Session) welcomeLocked(s *server) Welcome { // open — for [Welcome.Folders]'s stated reason: the surface's own type // assertion cannot see across the wire. Folders: keepsFolders(sess.agent), + // Every engine of this build answers the teams doors from its own + // profile (teams.go), so the flag is about the build, not the agent. + Teams: true, + // And the delegation doors beside them (delegation.go), for the same + // reason: the build answers them, whatever agent is open. + Delegation: true, + // And the settings tab's write of those defaults, for the same reason. + TeamSettings: true, + // And the wrap-up's two doors, for the same reason. + WrapUp: true, + // The two model asks are the agent's, so they are asked of it. + TeamAsk: teamAskKnown(sess.agent), // This revision checks it in the handler, for every engine behind it // ([Session.agentOf]), so the answer is about the wire and not the agent. SteerOwner: true, @@ -2979,6 +2991,16 @@ func (s *server) invoke(call Frame) (out json.RawMessage, err error) { if payload, handled, err := s.placesCall(call); handled { return payload, err } + // And the teams doors, additive in the same way (wire_teams.go). + if payload, handled, err := s.teamsCall(call); handled { + return payload, err + } + if payload, handled, err := s.delegationCall(call); handled { + return payload, err + } + if payload, handled, err := teamAskCall(agent, call); handled { + return payload, err + } return nil, fmt.Errorf("engine: no such method %q", call.Method) } diff --git a/internal/remote/teamask.go b/internal/remote/teamask.go new file mode 100644 index 0000000000..cbb6ee60ba --- /dev/null +++ b/internal/remote/teamask.go @@ -0,0 +1,145 @@ +package remote + +import ( + "context" + "encoding/json" + "errors" + "time" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── THE WALL'S TWO MODEL ASKS, BOTH HALVES ────────────────────────────────── +// +// wire_teams.go says what [MethodTeamsName] and [MethodTeamsPropose] are and +// why they carry a budget. This is the engine answering them from the agent it +// has open, and the surface asking them, in a file of their own for teams.go's +// reason. + +// teamAskDoor is the engine agent's two asks, as internal/tui3 asserts them +// (its teamNamer and teamProposer). The whole pair is advertised or neither: +// an engine that could name a team and not organize one would still have to +// say which in a flag of its own, and no engine is built that way. +type teamAskDoor interface { + NameTeam(ctx context.Context, titles []string) (string, error) + ProposeTeams(ctx context.Context, in session.TeamProposalInput) (session.TeamProposal, error) +} + +// teamAskKnown is [Welcome.TeamAsk]: whether the agent this engine has open +// answers both asks. +func teamAskKnown(agent any) bool { _, ok := agent.(teamAskDoor); return ok } + +// teamAskOffWord is an engine that does not answer the asks. The wall never +// shows it; it is the error the wall's ask fails with, which it reads as no +// suggestion. +const teamAskOffWord = "this engine cannot suggest team names or teams" + +// teamAskWithin is the engine's bound on one ask: the wall's budget, or none +// when the wall sent none. +func teamAskWithin(budget time.Duration) (context.Context, context.CancelFunc) { + if budget > 0 { + return context.WithTimeout(context.Background(), budget) + } + return context.WithCancel(context.Background()) +} + +// teamAskCall answers the two asks from agent, and says whether the method was +// one of them at all. A false hands the call on to the refusal an engine from +// before these doors answers. +func teamAskCall(agent WrappedAgent, call Frame) (json.RawMessage, bool, error) { + switch call.Method { + case MethodTeamsName, MethodTeamsPropose: + default: + return nil, false, nil + } + door, ok := agent.(teamAskDoor) + if !ok { + return nil, true, errors.New(teamAskOffWord) + } + if call.Method == MethodTeamsName { + args, err := arg[TeamNameArgs](call) + if err != nil { + return nil, true, err + } + ctx, cancel := teamAskWithin(args.Budget) + defer cancel() + name, err := door.NameTeam(ctx, args.Titles) + if err != nil { + return nil, true, err + } + payload, err := json.Marshal(name) + return payload, true, err + } + args, err := arg[TeamProposeArgs](call) + if err != nil { + return nil, true, err + } + ctx, cancel := teamAskWithin(args.Budget) + defer cancel() + proposal, err := door.ProposeTeams(ctx, args.In) + if err != nil { + return nil, true, err + } + payload, err := json.Marshal(proposal) + return payload, true, err +} + +// teamAskBudget is what is left of ctx's deadline, for the engine to bound the +// model call by, and false when nothing is left to spend. +func teamAskBudget(ctx context.Context) (time.Duration, bool) { + deadline, ok := ctx.Deadline() + if !ok { + return 0, true + } + left := time.Until(deadline) + return left, left > 0 +} + +// NameTeam asks the engine's naming role for a short name for a group of +// conversations, given their titles: the wall's teamNamer door, over the wire. +// An engine without the ask is refused here, before anything is written. +// +// THE WALL'S DEADLINE BOUNDS THE CALL as well as [callDeadline] does: the wall +// waits teamNameWait and no longer, so the call gives up with it and the +// engine is told the same span, rather than answering a card that has already +// kept its word. +func (a *Agent) NameTeam(ctx context.Context, titles []string) (string, error) { + if !a.c.Welcome().TeamAsk { + return "", errors.New(teamAskOffWord) + } + budget, ok := teamAskBudget(ctx) + if !ok { + return "", context.DeadlineExceeded + } + payload, err := a.c.call(ctx, MethodTeamsName, TeamNameArgs{Titles: titles, Budget: budget}) + if err != nil { + return "", err + } + var name string + if err := json.Unmarshal(payload, &name); err != nil { + return "", err + } + return name, nil +} + +// ProposeTeams asks the engine's naming role which teams the conversations in +// in could form: the wall's teamProposer door, over the wire, refused here for +// an engine without it as [Agent.NameTeam] is. +func (a *Agent) ProposeTeams(ctx context.Context, in session.TeamProposalInput) (session.TeamProposal, error) { + if !a.c.Welcome().TeamAsk { + return session.TeamProposal{}, errors.New(teamAskOffWord) + } + budget, ok := teamAskBudget(ctx) + if !ok { + return session.TeamProposal{}, context.DeadlineExceeded + } + payload, err := a.c.call(ctx, MethodTeamsPropose, TeamProposeArgs{In: in, Budget: budget}) + if err != nil { + return session.TeamProposal{}, err + } + var out session.TeamProposal + if err := json.Unmarshal(payload, &out); err != nil { + return session.TeamProposal{}, err + } + return out, nil +} diff --git a/internal/remote/teamask_test.go b/internal/remote/teamask_test.go new file mode 100644 index 0000000000..c3520d5b46 --- /dev/null +++ b/internal/remote/teamask_test.go @@ -0,0 +1,140 @@ +package remote + +import ( + "context" + "strings" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// askAgent is an engine agent that answers the wall's two asks and remembers +// what it was asked and how long it was given. +type askAgent struct { + *fakeAgent + titles []string + in session.TeamProposalInput + deadline bool + left time.Duration +} + +func (a *askAgent) NameTeam(ctx context.Context, titles []string) (string, error) { + a.titles = titles + a.note(ctx) + return "harbor", nil +} + +func (a *askAgent) ProposeTeams(ctx context.Context, in session.TeamProposalInput) (session.TeamProposal, error) { + a.in = in + a.note(ctx) + return session.TeamProposal{ + New: []session.ProposedTeam{{Name: "parser", Members: []string{"/srv/a.jsonl", "/srv/b.jsonl"}, Reason: "one lexer"}}, + Additions: []session.ProposedAddition{{TeamID: "0a0a0a0a0a0a", Members: []string{"/srv/c.jsonl"}}}, + Model: "cheap", + PromptChars: 412, + }, nil +} + +func (a *askAgent) note(ctx context.Context) { + deadline, ok := ctx.Deadline() + a.deadline = ok + if ok { + a.left = time.Until(deadline) + } +} + +func askLoop(t *testing.T, agent WrappedAgent) *Loop { + t.Helper() + loop, err := Loopback(Hello{Version: Version}, Options{Boot: func(Hello) (*Engine, error) { + return &Engine{Agent: agent, ProfileDir: t.TempDir()}, nil + }}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = loop.Close() }) + return loop +} + +// THE WALL'S TWO ASKS CROSS, AND THE ENGINE SPENDS NO LONGER THAN THE WALL +// WAITS. The welcome says the engine answers them; a name asked for over the +// wire is the engine agent's name for the titles sent; a proposal comes back +// whole, the model that answered and the size of the ask included, since the +// wall prices the ask off them; and the engine's own call is bounded by a span +// no longer than the one the wall gave. +func TestTheWallsTeamAsksCrossTheWire(t *testing.T) { + far := &askAgent{fakeAgent: &fakeAgent{model: "m"}} + loop := askLoop(t, far) + agent := loop.Client.Agent() + if !loop.Client.Welcome().TeamAsk { + t.Fatal("an engine whose agent answers the asks does not say so") + } + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + name, err := agent.NameTeam(ctx, []string{"the lexer", "the parser"}) + if err != nil || name != "harbor" { + t.Fatalf("the name: %q, %v", name, err) + } + if strings.Join(far.titles, "|") != "the lexer|the parser" { + t.Fatalf("the engine was asked about %q", far.titles) + } + if !far.deadline || far.left <= 0 || far.left > 5*time.Second { + t.Fatalf("the engine's name ask was bounded by %v (deadline %v), not the wall's five seconds", far.left, far.deadline) + } + + in := session.TeamProposalInput{ + Conversations: []session.TeamProposalConversation{ + {Key: "/srv/a.jsonl", Title: "the lexer", Folder: "harbor"}, + {Key: "/srv/b.jsonl", Title: "the parser", Folder: "harbor"}, + {Key: "/srv/c.jsonl", Title: "the docs", Folder: "site"}, + }, + Teams: []session.TeamProposalTeam{{ID: "0a0a0a0a0a0a", Name: "docs", Members: []string{"/srv/d.jsonl"}}}, + } + got, err := agent.ProposeTeams(ctx, in) + if err != nil { + t.Fatal(err) + } + if len(far.in.Conversations) != 3 || far.in.Conversations[2].Folder != "site" || len(far.in.Teams) != 1 || far.in.Teams[0].Members[0] != "/srv/d.jsonl" { + t.Fatalf("the engine was asked about %+v", far.in) + } + if len(got.New) != 1 || got.New[0].Name != "parser" || len(got.New[0].Members) != 2 || got.New[0].Reason != "one lexer" || + len(got.Additions) != 1 || got.Additions[0].TeamID != "0a0a0a0a0a0a" || got.Model != "cheap" || got.PromptChars != 412 { + t.Fatalf("the proposal came back as %+v", got) + } + if !far.deadline || far.left <= 0 || far.left > 5*time.Second { + t.Fatalf("the engine's proposal ask was bounded by %v (deadline %v)", far.left, far.deadline) + } +} + +// AN OLDER ENGINE IS NOT ASKED, AND THE WALL'S ASK FAILS AS ANY FAILED ASK +// DOES. An engine whose agent has no asks sends no flag; both doors are refused +// at this end with nothing written onto the wire, which the wall turns into the +// word it holds and Organize's folder pass alone. And an engine asked anyway, +// by a surface that did not read the flag, refuses rather than answering +// something that is not a name. +func TestAnOlderEngineIsNotAskedForATeamName(t *testing.T) { + loop := askLoop(t, &fakeAgent{model: "m"}) + if loop.Client.Welcome().TeamAsk { + t.Fatal("an engine whose agent cannot ask said it could") + } + agent := loop.Client.Agent() + before := loop.Client.made.Load() + if name, err := agent.NameTeam(context.Background(), []string{"the lexer", "the parser"}); err == nil || name != "" { + t.Fatalf("an older engine named a team: %q, %v", name, err) + } + if got, err := agent.ProposeTeams(context.Background(), session.TeamProposalInput{}); err == nil || len(got.New) != 0 { + t.Fatalf("an older engine proposed teams: %+v, %v", got, err) + } + if after := loop.Client.made.Load(); after != before { + t.Fatalf("%d calls went onto the wire for asks the welcome said were not there", after-before) + } + if _, err := loop.Client.call(nil, MethodTeamsName, TeamNameArgs{Titles: []string{"the lexer"}}); err == nil || + !strings.Contains(err.Error(), teamAskOffWord) { + t.Fatalf("an engine without the ask answered it: %v", err) + } +} + +// The actual engine, rather than only a fixture, must answer both asks, or the +// flag would be false on every real engine and the wall would never ask. +var _ teamAskDoor = (*session.Agent)(nil) diff --git a/internal/remote/teams.go b/internal/remote/teams.go new file mode 100644 index 0000000000..5aa15f4b75 --- /dev/null +++ b/internal/remote/teams.go @@ -0,0 +1,156 @@ +package remote + +import ( + "encoding/json" + "errors" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE ENGINE HALF OF THE TEAMS DOORS, AND THE SURFACE HALF ──────────────── +// +// wire_teams.go says what the three doors are and why they are shaped for a +// clock. This is what answers them, from the engine's own profile, and what +// asks them. They are in a file of their own for places.go's reason: server.go +// and client.go are where every lane meets. + +// teamsPage is the most one Traffic answer carries, whatever was asked: a +// window pages forward from its cursor, so a longer backlog is the next call's. +const teamsPage = 500 + +// teamsWatch is the engine's stat-before-read memory of the Traffic logs it +// has been asked about, shared by every connection to this process: two windows +// on one team ask about the same log, and one stat answers both. +var teamsWatch teamstore.Watch + +// teamsCall answers the three teams methods, and says whether the method was +// one of them at all. A false hands the call on to the refusal an engine from +// before these doors answers. +func (s *server) teamsCall(call Frame) (json.RawMessage, bool, error) { + switch call.Method { + case MethodTeamsRead, MethodTeamsUpdate, MethodTeamsTraffic: + default: + return nil, false, nil + } + sess := s.session + sess.mu.Lock() + dir := sess.engine.ProfileDir + sess.mu.Unlock() + + switch call.Method { + case MethodTeamsRead: + args, err := arg[TeamsReadArgs](call) + if err != nil { + return nil, true, err + } + reading, err := teamsRead(dir, args) + if err != nil { + return nil, true, err + } + payload, err := json.Marshal(reading) + return payload, true, err + + case MethodTeamsUpdate: + args, err := arg[TeamsUpdateArgs](call) + if err != nil { + return nil, true, err + } + reading, err := teamsUpdate(dir, args) + if err != nil { + return nil, true, err + } + payload, err := json.Marshal(reading) + return payload, true, err + + default: + args, err := arg[TeamsTrafficArgs](call) + if err != nil { + return nil, true, err + } + limit := args.Limit + if limit <= 0 || limit > teamsPage { + limit = teamsPage + } + entries, stamp, err := teamsWatch.Traffic(dir, args.Team, args.After, limit) + if err != nil { + return nil, true, err + } + payload, err := json.Marshal(TeamsTraffic{Entries: entries, Stamp: stamp}) + return payload, true, err + } +} + +// teamsRead is [MethodTeamsRead]: a stat, and a read only when the stamp is +// not the one the window holds. +// +// THE STAMP ANSWERED IS THE ONE TAKEN BEFORE THE READ. A write that lands +// between the stat and the read is then in the list with an older stamp, and +// the window's next question reads the file once more; the other order would +// hand back an older list with a newer stamp, and the window would be told +// "same" about a change it never saw. A colour repair the load writes back +// moves the stamp the same way, and costs the same one extra read. +func teamsRead(dir string, args TeamsReadArgs) (TeamsReading, error) { + stamp := teamstore.Stamp(dir) + if args.Stamp != "" && args.Stamp == stamp { + return TeamsReading{Stamp: stamp, Same: true}, nil + } + f, err := teamstore.LoadHued(dir, args.Reserved) + if err != nil { + return TeamsReading{}, err + } + return TeamsReading{Stamp: stamp, Teams: f.Teams}, nil +} + +// teamsUpdate is [MethodTeamsUpdate]: the list written whole, under the store's +// lock, only while the file is at the window's base. +func teamsUpdate(dir string, args TeamsUpdateArgs) (TeamsReading, error) { + f, stamp, err := teamstore.ChangeIf(dir, args.Base, func(f *teamstore.File) error { + f.Teams = args.Teams + return nil + }) + if errors.Is(err, teamstore.ErrStale) { + return TeamsReading{Stamp: teamstore.Stamp(dir), Stale: true}, nil + } + if err != nil { + return TeamsReading{}, err + } + return TeamsReading{Stamp: stamp, Teams: f.Teams}, nil +} + +// TeamsRead asks for the engine machine's teams file, telling it the stamp this +// window holds ("" for none); a reading with Same set carries no teams. +func (c *Client) TeamsRead(stamp string, reserved []float64) (TeamsReading, error) { + payload, err := c.call(nil, MethodTeamsRead, TeamsReadArgs{Stamp: stamp, Reserved: reserved}) + if err != nil { + return TeamsReading{}, err + } + var out TeamsReading + err = json.Unmarshal(payload, &out) + return out, err +} + +// TeamsUpdate writes teams as the engine machine's whole teams file while it is +// still at stamp base. A reading with Stale set wrote nothing. +func (c *Client) TeamsUpdate(base string, teams []teamstore.Team) (TeamsReading, error) { + if teams == nil { + teams = []teamstore.Team{} + } + payload, err := c.call(nil, MethodTeamsUpdate, TeamsUpdateArgs{Base: base, Teams: teams}) + if err != nil { + return TeamsReading{}, err + } + var out TeamsReading + err = json.Unmarshal(payload, &out) + return out, err +} + +// TeamsTraffic reads one team's log on the engine machine after a cursor. +func (c *Client) TeamsTraffic(team, after string, limit int) (TeamsTraffic, error) { + payload, err := c.call(nil, MethodTeamsTraffic, TeamsTrafficArgs{Team: team, After: after, Limit: limit}) + if err != nil { + return TeamsTraffic{}, err + } + var out TeamsTraffic + err = json.Unmarshal(payload, &out) + return out, err +} diff --git a/internal/remote/teams_test.go b/internal/remote/teams_test.go new file mode 100644 index 0000000000..8fc0d4666d --- /dev/null +++ b/internal/remote/teams_test.go @@ -0,0 +1,101 @@ +package remote + +import ( + "encoding/json" + "testing" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// teamsLoop is an in-process engine whose profile is the test's own. +func teamsLoop(t *testing.T) (*Loop, string) { + t.Helper() + dir := t.TempDir() + loop, err := Loopback(Hello{Version: Version}, Options{Boot: func(Hello) (*Engine, error) { + return &Engine{Agent: &fakeAgent{model: "m"}, ProfileDir: dir}, nil + }}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = loop.Close() }) + return loop, dir +} + +// THE TEAMS DOORS CROSS, AND THEY ANSWER FROM THE ENGINE'S PROFILE. The welcome +// says the engine has them; a write at the right base lands in the engine's +// teams.json; a read at the stamp the window holds answers "same" in a frame of +// a few bytes; a line the far session appends is read after the cursor, and a +// quiet log after it answers no entries. +func TestTheTeamsDoorsCrossFromTheEnginesProfile(t *testing.T) { + loop, dir := teamsLoop(t) + if !loop.Client.Welcome().Teams { + t.Fatal("an engine of this build does not say it has the teams doors") + } + first, err := loop.Client.TeamsRead("", nil) + if err != nil || first.Same || len(first.Teams) != 0 || first.Stamp != teamstore.MissingStamp { + t.Fatalf("the first read of no file: %+v, %v", first, err) + } + wrote, err := loop.Client.TeamsUpdate(first.Stamp, []teamstore.Team{{ID: "0a0a0a0a0a0a", Name: "harbor", + Members: []teamstore.Member{{Key: "/srv/a.jsonl", Word: "the parser"}}}}) + if err != nil || wrote.Stale || len(wrote.Teams) != 1 || wrote.Teams[0].Members[0].Handle == "" { + t.Fatalf("the write: %+v, %v", wrote, err) + } + on, err := teamstore.Load(dir) + if err != nil || len(on.Teams) != 1 || on.Teams[0].Name != "harbor" { + t.Fatalf("the engine's file holds %+v, %v", on, err) + } + same, err := loop.Client.TeamsRead(wrote.Stamp, nil) + if err != nil || !same.Same || same.Teams != nil { + t.Fatalf("a read at the held stamp: %+v, %v", same, err) + } + if raw, _ := json.Marshal(same); len(raw) > 64 { + t.Fatalf("an unchanged answer is %d bytes: %s", len(raw), raw) + } + + if err := teamstore.AppendTraffic(dir, "0a0a0a0a0a0a", teamstore.Entry{Kind: teamstore.KindNote, + From: teamstore.FromManager, To: "parser", Text: "take the lexer"}); err != nil { + t.Fatal(err) + } + got, err := loop.Client.TeamsTraffic("0a0a0a0a0a0a", "", 50) + if err != nil || len(got.Entries) != 1 || got.Entries[0].Text != "take the lexer" { + t.Fatalf("the tail: %+v, %v", got, err) + } + quiet, err := loop.Client.TeamsTraffic("0a0a0a0a0a0a", got.Entries[0].ID, 50) + if err != nil || len(quiet.Entries) != 0 { + t.Fatalf("a quiet log after the cursor: %+v, %v", quiet, err) + } + if raw, _ := json.Marshal(quiet); len(raw) > 64 { + t.Fatalf("a quiet Traffic answer is %d bytes: %s", len(raw), raw) + } + if _, err := loop.Client.TeamsTraffic("../escape", "", 1); err == nil { + t.Fatal("a team id that is a path was read") + } +} + +// A WRITE ON A FILE THAT MOVED IS REFUSED, NOT MERGED BY ACCIDENT. The far +// session sets a manager after the window read the file; the window's write at +// the old base answers Stale, writes nothing, and the manager is still there. +func TestATeamsWriteAtAnOldBaseIsStale(t *testing.T) { + loop, dir := teamsLoop(t) + if err := teamstore.Save(dir, []teamstore.Team{{ID: "0a0a0a0a0a0a", Name: "harbor", + Members: []teamstore.Member{{Key: "k1", Word: "one"}}}}); err != nil { + t.Fatal(err) + } + read, err := loop.Client.TeamsRead("", nil) + if err != nil { + t.Fatal(err) + } + if err := teamstore.Update(dir, func(f *teamstore.File) error { return f.SetManager("0a0a0a0a0a0a", "k1") }); err != nil { + t.Fatal(err) + } + mine := read.Teams + mine[0].Name = "renamed" + stale, err := loop.Client.TeamsUpdate(read.Stamp, mine) + if err != nil || !stale.Stale || stale.Stamp == read.Stamp || stale.Teams != nil { + t.Fatalf("a write at an old base: %+v, %v", stale, err) + } + on, _ := teamstore.Load(dir) + if on.Teams[0].Name != "harbor" || on.Teams[0].Manager != "k1" { + t.Fatalf("the refused write touched the file: %+v", on.Teams[0]) + } +} diff --git a/internal/remote/wire.go b/internal/remote/wire.go index 88e39f3ff4..757cace055 100644 --- a/internal/remote/wire.go +++ b/internal/remote/wire.go @@ -1155,6 +1155,58 @@ type Welcome struct { // would open a picker whose every row ends in an error. Folders bool `json:"folders,omitempty"` + // Teams says this engine ANSWERS THE TEAMS DOORS ([MethodTeamsRead], + // [MethodTeamsUpdate], [MethodTeamsTraffic]) from its own profile, which + // is where its team tools keep the teams and their Traffic. + // + // IT IS CARRIED FOR [Welcome.Folders]' REASON: the window decides at the + // door whether it has teams over this connection, before anything is + // drawn. ABSENCE IS false, and false turns teams off over the connection + // with the sentence the window has always said; it never sends the window + // back to the laptop's own teams file, which the far session cannot see. + Teams bool `json:"teams,omitempty"` + + // Delegation says this engine ANSWERS THE DELEGATION DOORS + // ([MethodTeamsDefaults], [MethodTeamsPackets], [MethodTeamsRaise], + // [MethodTeamsDecide], [MethodTeamsEscalate], [MethodTeamsSpend], + // [MethodTeamsDelete]) from its own profile, beside the teams doors. + // + // IT IS CARRIED FOR [Welcome.Teams]' REASON, and it is a second flag + // because an engine can have the first without it: one built between the + // two answers the teams file and its Traffic and not the packets, the + // spend or a delete. ABSENCE IS false, and false leaves those seam doors + // nil, which the window reads as "not over this connection" and says so + // rather than reading this laptop's files. + Delegation bool `json:"delegation,omitempty"` + + // TeamSettings says this engine ANSWERS [MethodTeamsApplyDefault]: the + // settings tab can change the five `teams.` defaults on this machine. + // + // IT IS A FLAG OF ITS OWN beside [Welcome.Delegation] for that flag's + // reason. An engine can read the defaults and still have no door that + // writes them. ABSENCE IS false, and false leaves the Teams tab read-only + // over the connection, said as such, rather than writing this laptop's file. + TeamSettings bool `json:"team_settings,omitempty"` + + // WrapUp says this engine ANSWERS THE WRAP-UP'S TWO DOORS + // ([MethodTeamsWrapUp], [MethodTeamsAcceptClosing]). A third flag for + // [Welcome.Delegation]'s reason: an engine built between the two has the + // packets and not these. ABSENCE IS false, and false leaves the window + // with `Close now` only over that connection, said as such. + WrapUp bool `json:"wrap_up,omitempty"` + + // TeamAsk says this engine ANSWERS THE WALL'S TWO MODEL ASKS + // ([MethodTeamsName], [MethodTeamsPropose]): its agent names a group of + // conversations and proposes teams on its own naming role. + // + // IT IS CARRIED FOR [Welcome.Folders]' REASON: a *remote.Agent always has + // NameTeam and ProposeTeams on it, so the wall's type assertion answers yes + // for every connection and says nothing about the far machine. ABSENCE IS + // false, and false is refused at this end before anything is written, which + // the wall reads as it reads any failed ask: the word it already holds, and + // Organize's folder pass alone. + TeamAsk bool `json:"teamAsk,omitempty"` + // News says this engine SENDS THE STATUS LINE'S NEWS — the "phase" and // "lane" frames the live rate and the `via <machine>` rider are drawn from // (news.go) — for the conversation this surface arrived in. diff --git a/internal/remote/wire_delegation.go b/internal/remote/wire_delegation.go new file mode 100644 index 0000000000..8c5fe6a3ae --- /dev/null +++ b/internal/remote/wire_delegation.go @@ -0,0 +1,150 @@ +package remote + +import ( + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── DELEGATION ACROSS THE WIRE ────────────────────────────────────────────── +// +// The delegation store (internal/teams' decision.go, spend.go, lifecycle.go +// and the four `teams.` defaults) lives in the engine's profile for +// wire_teams.go's reason: the far session's team tools read and write it +// there. So the teams page over --host asks for it through these doors, +// answered from [Engine.ProfileDir] and the engine machine's usage ledger, +// and never from this laptop. +// +// THEY ARE SHAPED FOR A CLOCK, like the teams doors. The two reads a page +// repeats, the open packets and a team's spend, carry the stamp the window +// last got and are answered `{"stamp":"…","same":true}` when nothing moved, +// which the engine learns from stats (a directory listing and a stat per team +// for the packets, two stats for the spend). The writes are single calls: a +// packet write is an append under the engine's lock, validated there, and +// needs no compare-and-swap because an append cannot undo another writer. +// +// THEY ARE ADDITIVE, and [Welcome.Delegation] says an engine has them. A +// window facing an engine without it leaves the delegation seam doors nil and +// says the teams page's inbox and spend are not available over that +// connection; it never reads the laptop's packet files, which the far +// manager never sees. Closing and reopening a team are edits to the teams +// file and cross by [MethodTeamsUpdate] like any other; only deleting, which +// removes the team's Traffic and packet files too, needs its own door. +const ( + // MethodTeamsDefaults is the engine profile's five `teams.` defaults. + MethodTeamsDefaults = "Teams.Defaults" // struct{} → teamstore.Defaults + // MethodTeamsApplyDefault writes one of those rows, the same way the + // settings tab writes it locally (config's ApplyTeamDefault). The answer + // is the five defaults after the write. [Welcome.TeamSettings] says an + // engine has the door; an engine without it leaves the tab read-only. + MethodTeamsApplyDefault = "Teams.ApplyDefault" // TeamDefaultArgs → teamstore.Defaults + // MethodTeamsPackets is the packets waiting on a scope, or word that the + // packet files have not moved since the stamp the window holds. + MethodTeamsPackets = "Teams.Packets" // PacketsArgs → PacketsReading + // MethodTeamsRaise records a new packet and answers it as written. + MethodTeamsRaise = "Teams.Raise" // teamstore.Packet → teamstore.Packet + // MethodTeamsDecide records a decision on a packet. + MethodTeamsDecide = "Teams.Decide" // DecideArgs → teamstore.Packet + // MethodTeamsEscalate sends a packet up. + MethodTeamsEscalate = "Teams.Escalate" // EscalateArgs → teamstore.Packet + // MethodTeamsSpend is one team's spend on a day, or word that neither the + // teams file nor the ledger moved since the stamp the window holds. + MethodTeamsSpend = "Teams.Spend" // SpendArgs → SpendReading + // MethodTeamsDelete forgets a closed team and its files. + MethodTeamsDelete = "Teams.Delete" // DeleteTeamArgs → DeleteTeamReply +) + +// THE WRAP-UP'S TWO DOORS ([Welcome.WrapUp]). Traffic is the channel between +// the interface and the session, and over --host the window reads it +// ([MethodTeamsTraffic]) but has no door to write it: so the one line the +// person's `Wrap up first` writes crosses by a door of its own, which appends +// exactly [teamstore.WrapUpRequest] to the engine's log and nothing else; and +// accepting a closing report, which closes the team and logs it, crosses by +// [teamstore.AcceptClosing] on the engine. Neither is a general Traffic +// writer: a window cannot put words in a member's mouth through them. +const ( + MethodTeamsWrapUp = "Teams.WrapUp" // WrapUpArgs → struct{} + MethodTeamsAcceptClosing = "Teams.AcceptClosing" // AcceptClosingArgs → AcceptClosingReply +) + +// WrapUpArgs is the team to wrap up and the person's words, "" for the +// standard ones. +type WrapUpArgs struct { + Team string `json:"team"` + Text string `json:"text,omitempty"` +} + +// AcceptClosingArgs names a decided closing packet. +type AcceptClosingArgs struct { + ID string `json:"id"` +} + +// AcceptClosingReply says whether this call closed the team, and the teams +// file's stamp after. +type AcceptClosingReply struct { + Closed bool `json:"closed"` + Stamp string `json:"stamp"` +} + +// TeamDefaultArgs is one `teams.` row, as the settings tab would apply it: +// Key is the registry key, Raw is what was typed (on, off, a number, or blank). +type TeamDefaultArgs struct { + Key string `json:"key"` + Raw string `json:"raw"` +} + +// PacketsArgs is a scope (a team id, teamstore.Person, or "" for every +// waiting packet) and the stamp the window last got, "" for none. +type PacketsArgs struct { + Scope string `json:"scope,omitempty"` + Stamp string `json:"stamp,omitempty"` +} + +// PacketsReading is the waiting packets and their stamp; Same says the stamp +// is the one asked about, and then Packets is absent. +type PacketsReading struct { + Stamp string `json:"stamp"` + Same bool `json:"same,omitempty"` + Packets []teamstore.Packet `json:"packets,omitempty"` +} + +// DecideArgs is a decision on one packet. +type DecideArgs struct { + ID string `json:"id"` + By string `json:"by"` + Decision string `json:"decision"` + Reason string `json:"reason,omitempty"` +} + +// EscalateArgs sends one packet to To: a team above, or teamstore.Person. +type EscalateArgs struct { + ID string `json:"id"` + By string `json:"by"` + To string `json:"to"` + Reason string `json:"reason,omitempty"` +} + +// SpendArgs is one team's day ("" is the engine's today) and the stamp the +// window last got. +type SpendArgs struct { + Team string `json:"team"` + Day string `json:"day,omitempty"` + Stamp string `json:"stamp,omitempty"` +} + +// SpendReading is the team's spend and its stamp; Same says nothing moved and +// then Spend is absent. +type SpendReading struct { + Stamp string `json:"stamp"` + Same bool `json:"same,omitempty"` + Spend *teamstore.Spend `json:"spend,omitempty"` +} + +// DeleteTeamArgs names the closed team to forget. +type DeleteTeamArgs struct { + Team string `json:"team"` +} + +// DeleteTeamReply is every team id forgotten and the teams file's stamp after. +type DeleteTeamReply struct { + Gone []string `json:"gone"` + Stamp string `json:"stamp"` +} diff --git a/internal/remote/wire_teams.go b/internal/remote/wire_teams.go new file mode 100644 index 0000000000..b10d4ba84b --- /dev/null +++ b/internal/remote/wire_teams.go @@ -0,0 +1,130 @@ +package remote + +import ( + "time" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── TEAMS ACROSS THE WIRE ─────────────────────────────────────────────────── +// +// A team's file and its Traffic logs live in the profile of the machine the +// SESSION runs on, because the team tools a model calls (internal/session) +// read and write them there. Over --host the window is on the laptop and the +// session is on the far machine, so a window that kept teams in its own +// profile would draw a list the manager never reads and a rail that is an +// empty log drawn as the team's. These three doors let the window read and +// write the ENGINE's teams, answered from [Engine.ProfileDir]. +// +// THEY ARE SHAPED FOR A CLOCK OVER SSH. The window asks about a managed team +// about once a second while it holds one of its conversations, and never at +// any other time. So every question carries what the window already has (the +// file's stamp, the log's cursor), and an answer about nothing new is a few +// bytes: `{"stamp":"…","same":true}` for the file and `{"stamp":"…"}` for a +// log. The engine stats before it reads ([teamstore.Watch]), so a quiet second +// costs it a stat per file too. +// +// THEY ARE ADDITIVE TO THIS VERSION, and [Welcome.Teams] is how a window knows +// they are there: an engine from before them sends no field, and the window +// turns teams off over that connection with the sentence it has always said +// rather than falling back to the laptop's file (internal/tui3's host.go). +const ( + // MethodTeamsRead is the engine's teams file, or word that it has not + // moved since the stamp the window holds. + MethodTeamsRead = "Teams.Read" // TeamsReadArgs → TeamsReading + // MethodTeamsUpdate writes the whole list back IF the file is still at the + // stamp the window read it at, and answers Stale when it is not. The window + // then reads again, makes its change again and retries (cmd/codeaf's + // hostTeams), so a manager the far session set in between is never undone. + MethodTeamsUpdate = "Teams.Update" // TeamsUpdateArgs → TeamsReading + // MethodTeamsTraffic is one team's log after a cursor, at most a page: the + // Ledger's Since pattern, so every call after the first carries only the + // lines written since. + MethodTeamsTraffic = "Teams.Traffic" // TeamsTrafficArgs → TeamsTraffic +) + +// TeamsReadArgs is what the window holds of the file. An empty Stamp is a +// window that has not read it yet and is always answered with the file. +// Reserved is the window's palette's reserved hues: a team the file left +// without a colour is coloured around them and the colour written back, as a +// local load does ([teamstore.LoadHued]). +type TeamsReadArgs struct { + Stamp string `json:"stamp,omitempty"` + Reserved []float64 `json:"reserved,omitempty"` +} + +// TeamsReading is the file as the engine holds it. Same says it is still at +// the stamp asked about, and then Teams is absent. Stale is only ever set by +// [MethodTeamsUpdate]: the file moved since the base, nothing was written, and +// Stamp is where it is now. +type TeamsReading struct { + Stamp string `json:"stamp"` + Same bool `json:"same,omitempty"` + Stale bool `json:"stale,omitempty"` + Teams []teamstore.Team `json:"teams,omitempty"` +} + +// TeamsUpdateArgs is the whole list the window wants written, and the stamp +// of the file it made that list from. +type TeamsUpdateArgs struct { + Base string `json:"base"` + Teams []teamstore.Team `json:"teams"` +} + +// TeamsTrafficArgs is one team's log after a cursor: After "" is the tail, +// the last Limit entries; an id pages forward from it. +type TeamsTrafficArgs struct { + Team string `json:"team"` + After string `json:"after,omitempty"` + Limit int `json:"limit,omitempty"` +} + +// TeamsTraffic is what came after the cursor, oldest first, and the log's +// stamp when it was read. +type TeamsTraffic struct { + Entries []teamstore.Entry `json:"entries,omitempty"` + Stamp string `json:"stamp,omitempty"` +} + +// ── AND THE TWO ASKS THE WALL MAKES OF THE ENGINE'S MODEL ─────────────────── +// +// A team's suggested name and Organize's proposals are one cheap call each on +// the naming role (internal/session's teamname.go and teampropose.go), made by +// the ENGINE because the model, its key and its bill are on the engine's +// machine. Over --host the wall is on the laptop, so without these two doors +// the default road never asked: the card kept the word it opened with and +// Organize showed the folder pass alone, in every terminal and in no test. +// +// THEY CARRY A BUDGET, NOT A DEADLINE, for [RefreshRunSummaryArgs.Budget]'s +// reason: the engine's clock is not this one's. The wall bounds each ask +// (internal/tui3's teamNameWait and organizeWait), and the engine bounds the +// model call by the same span so it stops when the wall stops listening. +// +// [Welcome.TeamAsk] says the engine answers them. An engine from before them +// sends no field, and this end refuses at once rather than spend a round trip +// on a refusal, which is exactly the failure the wall already turns into the +// word it holds and the folder pass alone. +const ( + // MethodTeamsName asks the engine's naming role for one short name for a + // group of conversations, given their titles. + MethodTeamsName = "Teams.Name" // TeamNameArgs → string + // MethodTeamsPropose asks the engine's naming role which teams the + // conversations offered could form and which existing teams more of them + // belong in. + MethodTeamsPropose = "Teams.Propose" // TeamProposeArgs → session.TeamProposal +) + +// TeamNameArgs is the titles a group is named from, and how long the wall +// will wait. Zero Budget is a caller with no deadline. +type TeamNameArgs struct { + Titles []string `json:"titles"` + Budget time.Duration `json:"budget,omitempty"` +} + +// TeamProposeArgs is everything one Organize ask is about, and how long the +// wall will wait. +type TeamProposeArgs struct { + In session.TeamProposalInput `json:"in"` + Budget time.Duration `json:"budget,omitempty"` +} diff --git a/internal/session/actioncategory.go b/internal/session/actioncategory.go index 96c8e3d052..6200e06fd6 100644 --- a/internal/session/actioncategory.go +++ b/internal/session/actioncategory.go @@ -220,7 +220,9 @@ func ActionCategoryForTool(tool string) ActionCategory { case "read", "read_document", "ls", "manual", "view_image", "settings", "use_skill", "tasks", "jobs", "list_harnesses", "list_subharnesses", "services", "gmail_read", "slack_read_thread", "slack_list_channels", - "calendar_list", "workspace_snapshots": + "calendar_list", "workspace_snapshots", + // A manager looking at its team: the states, and a member's page. + "team_status", "team_read": return ActionRead // Changing something that exists. @@ -246,11 +248,17 @@ func ActionCategoryForTool(tool string) ActionCategory { return ActionTransfer // Saying something to a person. - case "slack_send", "gmail_send", "speak", "ask": + case "slack_send", "gmail_send", "speak", "ask", + // A line into a team's traffic, from its manager or one of its members, + // a packet sent up, and a closing report to the person. + "team_send", "team_post", "team_escalate", "team_close_report", "team_raise": return ActionCommunicate // Work handed out, or this mind copied to run beside itself. - case "propose_task", "quick_task", "divide_work", "workspace_fork", "stand": + case "propose_task", "quick_task", "divide_work", "workspace_fork", "stand", + // A manager starting a member or ending its turn, or deciding what a + // member asked it. + "team_start", "team_stop", "team_decide": return ActionCoordinate // Keeping the account of the work rather than doing it. `items` is a quick diff --git a/internal/session/agent.go b/internal/session/agent.go index febbd1cd0c..c17448108e 100644 --- a/internal/session/agent.go +++ b/internal/session/agent.go @@ -435,6 +435,9 @@ func newAgent(config Config, client Completer) (*Agent, error) { // the frontier, but no ending or notice may run before the caller can hold // the agent and a surface can subscribe to its standing lane. agent.armWallClock() + // AND A CONVERSATION A TEAM'S MANAGER STARTED TAKES ITS FIRST TURN ON ITS + // OWN, once the interface has made it a member (team_wake.go). + agent.watchTeamStart() return agent, nil } @@ -949,6 +952,12 @@ func (a *Agent) Submit(ctx context.Context, text string) (<-chan Event, error) { if text == "" { return nil, errors.New("session: empty message") } + // A @ team or chat in the words is a reference, and the model needs a + // bounded digest of it (mention.go). The journal keeps the words as typed. + said := text + if note := a.mentionNote(text); note != "" { + text = text + "\n\n" + note + } // A PERSON'S TURN OPENS ON WHAT IS RUNNING, while anything is (plandigest.go // states why it is pushed rather than asked for). The digest is read here, // on the person's own door, and nowhere else: a wake note, a job's ending @@ -956,9 +965,15 @@ func (a *Agent) Submit(ctx context.Context, text string) (<-chan Event, error) { // the block is the empty string whenever no run is live, which is every turn // of most conversations. if digest := a.planDigest(); digest != "" { - return a.submitUser(ctx, planDigested(digest, text)) + user := planDigested(digest, text) + user.said = said + return a.submitUser(ctx, user) + } + user := userText(text) + if text != said { + user.said = said } - return a.submitUser(ctx, userText(text)) + return a.submitUser(ctx, user) } // submitUser is Submit's body with the MESSAGE left to the caller: the closed @@ -1163,9 +1178,11 @@ type userMessage struct { wake bool // said is THE PERSON'S OWN WORDS, when what the model reads is not only - // them. Empty in every ordinary case, and set by exactly one door: a draft - // the person MARKED STANDING, whose message carries an instruction in front - // of the sentence (standing_mark.go). + // them. Empty in every ordinary case, and set by two doors: a draft the + // person MARKED STANDING, whose message carries an instruction in front of + // the sentence (standing_mark.go), and a message that names a team or a + // conversation, whose message carries that reference's digest after the + // sentence (mention.go). // // THE INSTRUCTION IS THE MODEL'S AND THE JOURNAL IS THE PERSON'S. A // transcript that replayed the instruction would show somebody a paragraph @@ -1685,6 +1702,8 @@ func (u userMessage) journaled() ai.Message { // it is about is already on the steering queue, and the loop's first drain // writes it (see [Agent.wakeLocked]). func (a *Agent) startTurnLocked(ctx context.Context, user userMessage, watcher *eventStream, extra ...*eventStream) <-chan Event { + // The person speaking is what resets a team's loop breaker (team_wakewatch.go). + a.notePersonTurn(user) a.rebindClientLocked(a.model) a.running = true a.lastTurnTruncated = false @@ -1920,6 +1939,11 @@ func (a *Agent) startTurnLocked(ctx context.Context, user userMessage, watcher * // return above because a turn that was abandoned has had every one // of these acts done for it already. a.retireTurnQuestions() + // AND A TEAM MEMBER'S MANAGER IS TOLD HOW IT ENDED, after the + // questions above came down, so the wait the turn ended inside is + // closed before the ending is said (teamevent.go). The context is + // the turn's own, still uncancelled unless somebody stopped it. + a.teamTurnEnded(turnCtx, hub) }() // A faulted turn must end its streams with a reason rather than take // the process down: the person is holding a live channel. @@ -2737,8 +2761,18 @@ func (a *Agent) landVolatileLocked() { // (memory.go), so leaving it in front of the whole conversation re-priced the // entire transcript on any turn the router reached differently — the same bug // the card had, on a faster beat. See [memoryNoteOpening]. + // THE TEAM ROLE LANDS FIRST, because it is the one note that says what this + // conversation is rather than what is around it, and it was composed from a + // read made before this request ([Agent.teamBoundary]) rather than beside + // the work, so it is never a step late (team.go's [teamRoleNoteOpening]). + a.landTeamRoleLocked() a.landNoteLocked(memoryNoteOpening, strings.TrimSpace(a.memoryText)) a.landNoteLocked(volatileNoteOpening, a.volatileBlockLocked()) + // AND A MANAGER'S TEAM, in a note of its own for the reason the memory block + // has one: a team moves whenever a member does, and riding the card's note + // would re-send the card each time (team.go's [teamNoteOpening]). A + // conversation that manages nothing has an empty block and lands nothing. + a.landNoteLocked(teamNoteOpening, a.teamBlockLocked()) } // landNoteLocked appends one of the session's own notes when what it says has @@ -2802,7 +2836,9 @@ func (a *Agent) lastNoteLocked(opening string) string { func isVolatileNote(text string) bool { return strings.HasPrefix(text, volatileNoteOpening) || strings.HasPrefix(text, memoryNoteOpening) || - strings.HasPrefix(text, bashBeltFrameOpening) + strings.HasPrefix(text, bashBeltFrameOpening) || + strings.HasPrefix(text, teamNoteOpening) || + strings.HasPrefix(text, teamRoleNoteOpening) } // mayBashBelt is [Config.mayBashBelt] asked of a live agent, so that the @@ -3038,6 +3074,17 @@ func (a *Agent) drainSteering(hub *eventHub) int { // the first thing it reads, and an agent that is not on the experiment // composes nothing and lands nothing. frame := a.bashBeltFrame(hub) + // AND WHAT THIS CONVERSATION'S TEAMS SAID TO IT, read on the same side of + // the lock for the same reason: it is a stat of the teams file and of each + // Traffic log, and a read only when one of them moved (team.go's + // [Agent.teamBoundary]). What comes back is one marked note on the steering + // queue, so the drain below puts it in front of this very request: at the + // turn's opening and at every step after it, which is what makes a line the + // manager sends mid-turn land mid-turn. A conversation in no team pays one + // stat, and one with no profile or a task node pays nothing. + if news := a.teamBoundary(); news != "" { + a.enqueueNote(userText(news)) + } a.mu.Lock() opening := !a.running || len(a.messages) == a.turnFloor // AND THE VOLATILE NOTE LANDS HERE, ahead of the steering, for the reason the @@ -4547,6 +4594,14 @@ type DisplayEntry struct { // Nil on every other entry, and on every session with no file to have kept a // mark. Steer *SteerMark + + // Team is what a TEAM DELIVERY handed this conversation, line by line, on + // an "aside" that is one (teamshape.go): the manager's brief that started + // it (Kind [teams.KindStart]), a manager's note or directive, a teammate's + // post. It is what lets a surface draw the brief as a quoted card headed by + // who sent it rather than as the aside's first line. Nil on every other + // entry; the aside's Text still holds the whole delivery as the model read it. + Team []TeamLine } // SteerMark is what the record keeps about one steer that LANDED: when the @@ -4666,6 +4721,10 @@ func shapeEntries(messages []ai.Message, journal *sessionFile) []DisplayEntry { role = "aside" replyTags = append(replyTags, journal.taskReplyTags(msg)...) } + var team []TeamLine + if role == "aside" { + team = teamNewsLines(messageContentText(msg)) + } var tags []TaskReplyTag if role == "assistant" && len(replyTags) > 0 { tags = append([]TaskReplyTag(nil), replyTags...) @@ -4681,6 +4740,7 @@ func shapeEntries(messages []ai.Message, journal *sessionFile) []DisplayEntry { // message itself is an ordinary user message, because that is what the // model has to read it as (steer.go). Steer: journal.steerMark(msg), + Team: team, }) for callIndex := range msg.ToolCalls { call := &msg.ToolCalls[callIndex] diff --git a/internal/session/answers.go b/internal/session/answers.go index 0f92a91e4c..73f80e537a 100644 --- a/internal/session/answers.go +++ b/internal/session/answers.go @@ -241,11 +241,11 @@ func AnswerOptions(kind QuestionKind) []AnswerOption { {Key: "2", Label: "no", Safe: true}, } case QuestionStanding: - return []AnswerOption{ - {Key: "1", Label: "yes"}, - {Key: StandingOnceKey, Label: "just once"}, - {Key: StandingNoKey, Label: "not set up"}, - } + // THE KIND'S ROW, WITH NO ITEM TO NARROW IT. A card is built from + // [StandingOptions], which says the words for THAT item. This list is + // the repeating check, the shape a bare key still has to name, and the + // yes carries no cadence because there is no when to read one from. + return standingCheckOptions("") case QuestionConnect: return []AnswerOption{ {Key: "1", Label: "connect"}, @@ -397,51 +397,137 @@ const StandingOnceKey = "3" // it in the one place there is an esc to spare. const StandingNoKey = "0" -// StandingOnceIsAnAnswer reports whether "once, not standing" MEANS anything -// for one item, and it is the ONE PLACE that is decided. +// StandingOnceIsAnAnswer reports whether "do it once, now" MEANS anything for +// one item, and it is the ONE PLACE that is decided. // // "Once" means: do the action NOW, as an ordinary turn, and leave nothing -// behind ([StandingAnswer.Once]). For a watch, a rule, a routine or overnight -// work that is a real answer — the person wants the thing done, not the -// arrangement. FOR A ONE-OFF REMINDER IT IS NOT AN ANSWER AT ALL: the whole -// content of "remind me at six" is the SIX, and doing it now says "time to -// leave" hours early or says nothing. A person met that chip after asking for a -// one-minute timer, pressed it because it was the only answer that was not a -// commitment, and was told the build could not hold a timer — which it can, and -// does, and had just offered to. -// -// So the card does not draw it there. Everywhere else it stays. +// behind ([StandingAnswer.Once]). A repeating check and a watch are things a +// person may want done once. A reminder's whole content is the moment, and +// doing it now says the thing at the wrong time. A rule never runs, so "once" +// has nothing to do. func StandingOnceIsAnAnswer(item standing.Item) bool { - return !(item.When.Kind == standing.WhenAt && item.Does.Kind == standing.ActionSay) + switch item.CardKindOf() { + case standing.CardCheck, standing.CardWatch: + return true + default: + return false + } +} + +// The heads a standing card opens with. The person's own sentence is the next +// line, not this one: this line says what KIND of thing is being asked. +const ( + StandingHeadReminder = "wants to remind you" + StandingHeadCheck = "wants to set up a repeating check" + StandingHeadWatch = "wants to watch for something" + StandingHeadRule = "wants to keep a rule" +) + +// StandingHead is the card's first line for this item. +func StandingHead(item standing.Item) string { + switch item.CardKindOf() { + case standing.CardReminder: + return StandingHeadReminder + case standing.CardCheck: + return StandingHeadCheck + case standing.CardRule: + return StandingHeadRule + default: + return StandingHeadWatch + } } -// StandingOptions is [AnswerOptions](QuestionStanding) narrowed to ONE item: -// the answers this particular card offers, in the order chips are drawn. +// StandingChangeWord is the correction button. A rule's correction is about +// where it reaches. Everything else is about the arrangement. +func StandingChangeWord(item standing.Item) string { + if item.CardKindOf() == standing.CardRule { + return "Change where…" + } + return "Change…" +} + +// StandingChangeHint is what the correction button does, in one sentence. +func StandingChangeHint(item standing.Item) string { + switch item.CardKindOf() { + case standing.CardReminder: + return "Say a different time. Nothing is set up yet." + case standing.CardRule: + return "Say where it should reach. Nothing is kept yet." + case standing.CardWatch: + return "Say what to watch for instead. Nothing is set up yet." + default: + return "Say a different time or place. Nothing is set up yet." + } +} + +// standingCadenceMark separates a yes label from the cadence it carries. A +// narrow row drops everything from this mark on before it cuts a character. +const standingCadenceMark = " · " + +// StandingPlainLabel is a label with its cadence removed. A label that carries +// none is returned as it is. +func StandingPlainLabel(label string) string { + if at := strings.Index(label, standingCadenceMark); at > 0 { + return label[:at] + } + const stem = "Remind me " + if strings.HasPrefix(label, stem) && len(label) > len(stem) { + return "Remind me" + } + return label +} + +// StandingOptions is the answers THIS card offers, in the order they are drawn. // -// THE ONLY CHIP THAT IS EVER MISSING IS THE `once`. A yes and a no are answers -// to every standing card there is — "set it up" and "set nothing up" are what -// the question means — so [StandingNoKey] is on every row this returns, and a -// person who learned the decline on a watch finds it under the same key on a -// reminder. +// THE WORDS ARE THIS ITEM'S. A reminder, a repeating check, a watch and a rule +// are different questions, and a label that could mean two of them is how a +// person presses the wrong one. Every surface, including another window and the +// record of what was pressed, reads this list. // -// IT IS WHAT BOTH SURFACES DRAW FROM. The engine puts it on the card -// ([StandingNotice.Options]) and into the presence file another window answers -// through ([Agent.presenceAsking]), so the conversation's chip row, home's chip -// row and the keys the session will actually accept are one decision made once -// — a chip that does nothing is exactly what this file's third law forbids. +// THE KEYS DO NOT MOVE. 1 is the yes, 3 is once, 0 is the no. Once is missing +// on a reminder and on a rule, and it is never the answer a cursor may rest on. +// The no is last and marked safe, so a row that has to drop an answer drops +// one in front of it. func StandingOptions(item standing.Item) []AnswerOption { - options := AnswerOptions(QuestionStanding) - if StandingOnceIsAnAnswer(item) { - return options - } - kept := make([]AnswerOption, 0, len(options)) - for _, option := range options { - if option.Key == StandingOnceKey { - continue + cadence := item.When.ShortWords() + switch item.CardKindOf() { + case standing.CardReminder: + yes := "Remind me" + if cadence != "" { + yes = "Remind me " + cadence + } + return []AnswerOption{ + {Key: "1", Label: yes, Consequence: "Reminds you then. Nothing repeats."}, + {Key: StandingNoKey, Label: "Don't remind me", Consequence: "You are not reminded.", Safe: true}, + } + case standing.CardWatch: + return []AnswerOption{ + {Key: "1", Label: "Watch for it", Consequence: "It watches until you stop it."}, + {Key: StandingOnceKey, Label: "Check once now", Consequence: "Checks once now. Nothing keeps watching."}, + {Key: StandingNoKey, Label: "Don't watch", Consequence: "Nothing watches.", Safe: true}, + } + case standing.CardRule: + return []AnswerOption{ + {Key: "1", Label: "Keep this rule", Consequence: "The rule is kept until you stop it."}, + {Key: StandingNoKey, Label: "Don't keep it", Consequence: "The rule is not kept.", Safe: true}, } - kept = append(kept, option) + default: + return standingCheckOptions(cadence) + } +} + +// standingCheckOptions is a repeating check's row. An empty cadence leaves the +// yes as the stem, which is also what a bare key names when no item is in hand. +func standingCheckOptions(cadence string) []AnswerOption { + yes := "Set it up" + if cadence != "" { + yes = "Set it up" + standingCadenceMark + cadence + } + return []AnswerOption{ + {Key: "1", Label: yes, Consequence: "It repeats on that cadence until you stop it."}, + {Key: StandingOnceKey, Label: "Only now, don't repeat", Consequence: "Runs the check one time now. Nothing repeats."}, + {Key: StandingNoKey, Label: "Don't set it up", Consequence: "Nothing is set up, and nothing runs.", Safe: true}, } - return kept } // AnswerLabel is the word for one key, and "" for a key that kind does not diff --git a/internal/session/answers_test.go b/internal/session/answers_test.go index d9a21e3311..f09575266f 100644 --- a/internal/session/answers_test.go +++ b/internal/session/answers_test.go @@ -5,6 +5,7 @@ import ( "encoding/json" "os" "path/filepath" + "strings" "testing" "time" @@ -219,7 +220,7 @@ func TestTheStandingCardTravelsInPresenceAndAnAnswerComesBack(t *testing.T) { if question.Kind != QuestionStanding || question.ID != proposal.Standing.ID { t.Fatalf("the question reads %+v, the card is %d", question, proposal.Standing.ID) } - if question.Text != "wants to keep an eye on: tell me when ci goes red" { + if question.Text != StandingHeadWatch { t.Fatalf("the line is %q", question.Text) } // `2 change when` is not offered from another window: it is a request for a @@ -292,6 +293,76 @@ func TestAStandingCardIsDeclinedFromAnotherWindowWithOneKey(t *testing.T) { waitForNoQuestion(t, dir) } +// EACH KIND OF CARD SAYS WHAT IT IS, AND EACH BUTTON SAYS WHAT IT DOES. +func TestStandingCardWordsFollowTheKind(t *testing.T) { + cases := []struct { + item standing.Item + head string + yes string + once string + no string + }{ + { + item: standing.Item{When: standing.When{Kind: standing.WhenAt, Words: "at 6"}}, + head: StandingHeadReminder, yes: "Remind me at 6", once: "", no: "Don't remind me", + }, + { + item: standing.Item{When: standing.When{Kind: standing.WhenEvery, Words: "every 3 hours"}}, + head: StandingHeadCheck, yes: "Set it up · every 3 hours", once: "Only now, don't repeat", no: "Don't set it up", + }, + { + item: standing.Item{When: standing.When{Kind: standing.WhenProbe, Words: "when CI goes red"}}, + head: StandingHeadWatch, yes: "Watch for it", once: "Check once now", no: "Don't watch", + }, + { + item: standing.Item{When: standing.When{Kind: standing.WhenHold, Words: "always"}}, + head: StandingHeadRule, yes: "Keep this rule", once: "", no: "Don't keep it", + }, + } + for _, c := range cases { + if got := StandingHead(c.item); got != c.head { + t.Errorf("%s head %q, want %q", c.item.When.Kind, got, c.head) + } + var sawOnce bool + for _, option := range StandingOptions(c.item) { + switch option.Key { + case "1": + if option.Label != c.yes || option.Consequence == "" { + t.Errorf("%s yes %q (%q)", c.item.When.Kind, option.Label, option.Consequence) + } + if option.Safe { + t.Errorf("%s yes is the cursor rest", c.item.When.Kind) + } + case StandingOnceKey: + sawOnce = true + if option.Label != c.once || option.Safe { + t.Errorf("%s once %q safe=%v", c.item.When.Kind, option.Label, option.Safe) + } + if option.Consequence == "" { + t.Errorf("%s once has no hint", c.item.When.Kind) + } + case StandingNoKey: + if option.Label != c.no || !option.Safe || option.Consequence == "" { + t.Errorf("%s no %+v", c.item.When.Kind, option) + } + } + } + if sawOnce != (c.once != "") { + t.Errorf("%s once offered=%v want %q", c.item.When.Kind, sawOnce, c.once) + } + if plain := StandingPlainLabel(c.yes); strings.Contains(c.yes, " · ") && strings.Contains(plain, " · ") { + t.Errorf("%s plain label kept the cadence: %q", c.item.When.Kind, plain) + } + if c.item.When.Kind == standing.WhenAt && StandingPlainLabel(c.yes) != "Remind me" { + t.Errorf("reminder plain label %q", StandingPlainLabel(c.yes)) + } + } + long := standing.When{Words: "every Monday morning after the deploy window closes and the board has signed off"} + if got := long.ShortWords(); len(got) > 40 || !strings.HasSuffix(got, "...") { + t.Fatalf("a long cadence was not shortened: %q", got) + } +} + // THE DECLINE IS ON EVERY STANDING CARD THERE IS. The `once` chip is the only // one that is ever missing (a one-off reminder's), because "do it now" is not a // smaller version of "do it at six" — but "set nothing up" answers every @@ -309,7 +380,7 @@ func TestEveryStandingCardOffersTheSameDecline(t *testing.T) { for _, item := range []standing.Item{reminder, watch} { var found bool for _, option := range StandingOptions(item) { - found = found || (option.Key == StandingNoKey && option.Label == "not set up") + found = found || (option.Key == StandingNoKey && option.Label != "") } if !found { t.Fatalf("a %s card offers %v, with no decline on it", item.When.Kind, StandingOptions(item)) @@ -470,9 +541,9 @@ func TestTheKeysMeanWhatTheChipsSay(t *testing.T) { // named no action at all (question.go's proposalQuestion). {QuestionTask, "1", "start it", func(a AnswerAction) bool { return a.Task.Approved }}, {QuestionTask, "2", "no", func(a AnswerAction) bool { return !a.Task.Approved }}, - {QuestionStanding, "1", "yes", func(a AnswerAction) bool { return a.Standing.Approved && !a.Standing.Once }}, - {QuestionStanding, "3", "just once", func(a AnswerAction) bool { return a.Standing.Once && !a.Standing.Approved }}, - {QuestionStanding, "0", "not set up", func(a AnswerAction) bool { + {QuestionStanding, "1", "Set it up", func(a AnswerAction) bool { return a.Standing.Approved && !a.Standing.Once }}, + {QuestionStanding, "3", "Only now, don't repeat", func(a AnswerAction) bool { return a.Standing.Once && !a.Standing.Approved }}, + {QuestionStanding, "0", "Don't set it up", func(a AnswerAction) bool { return a.Standing == (StandingAnswer{}) }}, } { diff --git a/internal/session/cardanswer_test.go b/internal/session/cardanswer_test.go new file mode 100644 index 0000000000..ad883f7bbe --- /dev/null +++ b/internal/session/cardanswer_test.go @@ -0,0 +1,123 @@ +package session + +import ( + "context" + "encoding/json" + "strings" + "sync/atomic" + "testing" + + "github.com/Agent-Field/agentfield/sdk/go/ai" +) + +// A PERSON'S CARD ANSWER IS ON THE PAGE THE CHECKER READS, and a gap that +// answer already chose does not carry the turn on. +// +// The measured failure: the person pressed `just once`, the tool said nothing +// was set up, the digest clipped that result, and the checker raised "the +// recurring reminder was never set up" three times. This drives [Agent.checkerPage] +// through [Agent.checkpointReopen]. A checker that cannot see the answer line +// raises the gap, so the test is red without the line on the page. +func TestAPersonsCardAnswerReachesTheCheckerAndClosesTheGap(t *testing.T) { + const gap = "The recurring reminder was never set up" + var page atomic.Value + var done atomic.Int64 + steps := make([]step, 20) + for index := range steps { + steps[index] = func(_ context.Context, messages []ai.Message) (*ai.Response, error) { + if askedForSketch(messages) { + return textResponse("one job, still in this conversation"), nil + } + if askedForHandoff(messages) { + return textResponse("a draft of what is left"), nil + } + if askedToWriteHandoff(messages) { + return textResponse("a brief somebody could work from"), nil + } + if askedForRemains(messages) { + shown := messageText(messages[len(messages)-1]) + page.Store(shown) + if strings.Contains(shown, "only now, don't repeat") { + return textResponse(checkpointNothingLeft), nil + } + return textResponse(gap), nil + } + switch call := done.Add(1); call { + case 1: + return toolResponse("s1", "stand", aRepeatingCheck()), nil + case 2: + // The last act is a write, so the cheap turn is still read + // (checkpoint.go's exposure gate) without climbing a mark. + return toolResponse("w1", "write", `{"path":"note.txt","content":"time to leave"}`), nil + default: + return textResponse("I stopped. The reminder was never set up."), nil + } + } + } + store := newFakeStanding(t) + completer := &scriptedCompleter{steps: steps} + agent := checkpointWritingAgent(t, completer, func(config *Config) { + config.Standing = &Standing{} + config.standingItems = store + }) + + events, err := agent.Submit(watchedContext(agent), "check the marketing slack every 3 hours") + if err != nil { + t.Fatalf("Submit: %v", err) + } + collected := drainAnsweringStanding(t, events, func(event Event) { + if err := agent.ResolveQuestion(Answer{ + Kind: QuestionStanding, ID: event.Standing.ID, Key: StandingOnceKey, + }); err != nil { + t.Errorf("ResolveQuestion: %v", err) + } + }) + shown, _ := page.Load().(string) + if !strings.Contains(shown, `the person answered the card "`+StandingHeadCheck+`": only now, don't repeat`) { + t.Fatalf("the checker was not shown the card answer:\npage:\n%s\ntranscript:\n%s\nevents: %v", shown, transcriptText(agent), kinds(collected)) + } + if strings.Contains(transcriptText(agent), checkpointCarryOnLead) { + t.Fatal("a gap the person chose carried the turn on") + } + if len(store.created) != 0 { + t.Fatal("a once answer created a standing item") + } + _ = collected +} + +// aRepeatingCheck is the measured proposal: a check every three hours, the +// one kind whose card offers only now. +func aRepeatingCheck() string { + body := map[string]any{ + "op": "propose", + "words": "check the marketing slack every 3 hours", + "when": map[string]any{"kind": "every", "every": "3h"}, + "does": map[string]any{"kind": "say", "say": "check the marketing slack"}, + "when_words": "every 3 hours", + "cost_words": "nothing to speak of, one line each time", + } + raw, _ := json.Marshal(body) + return string(raw) +} + +func TestPersonCardAnswerLineKeepsOnceAndAnyOtherCard(t *testing.T) { + standing := Question{ + Kind: QuestionStanding, + Head: "wants to keep an eye on: run the tests", + } + once := personCardAnswerLine(standing, Answer{Kind: QuestionStanding, Key: StandingOnceKey, DecidedBy: DecidedByPerson}) + if once != `the person answered the card "wants to keep an eye on: run the tests": only now, don't repeat` { + t.Fatalf("once line = %q", once) + } + consent := Question{ + Kind: QuestionConsent, Head: "may I run the tests", + Options: AnswerOptions(QuestionConsent), + } + allowed := personCardAnswerLine(consent, Answer{Kind: QuestionConsent, Key: "1", DecidedBy: DecidedByPerson}) + if allowed != `the person answered the card "may I run the tests": allow once` { + t.Fatalf("consent line = %q", allowed) + } + if personCardAnswerLine(consent, Answer{Kind: QuestionConsent, Key: "1", DecidedBy: DecidedByDial}) != "" { + t.Fatal("a dial's answer was written as the person's") + } +} diff --git a/internal/session/checkpoint.go b/internal/session/checkpoint.go index 37f6d0114f..65c8e43be8 100644 --- a/internal/session/checkpoint.go +++ b/internal/session/checkpoint.go @@ -125,6 +125,7 @@ import ( "encoding/json" "errors" "fmt" + "strconv" "strings" "time" "unicode" @@ -1884,7 +1885,7 @@ func (a *Agent) readMark(ctx context.Context) checkpointRead { // is left, and nothing inside a tool result changes that shape. asked := a.turnAsk() snapshot := a.snapshot() - page := checkpointCompletionPage(asked, snapshot) + page := a.checkerPage(asked, snapshot) if page == "" { // NOTHING TO READ IS NOT A READING. A turn with no ask, no tool call and // nothing said has nothing for a second mind to be shown, and a call made @@ -1963,7 +1964,7 @@ func (a *Agent) readMark(ctx context.Context) checkpointRead { // writer can weigh beneath it (task_divide_sketch.go). The handoff page adds // the complete ask in its own section, so carrying it here would send the // same request twice. - read.digest = checkpointDigest("", snapshot) + read.digest = withPersonCardAnswers(checkpointDigest("", snapshot), a.personCardAnswerLines()) return read } @@ -3799,7 +3800,7 @@ func (a *Agent) readRemains(ctx context.Context) readerLine { } // THE ASK IS THE ONE THIS TURN OWES, which on a woken turn is the request its // result belongs to and not whatever was typed last (wakecause.go). - page := checkpointCompletionPage(a.turnAsk(), a.completionSnapshot()) + page := a.checkerPage(a.turnAsk(), a.completionSnapshot()) if page == "" { return readerLine{} } @@ -3848,6 +3849,95 @@ func (a *Agent) completionSnapshot() []ai.Message { return messages } +// checkerPage is the account a completion check is shown, with this turn's +// card answers kept after the clipped digest. A person's answer is final for +// the gap it chose, and a result that said "nothing was set up" is not. +func (a *Agent) checkerPage(asked string, messages []ai.Message) string { + page := checkpointCompletionPage(asked, messages) + if page == "" { + return "" + } + return withPersonCardAnswers(page, a.personCardAnswerLines()) +} + +// checkpointDigestAnswered heads the card answers. It sits outside the digest +// clip, so a long ledger cannot drop the one fact that closes a chosen gap. +const checkpointDigestAnswered = "WHAT THE PERSON ANSWERED ON A CARD" + +// withPersonCardAnswers appends the lines. An empty list leaves the page +// untouched, which is the emptiness law: a turn with no card says nothing +// about cards. +func withPersonCardAnswers(page string, lines []string) string { + if len(lines) == 0 { + return page + } + var out strings.Builder + if strings.TrimSpace(page) != "" { + out.WriteString(strings.TrimSpace(page)) + out.WriteString("\n\n") + } + out.WriteString(checkpointDigestAnswered) + out.WriteString("\n") + for _, line := range lines { + if line = strings.TrimSpace(line); line == "" { + continue + } + out.WriteString(line) + out.WriteString("\n") + } + return strings.TrimSpace(out.String()) +} + +// personCardAnswerLine is one card, compact, in the shape the checker reads. +// A standing "just once" is spelled "only now, don't repeat" because the tool +// result says nothing was set up, and that sentence is the gap the person +// chose. Every other recorded answer keeps the words on the card. +func personCardAnswerLine(q Question, answer Answer) string { + title := strings.TrimSpace(q.Head) + gloss := personCardAnswerGloss(q, answer) + if title == "" || gloss == "" { + return "" + } + return "the person answered the card " + strconv.Quote(title) + ": " + gloss +} + +// personCardAnswerGloss is the half of the line after the colon. +func personCardAnswerGloss(q Question, answer Answer) string { + if answer.DecidedBy != "" && answer.DecidedBy != DecidedByPerson { + return "" + } + if q.Kind == QuestionStanding && answer.FirstKey() == StandingOnceKey { + return "only now, don't repeat" + } + words := strings.TrimSpace(decisionRecordOf(q, answer).Words()) + if change := strings.Join(strings.Fields(answer.Change), " "); change != "" { + if words == "" { + words = change + } else if !strings.Contains(words, change) { + words += "; " + change + } + } + return strings.Join(strings.Fields(words), " ") +} + +// rememberPersonCardAnswer keeps one resolved card for the checker. A decision +// the person did not make (a dial, an earlier record) is not their answer. +func (a *Agent) rememberPersonCardAnswer(q Question, answer Answer) { + line := personCardAnswerLine(q, answer) + if line == "" { + return + } + a.mu.Lock() + a.personCardAnswers = append(a.personCardAnswers, line) + a.mu.Unlock() +} + +func (a *Agent) personCardAnswerLines() []string { + a.mu.Lock() + defer a.mu.Unlock() + return append([]string(nil), a.personCardAnswers...) +} + func checkpointCompletionPage(asked string, messages []ai.Message) string { asked = strings.TrimSpace(asked) if len(checkpointDigestAsked)+1+len(asked) <= checkpointDigestBytes { diff --git a/internal/session/consent.go b/internal/session/consent.go index e2b089b23c..0c25435ea4 100644 --- a/internal/session/consent.go +++ b/internal/session/consent.go @@ -372,7 +372,7 @@ func (a *Agent) askAnswer(ctx context.Context, hub *eventHub, call ai.ToolCall, // own words for why it is asking. Hint: a.gloss(call), Args: argsText(call), - Rule: decision.Rule, + Rule: consentRule(call, decision), // And whether the memo is even available, so a surface can leave the // "always" key off a question it would be dropped on (see Event.Memo). Memo: true, @@ -591,8 +591,8 @@ func (a *Agent) consentAsk(id uint64, call ai.ToolCall, decision approval.Decisi Ask: AskPermission, Form: FormLine, Asker: Asker{Kind: AskerEngine}, - Head: consentHeadLead + call.Function.Name, - Reason: consentReason(decision), + Head: ConsentHead(call.Function.Name, call.Function.Arguments), + Reason: consentReason(call, decision), Subject: SubjectRef{Kind: SubjectCall, CallID: call.ID, Name: call.Function.Name}, // AND WHICH STEP ASKED, so that three approvals raised by one tool batch // are drawn and answered as the one thing they are (question.go's @@ -618,12 +618,43 @@ func (a *Agent) consentAsk(id uint64, call ai.ToolCall, decision approval.Decisi // window — home, a second terminal, the phone — and the tool's name closes it. const consentHeadLead = "needs your ok to run " +// ConsentHead is the permission question's one line for a call: "needs your ok +// to run bash", and for a manager's `team_start` the sentence the person is +// actually being asked, "◆ manager wants to start @lexer". args is the call's +// arguments as JSON, the raw ones or [Event.Args]; a start whose handle cannot +// be read falls back to the ordinary line. +// +// IT IS EXPORTED SO THERE IS ONE BUILDER. The card a surface draws and the +// question home and a second window answer from are the same question, and two +// builders that drifted would make them two. +func ConsentHead(tool, args string) string { + tool = strings.TrimSpace(tool) + if tool == teamStartToolName { + if handle, _ := teamStartArgs(args); handle != "" { + return "◆ manager wants to start @" + handle + } + } + return consentHeadLead + tool +} + +// consentRule is [Event.Rule] for a call: the policy's own words, and for a +// start with none, what the person is agreeing to pay for ([teamStartCost]). +func consentRule(call ai.ToolCall, decision approval.Decision) string { + if rule := strings.TrimSpace(decision.Rule); rule != "" { + return rule + } + if call.Function.Name == teamStartToolName { + return teamStartCost + } + return "" +} + // consentReason is why the gate is asking, in the policy's own words where it // gave any and in this lane's own sentence where it did not. The wording is // internal/approval's on the same terms [Event.Rule] takes it: every surface // should say the same sentence about the same rule instead of deriving one. -func consentReason(decision approval.Decision) string { - if rule := strings.TrimSpace(decision.Rule); rule != "" { +func consentReason(call ai.ToolCall, decision approval.Decision) string { + if rule := consentRule(call, decision); rule != "" { return rule } return ConsentFallbackReason diff --git a/internal/session/handlepick.go b/internal/session/handlepick.go new file mode 100644 index 0000000000..c34e548e14 --- /dev/null +++ b/internal/session/handlepick.go @@ -0,0 +1,290 @@ +package session + +import ( + "context" + "errors" + "strings" + "time" + "unicode" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/provider" + "github.com/Agent-Field/codeaf/internal/roles" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// A member's handle, chosen by the conversation's own title model. +// +// A handle is ONE lowercase word naming what the conversation is about: +// @security for "santosh dev2 branch code complexity & security review", +// @milestones for "CodeAF repo issue tags & milestones", @gravity for "quantum +// gravity research updates / session monitor". The word list in internal/teams +// ([teams.DeriveHandle]) guesses one at once, so a member is addressable the +// moment it has a title, and the guesses it made of those three titles were +// @review, @reviewing and @session: a list cannot tell the subject of a title +// from the kind of work being done to it. A model can, in one word. +// +// IT IS THE CONVERSATION NAMER'S ERRAND WITH A ONE-WORD QUESTION, asked where +// the name is made. It goes through the same door ([Agent.callRoleChecked]) on +// the same role ([roles.RoleTitle]), so it lands on the cheap tier and is billed +// the same way, and it asks for a handful of tokens. It runs: +// +// - right after the conversation's title is published ([Agent.publishTitle]), +// which is the moment the title the word is read off exists; and +// - once per process at a step boundary, for a conversation that already had +// its title and is in a team whose handle for it is still the word list's +// guess. That is the ONE-TIME pass over handles made before this: each is +// chosen again, the same way, on its conversation's next turn. A timeout or +// a dropped connection is asked once more; a refusal is not. +// +// IT RUNS ON THE MACHINE THAT OWNS THE MODEL AND THE STORE. Over --host that is +// the engine, where this session is, and the teams file is that machine's. +// +// ONLY A GUESS IS REPLACED ([teams.Member.HandleDerived]). A handle a person or +// the manager gave is never touched, and one the model chose is not chosen +// again ([teams.File.ChooseHandle]). A clash inside a team takes the model's +// second choice, then a word of the title in front of the first; never a +// number unless nothing else fits. +// +// EVERY RENAME IS SAID IN THE TEAM'S TRAFFIC, `@review is now @security`, from +// codeaf to everyone, so the manager and the members read it at their next +// step ([teamLine]) and the person sees it on the rail. The manager's role note +// names the members by handle and is read again when the teams file moves, so +// it refreshes on its own. + +// handleAsk is the instruction, last in the user message for the reason +// titleSystem's comment gives. +const handleAsk = "Give this conversation a handle: ONE lowercase English word that names what it is about, its subject, not the kind of work (not review, fix, update, session, research). Then two other such words, in case the first is taken. Answer with the three words on one line, best first." + +// handleTokens is the whole budget of one ask: three short words. +const handleTokens = 24 + +// handleRetryWait is the one pause before a handle ask is tried again. The +// guess already stands, so the wait is short: long enough that a timeout or a +// dropped connection has a chance to clear, and one try only. +const handleRetryWait = 250 * time.Millisecond + +// handleBackoff is that wait's seam, so a test states it without spending it. +var handleBackoff = backoffWait + +// handleChoices is how many words an answer is read for. +const handleChoices = 3 + +// chooseTeamHandlesLater starts the handle errand beside the turn for title, +// once per process, when this conversation is in a team whose handle for it is +// still a guess. roles is what the caller already read, nil to read them here. +// Nothing waits on it. +// +// A conversation in no team yet is not marked as asked: it may join one later +// in this process, and its first boundary in the team asks then. +func (a *Agent) chooseTeamHandlesLater(title string, roles []teamRole) { + title = strings.TrimSpace(title) + if title == "" || a.config.teamProfile() == "" { + return + } + if roles == nil { + roles = a.teamRoles() + } + if !rolesWantHandle(roles) { + return + } + a.team.mu.Lock() + if a.team.handleTried { + a.team.mu.Unlock() + return + } + a.team.handleTried = true + a.team.mu.Unlock() + a.mu.Lock() + ctx, model, closed := a.titleCtx, a.model, a.closed + if ctx == nil || closed { + a.mu.Unlock() + return + } + a.titleJobs.Add(1) + a.mu.Unlock() + go func() { + defer a.titleJobs.Done() + a.chooseTeamHandles(ctx, title, model) + }() +} + +// teamHandlePass is the boundary's half: a conversation with a title, in a team +// whose handle for it is a guess, has it chosen once. roles is what the +// boundary just read. +func (a *Agent) teamHandlePass(roles []teamRole) { + if !rolesWantHandle(roles) { + return + } + a.mu.Lock() + title := a.title + a.mu.Unlock() + a.chooseTeamHandlesLater(title, roles) +} + +// rolesWantHandle reports whether any of roles holds a guessed handle. +func rolesWantHandle(roles []teamRole) bool { + for _, role := range roles { + if role.derived { + return true + } + } + return false +} + +// chooseTeamHandles is the errand: one ask, then the word written to every team +// whose handle for this conversation is a guess, and each rename said in that +// team's Traffic. +func (a *Agent) chooseTeamHandles(ctx context.Context, title, model string) { + profile := a.config.teamProfile() + if profile == "" { + return + } + if !rolesWantHandle(a.teamRoles()) { + return + } + choices := a.askForHandle(ctx, title, model) + if len(choices) == 0 || ctx.Err() != nil { + return + } + a.team.mu.Lock() + keys := a.teamKeysLocked() + a.team.mu.Unlock() + file, err := teams.Load(profile) + if err != nil { + return + } + for _, role := range rolesFor(file, keys, a.teamDefaults(profile)) { + if !role.derived { + continue + } + var old, now string + err := teams.Update(profile, func(f *teams.File) error { + // Made again under the store's lock, against the file as it is now: + // a person may have typed a handle since the roles were read. + var err error + old, now, err = f.ChooseHandle(role.id, role.key, choices, title) + return err + }) + if err != nil || old == "" || now == old { + continue + } + _ = teams.AppendTraffic(profile, role.id, handleRenameEntry(old, now)) + } +} + +// handleRenameEntry is the Traffic line that says a member's handle changed. +// It names no member key, so it is never read as the member's own state +// ([askingFromEvents] reads the newest event about a member). +func handleRenameEntry(old, now string) teams.Entry { + return teams.Entry{ + Kind: teams.KindEvent, + From: teams.FromSystem, + To: teams.ToEveryone, + Text: "@" + old + " is now @" + now, + } +} + +// askForHandle is one question for the words. A transient failure, a timeout or +// the network, is asked once more after [handleRetryWait]. A refusal is not, +// and neither is an answer that names nothing: the guess already stands, and a +// model that will not answer leaves it. A later turn does not ask again +// ([Agent.chooseTeamHandlesLater] asks once per process). +func (a *Agent) askForHandle(ctx context.Context, title, model string) []string { + choices, err := a.askForHandleOnce(ctx, title, model) + if len(choices) > 0 || !handleMayRetry(ctx, err) { + return choices + } + if handleBackoff(ctx, handleRetryWait) != nil { + return nil + } + choices, _ = a.askForHandleOnce(ctx, title, model) + return choices +} + +// askForHandleOnce is one call for the words. +func (a *Agent) askForHandleOnce(ctx context.Context, title, model string) ([]string, error) { + callCtx, cancel := context.WithTimeout(ctx, titleAskWindow) + defer cancel() + ask := "Conversation title:\n" + clip(title, titleClip) + "\n\n" + handleAsk + response, named, err := a.callRoleChecked(callCtx, roles.RoleTitle, model, + []ai.Message{textMessage("system", titleSystem), textMessage("user", ask)}, + func(response *ai.Response, named string) bool { + if len(cleanHandleChoices(response.Text())) > 0 { + return true + } + a.addDetachedUsageAs(response, named, 1, auxRoleTitle) + return false + }, ai.WithMaxTokens(handleTokens)) + if err != nil || response == nil { + return nil, err + } + a.addDetachedUsageAs(response, named, 1, auxRoleTitle) + return cleanHandleChoices(response.Text()), nil +} + +// handleMayRetry reports whether one failed handle ask may be tried again. +// A cancelled errand is not a failure, and a refusal is the provider saying no +// to the same question. +func handleMayRetry(ctx context.Context, err error) bool { + if err == nil || ctx.Err() != nil { + return false + } + if _, refused := provider.RefusalFrom(err); refused { + return false + } + if errors.Is(err, context.DeadlineExceeded) { + return true + } + return isRetryable(err.Error()) +} + +// cleanHandleChoices is a model's answer as handle words: the first line's +// words, lowercased, with anything but letters and digits taken off, each a +// valid handle ([teams.ValidHandle]) and not one of the words the instruction +// names as work rather than a subject. It is nil when nothing usable is left. +func cleanHandleChoices(raw string) []string { + line := strings.TrimSpace(raw) + if at := strings.IndexByte(line, '\n'); at >= 0 { + line = line[:at] + } + var out []string + for _, w := range strings.FieldsFunc(strings.ToLower(line), func(r rune) bool { + return unicode.IsSpace(r) || r == ',' || r == '/' || r == '|' || r == ';' + }) { + w = strings.Map(func(r rune) rune { + if r >= 'a' && r <= 'z' || r >= '0' && r <= '9' { + return r + } + return -1 + }, w) + if teams.ValidHandle(w) != nil || handleWorkWords[w] || strings.Trim(w, "0123456789") == "" { + continue + } + if !handleSeen(out, w) { + out = append(out, w) + } + if len(out) == handleChoices { + break + } + } + return out +} + +// handleWorkWords are words a handle may not be, because they name the kind of +// work or the conversation itself rather than what it is about; a small model +// that echoes the instruction answers with them. +var handleWorkWords = map[string]bool{ + "review": true, "reviewing": true, "fix": true, "update": true, "updates": true, + "session": true, "research": true, "conversation": true, "handle": true, + "subject": true, "word": true, "words": true, "the": true, "one": true, "not": true, +} + +func handleSeen(list []string, w string) bool { + for _, have := range list { + if have == w { + return true + } + } + return false +} diff --git a/internal/session/handlepick_test.go b/internal/session/handlepick_test.go new file mode 100644 index 0000000000..eac9a5d8a3 --- /dev/null +++ b/internal/session/handlepick_test.go @@ -0,0 +1,351 @@ +package session + +import ( + "context" + "errors" + "os" + "path/filepath" + "strings" + "sync" + "testing" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/provider" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// handleModel is a fake title model for the handle ask: it answers with the +// words given for the title it is shown, and counts the asks. +type handleModel struct { + mu sync.Mutex + words map[string]string + asks int +} + +func (h *handleModel) aside(messages []ai.Message) (*ai.Response, bool) { + if !isTitleCall(messages) { + return nil, false + } + last := messageContentText(messages[len(messages)-1]) + if !strings.Contains(last, handleAsk) { + return textResponse(""), true + } + h.mu.Lock() + defer h.mu.Unlock() + h.asks++ + for title, words := range h.words { + if strings.Contains(last, title) { + return textResponse(words), true + } + } + return textResponse(""), true +} + +func (h *handleModel) count() int { + h.mu.Lock() + defer h.mu.Unlock() + return h.asks +} + +// handleFixture is a team, test, of three conversations with the titles the +// manager made @review, @reviewing and @session of, written by a build that +// did not keep who chose a handle, plus one member whose handle was typed. +type handleFixture struct { + profile string + teamID string + paths map[string]string // by legacy handle +} + +var handleTitles = map[string]string{ + "review": "santosh dev2 branch code complexity & security review", + "reviewing": "CodeAF repo issue tags & milestones", + "session": "quantum gravity research updates / session monitor", + "lexer": "rewrite the lexer", +} + +func newHandleFixture(t *testing.T) handleFixture { + t.Helper() + root := t.TempDir() + f := handleFixture{profile: filepath.Join(root, "profile"), teamID: teams.NewID(), paths: map[string]string{}} + var members []teams.Member + for _, handle := range []string{"review", "reviewing", "session", "lexer"} { + dir := filepath.Join(root, "sessions", handle) + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + path := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(path, nil, 0o600); err != nil { + t.Fatal(err) + } + f.paths[handle] = path + m := teams.Member{Key: convKeyOf(t, path), File: path, Word: handleTitles[handle], Handle: handle} + if handle == "lexer" { + m.HandleBy = teams.HandleByTyped + } + members = append(members, m) + } + // Written whole, as the older build wrote it: no handle_by on the three. + err := teams.Save(f.profile, []teams.Team{{ID: f.teamID, Name: "test", Members: members}}) + if err != nil { + t.Fatal(err) + } + return f +} + +func (f handleFixture) member(t *testing.T, handle string) teams.Member { + t.Helper() + file, err := teams.Load(f.profile) + if err != nil { + t.Fatal(err) + } + m, ok := file.Teams[0].Member(convKeyOf(t, f.paths[handle])) + if !ok { + t.Fatalf("no member for %s", handle) + } + return m +} + +func (f handleFixture) traffic(t *testing.T) []string { + t.Helper() + entries, err := teams.ReadTraffic(f.profile, f.teamID, teamLogStart, 0) + if err != nil { + t.Fatal(err) + } + var out []string + for _, e := range entries { + out = append(out, e.Kind+" "+e.From+" "+e.To+" "+e.Text) + } + return out +} + +// handleAgent is the conversation that was @<handle>, titled already, with the +// fake model behind it. +func handleAgent(t *testing.T, f handleFixture, handle string, model *handleModel) *Agent { + t.Helper() + completer := &scriptedCompleter{aside: model.aside} + agent, _ := newTestAgent(t, completer, func(config *Config) { + config.ProfileDir = f.profile + config.SessionFile = f.paths[handle] + config.Place = Place{Dir: filepath.Dir(f.paths[handle])} + }) + agent.mu.Lock() + agent.title = handleTitles[handle] + agent.mu.Unlock() + return agent +} + +// THE ONE-TIME PASS, WITH THE REAL TITLES. Each conversation that already had a +// title and a guessed handle has its handle chosen by the model on its next +// turn, once: @review becomes @security, @reviewing @milestones and @session +// @gravity, each rename is said to everyone in the team's Traffic, and a second +// turn asks nothing more. +func TestTheTitleModelChoosesOneWordHandlesOnce(t *testing.T) { + f := newHandleFixture(t) + model := &handleModel{words: map[string]string{ + handleTitles["review"]: "security complexity branch", + handleTitles["reviewing"]: "Milestones, tags, issues", + handleTitles["session"]: "gravity quantum monitor", + }} + want := map[string]string{"review": "security", "reviewing": "milestones", "session": "gravity"} + for _, old := range []string{"review", "reviewing", "session"} { + agent := handleAgent(t, f, old, model) + submitAndWait(t, agent, "carry on") + agent.titleJobs.Wait() + submitAndWait(t, agent, "and again") + agent.titleJobs.Wait() + m := f.member(t, old) + if m.Handle != want[old] || m.HandleBy != teams.HandleByModel { + t.Errorf("@%s became %+v, want @%s chosen by the model", old, m, want[old]) + } + } + if got := model.count(); got != 3 { + t.Errorf("the model was asked %d times for three conversations", got) + } + log := strings.Join(f.traffic(t), "\n") + for _, line := range []string{ + "event system everyone @review is now @security", + "event system everyone @reviewing is now @milestones", + "event system everyone @session is now @gravity", + } { + if !strings.Contains(log, line) { + t.Errorf("the Traffic lacks %q:\n%s", line, log) + } + } +} + +// A HANDLE THAT WAS TYPED IS NEVER REPLACED, and nothing is asked for it. +func TestATypedHandleIsNeverAskedAbout(t *testing.T) { + f := newHandleFixture(t) + model := &handleModel{words: map[string]string{handleTitles["lexer"]: "parser tokens grammar"}} + agent := handleAgent(t, f, "lexer", model) + submitAndWait(t, agent, "carry on") + agent.titleJobs.Wait() + if m := f.member(t, "lexer"); m.Handle != "lexer" || m.HandleBy != teams.HandleByTyped { + t.Fatalf("a typed handle changed: %+v", m) + } + if model.count() != 0 || len(f.traffic(t)) != 0 { + t.Fatalf("a typed handle was asked about: %d asks, traffic %v", model.count(), f.traffic(t)) + } +} + +// A CLASH TAKES THE MODEL'S SECOND WORD. The conversation that was @session +// answers "security" first, which @review already became. +func TestAHandleClashTakesTheSecondWord(t *testing.T) { + f := newHandleFixture(t) + model := &handleModel{words: map[string]string{ + handleTitles["review"]: "security", + handleTitles["session"]: "security gravity", + }} + for _, old := range []string{"review", "session"} { + agent := handleAgent(t, f, old, model) + agent.chooseTeamHandles(context.Background(), handleTitles[old], "test/model") + } + if got := f.member(t, "session").Handle; got != "gravity" { + t.Fatalf("the clash took %q", got) + } +} + +// THE RENAME REACHES EVERYONE, the manager included, as codeaf's line. +func TestTheRenameIsToldToTheManagerAndTheMembers(t *testing.T) { + entry := handleRenameEntry("review", "security") + for _, role := range []teamRole{{name: "test", handle: "gravity"}, {name: "test", handle: "boss", manager: true, managed: true}} { + if got := teamLine(role, entry); got != "from codeaf: @review is now @security" { + t.Errorf("manager %v is told %q", role.manager, got) + } + } + if entry.Member != "" { + t.Error("the rename names a member, and would be read as its state") + } +} + +// AN ANSWER IS READ FOR ONE-WORD HANDLES AND NOTHING ELSE. +func TestCleanHandleChoices(t *testing.T) { + for raw, want := range map[string]string{ + "security complexity branch": "security complexity branch", + "Milestones, tags, issues": "milestones tags issues", + "**gravity**\nbecause physics": "gravity", + "review session research": "", + "x manager everyone": "", + "api-docs": "apidocs", + "": "", + } { + if got := strings.Join(cleanHandleChoices(raw), " "); got != want { + t.Errorf("cleanHandleChoices(%q) = %q, want %q", raw, got, want) + } + } +} + +// flakyHandle is a title model that fails its first handle asks, then answers. +type flakyHandle struct { + mu sync.Mutex + left int + err error + words string + asks int +} + +func (f *flakyHandle) CompleteWithMessages(ctx context.Context, messages []ai.Message, _ ...ai.Option) (*ai.Response, error) { + last := "" + if len(messages) > 0 { + last = messageContentText(messages[len(messages)-1]) + } + if !strings.Contains(last, handleAsk) { + return textResponse("ok"), nil + } + f.mu.Lock() + defer f.mu.Unlock() + f.asks++ + if f.left > 0 { + f.left-- + return nil, f.err + } + return textResponse(f.words), nil +} + +func (f *flakyHandle) count() int { + f.mu.Lock() + defer f.mu.Unlock() + return f.asks +} + +// A TRANSIENT FAILURE IS ASKED ONCE MORE. The first call times out, the second +// answers, and a later turn does not ask again: still one question per title. +func noHandleWait(t *testing.T) { + t.Helper() + prev := handleBackoff + handleBackoff = func(ctx context.Context, _ time.Duration) error { return ctx.Err() } + t.Cleanup(func() { handleBackoff = prev }) +} + +func TestAHandleAskRetriesOnceAfterATimeout(t *testing.T) { + noHandleWait(t) + f := newHandleFixture(t) + model := &flakyHandle{left: 1, err: context.DeadlineExceeded, words: "security"} + agent, _ := newTestAgent(t, model, func(config *Config) { + config.ProfileDir = f.profile + config.SessionFile = f.paths["review"] + config.Place = Place{Dir: filepath.Dir(f.paths["review"])} + }) + agent.mu.Lock() + agent.title = handleTitles["review"] + agent.mu.Unlock() + submitAndWait(t, agent, "carry on") + agent.titleJobs.Wait() + if m := f.member(t, "review"); m.Handle != "security" || m.HandleBy != teams.HandleByModel { + t.Fatalf("a timeout then an answer left %+v", m) + } + if got := model.count(); got != 2 { + t.Fatalf("the model was asked %d times, want one retry", got) + } + submitAndWait(t, agent, "and again") + agent.titleJobs.Wait() + if got := model.count(); got != 2 { + t.Fatalf("a second turn asked again: %d asks", got) + } +} + +// A REFUSAL IS NOT ASKED AGAIN. The guess stands. +func TestAHandleAskRetriesOnceAfterANetworkFailure(t *testing.T) { + noHandleWait(t) + f := newHandleFixture(t) + model := &flakyHandle{left: 1, err: errors.New("read: connection reset by peer"), words: "gravity"} + agent, _ := newTestAgent(t, model, func(config *Config) { + config.ProfileDir = f.profile + config.SessionFile = f.paths["session"] + config.Place = Place{Dir: filepath.Dir(f.paths["session"])} + }) + agent.mu.Lock() + agent.title = handleTitles["session"] + agent.mu.Unlock() + submitAndWait(t, agent, "carry on") + agent.titleJobs.Wait() + if m := f.member(t, "session"); m.Handle != "gravity" { + t.Fatalf("a dropped connection then an answer left %+v", m) + } + if got := model.count(); got != 2 { + t.Fatalf("the model was asked %d times, want one retry", got) + } +} + +func TestAHandleAskDoesNotRetryARefusal(t *testing.T) { + noHandleWait(t) + f := newHandleFixture(t) + model := &flakyHandle{left: 2, err: &provider.APIError{Status: 400, Message: "invalid request body"}, words: "security"} + agent, _ := newTestAgent(t, model, func(config *Config) { + config.ProfileDir = f.profile + config.SessionFile = f.paths["review"] + config.Place = Place{Dir: filepath.Dir(f.paths["review"])} + }) + agent.mu.Lock() + agent.title = handleTitles["review"] + agent.mu.Unlock() + submitAndWait(t, agent, "carry on") + agent.titleJobs.Wait() + if m := f.member(t, "review"); m.Handle != "review" { + t.Fatalf("a refusal replaced the guess: %+v", m) + } + if got := model.count(); got != 1 { + t.Fatalf("a refusal was asked %d times, want 1", got) + } +} diff --git a/internal/session/loop.go b/internal/session/loop.go index 1dc25ecc5f..5315cafe01 100644 --- a/internal/session/loop.go +++ b/internal/session/loop.go @@ -482,6 +482,20 @@ func (a *Agent) runTurn(ctx context.Context, hub *eventHub, user userMessage) bo } defer elsewhere.end() + // AND, FOR A MANAGER, THE TEAM IT MANAGES (team.go), on the same terms and + // the same door as the block above: members' journals and the team's + // Traffic are disk, read beside the work, and a digest that lands after the + // first request rides the next step. A conversation with no profile and a + // task node start no reading at all. + var team *sidecar[struct{}] + if a.config.teamProfile() != "" { + team = readBeside(ctx, func(read context.Context) struct{} { + a.refreshTeamDigest(read) + return struct{}{} + }, nil) + } + defer team.end() + // partial accumulates what the model has streamed for the CURRENT step. // It is the transcript's answer for an interrupted step, where no response // ever comes back. @@ -3710,6 +3724,9 @@ var glossField = map[string]string{ // The settings read is the row it went to look at, and a call with no key // at all is the whole sheet, which reads honestly as its bare name. "settings": "key", + // A manager's look at one member, and the member a stop is aimed at. + "team_read": "handle", + "team_stop": "handle", } // glossFields is [glossField] for the calls where ONE argument is not enough to @@ -3731,6 +3748,15 @@ var glossFields = map[string][]string{ // and the whole of what they are agreeing to is which row and what it // becomes. "change_setting": {"key", "value"}, + // A line into a team is who it goes to and what it says. A start is not + // here: it reads as its own sentence ([teamStartGloss]). + "team_send": {"to", "text"}, + "team_post": {"to", "text"}, + // A packet is its id and what was done with it. + "team_decide": {"packet", "answer"}, + "team_escalate": {"packet", "to"}, + "team_close_report": {"done"}, + "team_raise": {"question"}, } // gloss renders one call as a person-readable line: the tool name and the one @@ -3786,6 +3812,11 @@ func control(r rune) bool { return r < ' ' || r == 0x7f } func glossOf(call ai.ToolCall) string { name := call.Function.Name + if name == teamStartToolName { + if said := teamStartGloss(call.Function.Arguments); said != "" { + return said + } + } fields, known := glossFields[name] if !known { field, single := glossField[name] diff --git a/internal/session/mention.go b/internal/session/mention.go new file mode 100644 index 0000000000..ee533a6222 --- /dev/null +++ b/internal/session/mention.go @@ -0,0 +1,256 @@ +package session + +import ( + "path/filepath" + "strings" + "time" + "unicode/utf8" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// mentionTeamBudget and mentionChatBudget are how much of one reference the +// model is handed. A team is a short digest (members, handles, states, the +// recent traffic). A chat is its title, its state and an excerpt of its last +// reply, never the transcript. Both are rune budgets, the same cut the team +// digest already uses. +const ( + mentionTeamBudget = 800 + mentionChatBudget = 1536 + mentionReplyRunes = 400 +) + +// mentionNote is the block Submit appends when the person's words name a team +// or a conversation. It reads. It never messages, and it never wakes: no +// teamRouse, no AppendTraffic, no Submit on the conversation it names. +func (a *Agent) mentionNote(text string) string { + if a == nil || (!strings.Contains(text, "●") && !strings.Contains(text, "@")) { + return "" + } + teams, chats := mentionTokens(text) + if len(teams) == 0 && len(chats) == 0 { + return "" + } + profile := a.config.teamProfile() + bucket := mentionBucket(a.config) + self := a.config.transcriptPath() + now := time.Now() + var blocks []string + seenTeam := map[string]bool{} + for _, slug := range teams { + if seenTeam[slug] { + continue + } + seenTeam[slug] = true + if block := mentionTeamBlock(profile, self, slug, now); block != "" { + blocks = append(blocks, block) + } + } + seenChat := map[string]bool{} + for _, token := range chats { + if seenChat[token] { + continue + } + seenChat[token] = true + if block := mentionChatBlock(profile, bucket, self, token, now); block != "" { + blocks = append(blocks, block) + } + } + return strings.Join(blocks, "\n\n") +} + +func mentionTeamBlock(profile, self, slug string, now time.Time) string { + if profile == "" { + return "" + } + file, err := teams.Load(profile) + if err != nil || file == nil || len(file.Teams) == 0 { + return "" + } + var team teams.Team + found := false + for _, t := range file.Teams { + if TaskSlug(t.Name) == slug { + team, found = t, true + break + } + } + if !found { + return "" + } + log, _ := teams.ReadTraffic(profile, team.ID, "", 40) + states := map[string]teams.MemberState{} + for _, m := range team.Members { + if m.Key == self || m.File == self { + states[m.Key] = teams.MemberState{State: teams.StateRunning} + continue + } + if st, ok := journalState(m.File, now); ok { + states[m.Key] = st + } + } + body := teams.Digest(team, states, recentOf(log), mentionTeamBudget) + return "Team reference (" + team.Name + "):\n" + body +} + +func mentionChatBlock(profile, bucket, self, token string, now time.Time) string { + chat, ok := mentionFindChat(profile, bucket, self, token) + if !ok { + return "" + } + var b strings.Builder + b.WriteString("Chat reference (@") + b.WriteString(token) + b.WriteString("):\n") + if chat.title != "" { + b.WriteString("Title: ") + b.WriteString(chat.title) + b.WriteByte('\n') + } + if st, ok := journalState(chat.file, now); ok && st.State != "" { + b.WriteString("State: ") + b.WriteString(st.State) + b.WriteByte('\n') + } + if chat.reply != "" { + b.WriteString("Last reply: ") + b.WriteString(chat.reply) + b.WriteByte('\n') + } + return mentionCut(strings.TrimRight(b.String(), "\n"), mentionChatBudget) +} + +type mentionChatHit struct { + file, title, reply string +} + +func mentionFindChat(profile, bucket, self, token string) (mentionChatHit, bool) { + if profile != "" { + if file, err := teams.Load(profile); err == nil && file != nil { + for _, t := range file.Teams { + for _, m := range t.Members { + if m.File == self || m.Key == self { + continue + } + if mentionNames(token, m.Handle, m.Word) { + return mentionHit(m.File, m.Word), true + } + } + } + } + } + if bucket == "" { + return mentionChatHit{}, false + } + for _, row := range RecentSessions(bucket, 48) { + file := row.File + if file == self || file == "" { + continue + } + if mentionNames(token, "", row.Title) { + return mentionHit(file, row.Title), true + } + } + return mentionChatHit{}, false +} + +func mentionNames(token, handle, title string) bool { + token = strings.ToLower(strings.TrimSpace(token)) + if token == "" { + return false + } + if handle != "" && strings.EqualFold(handle, token) { + return true + } + return TaskSlug(title) == token +} + +func mentionHit(file, title string) mentionChatHit { + hit := mentionChatHit{file: file, title: strings.TrimSpace(title)} + sum, ok := Peek(file) + if !ok { + return hit + } + if hit.title == "" { + hit.title = strings.TrimSpace(sum.Title) + } + hit.reply = mentionCut(oneLine(sum.LastAssistant), mentionReplyRunes) + return hit +} + +func mentionBucket(c Config) string { + if dir := strings.TrimSpace(c.Place.Dir); dir != "" { + return filepath.Dir(dir) + } + file := strings.TrimSpace(c.SessionFile) + if file == "" { + return "" + } + dir := filepath.Dir(file) + if filepath.Base(file) == placeTranscript { + return filepath.Dir(dir) + } + return dir +} + +func mentionTokens(text string) (teamSlugs, chatTokens []string) { + const bullet = "●" + for i := 0; i < len(text); i++ { + if strings.HasPrefix(text[i:], bullet) && (i == 0 || !mentionWord(text[i-1])) { + j := i + len(bullet) + for j < len(text) && (mentionWord(text[j]) || text[j] == '-') { + j++ + } + slug := strings.ToLower(text[i+len(bullet) : j]) + if slug != "" { + teamSlugs = append(teamSlugs, slug) + } + i = j - 1 + continue + } + if text[i] != '@' || (i > 0 && (mentionWord(text[i-1]) || text[i-1] == '.' || text[i-1] == '@')) { + continue + } + j := i + 1 + for j < len(text) && (mentionWord(text[j]) || text[j] == '-' || text[j] == ':' || text[j] == '/') { + j++ + } + token := text[i+1 : j] + if token == "" || strings.Contains(token, "/") { + i = j - 1 + continue + } + low := strings.ToLower(token) + if strings.HasPrefix(low, "team:") || strings.HasPrefix(low, "file:") { + i = j - 1 + continue + } + low = strings.TrimPrefix(low, "chat:") + if low != "" { + chatTokens = append(chatTokens, low) + } + i = j - 1 + } + return teamSlugs, chatTokens +} + +func mentionWord(b byte) bool { + return b == '_' || b == '-' || + (b >= '0' && b <= '9') || + (b >= 'A' && b <= 'Z') || + (b >= 'a' && b <= 'z') +} + +func mentionCut(s string, budget int) string { + if budget <= 0 || utf8.RuneCountInString(s) <= budget { + return s + } + n := 0 + for i := range s { + if n == budget-1 { + return s[:i] + "…" + } + n++ + } + return s +} diff --git a/internal/session/mention_test.go b/internal/session/mention_test.go new file mode 100644 index 0000000000..25e57e469d --- /dev/null +++ b/internal/session/mention_test.go @@ -0,0 +1,112 @@ +package session + +import ( + "context" + "os" + "path/filepath" + "strings" + "testing" + "unicode/utf8" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/teams" +) + +func TestMentionDigestIsAttachedBoundedAndDoesNotWake(t *testing.T) { + fixture := newTeamFixture(t, true) + lonerDir := filepath.Join(filepath.Dir(filepath.Dir(fixture.manager)), "loner") + if err := os.MkdirAll(lonerDir, 0o700); err != nil { + t.Fatal(err) + } + loner := filepath.Join(lonerDir, placeTranscript) + reply := strings.Repeat("the parser said this. ", 40) + body := strings.Join([]string{ + `{"type":"title","title":"side chat"}`, + `{"type":"message","role":"user","content":"how is the port","timestamp":"2026-09-01T10:00:01Z"}`, + `{"type":"message","role":"assistant","content":"` + reply + `","timestamp":"2026-09-01T10:00:02Z"}`, + }, "\n") + "\n" + if err := os.WriteFile(loner, []byte(body), 0o600); err != nil { + t.Fatal(err) + } + for i := 0; i < 12; i++ { + appendTraffic(t, fixture, teams.Entry{ + Kind: teams.KindNote, From: "parser", To: teams.ToEveryone, + Text: strings.Repeat("traffic line. ", 20), + }) + } + + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { + return textResponse("noted"), nil + }, + }} + agent := teamAgent(t, fixture, fixture.manager, completer, nil) + quiet := []string{fixture.parser, fixture.web, loner, teams.TrafficPath(fixture.profile, fixture.teamID)} + beforeQuiet := map[string]string{} + for _, path := range quiet { + beforeQuiet[path] = string(mustRead(t, path)) + } + said := "see ●harbor and @parser and @side-chat" + note := agent.mentionNote(said) + if note == "" { + t.Fatal("the mention produced no digest") + } + if !strings.Contains(note, "Team reference (harbor)") || !strings.Contains(note, "@parser") || !strings.Contains(note, "side chat") { + t.Fatalf("the digest is missing a reference:\n%s", note) + } + if strings.Contains(note, reply) { + t.Fatal("the digest carried the whole reply") + } + for _, block := range strings.Split(note, "\n\n") { + budget := mentionChatBudget + if strings.HasPrefix(block, "Team reference") { + budget = mentionTeamBudget + len("Team reference (harbor):\n") + } + if utf8.RuneCountInString(block) > budget { + t.Fatalf("a reference ran to %d runes:\n%s", utf8.RuneCountInString(block), block[:80]) + } + } + for _, path := range quiet { + if got := string(mustRead(t, path)); got != beforeQuiet[path] { + t.Fatalf("building the digest wrote %s", path) + } + } + + collect(t, mustSubmit(t, agent, said)) + var model string + for _, message := range agent.messages { + text := messageContentText(message) + if strings.Contains(text, "Team reference") { + model = text + } + } + if model == "" || !strings.Contains(model, said) { + t.Fatal("the model was not handed the words and the digest") + } + journal, err := os.ReadFile(fixture.manager) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(journal), said) || strings.Contains(string(journal), "Team reference") { + t.Fatal("the journal did not keep the words without the digest") + } + for _, path := range quiet { + if got := string(mustRead(t, path)); got != beforeQuiet[path] { + t.Fatalf("sending the mention wrote %s", path) + } + } + + cut := mentionCut(strings.Repeat("あ", mentionChatBudget+40), mentionChatBudget) + if utf8.RuneCountInString(cut) != mentionChatBudget { + t.Fatalf("the chat budget cut to %d", utf8.RuneCountInString(cut)) + } +} + +func mustRead(t *testing.T, path string) []byte { + t.Helper() + b, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + return b +} diff --git a/internal/session/place.go b/internal/session/place.go index 4feed470ae..9988d4b93b 100644 --- a/internal/session/place.go +++ b/internal/session/place.go @@ -47,6 +47,10 @@ const ( placeTrees = "trees" placeWork = "work" placeArtifacts = "artifacts" + // placeTeamCursors is how far into each of its teams' Traffic this + // conversation has read (team.go). It is .json, so neither conversation + // scan can take it for a transcript. + placeTeamCursors = "team.json" ) // Place names every location one v3 session may touch on disk. diff --git a/internal/session/placemeta.go b/internal/session/placemeta.go index 14ca37c865..7372390d38 100644 --- a/internal/session/placemeta.go +++ b/internal/session/placemeta.go @@ -112,6 +112,7 @@ func (a *Agent) SettleWrites() { a.toldStamp().settle() a.fixShelfFor().settle() a.treesAhead().Settle() + a.settleTeamEvents() } // stampWriter is [offpath.Write] with the patch it is to perform carried beside diff --git a/internal/session/question.go b/internal/session/question.go index 073183c80c..1756028673 100644 --- a/internal/session/question.go +++ b/internal/session/question.go @@ -2029,6 +2029,10 @@ func (a *Agent) ResolveQuestion(answer Answer) error { // record for the same law. if said || (landingSaid && strings.TrimSpace(q.Head) != "") { a.recordDecision(decisionRecordOf(q, answer)) + // THE COMPLETION CHECK READS THIS, NOT THE TOOL RESULT. A digest clips + // results, and "nothing was set up" then reads as work still owed. The + // person's own answer is what closes that gap (checkpoint.go). + a.rememberPersonCardAnswer(q, answer) } if said { a.rememberOverride(q, answer) diff --git a/internal/session/recentplace.go b/internal/session/recentplace.go index 82c9a547ca..340531bcd1 100644 --- a/internal/session/recentplace.go +++ b/internal/session/recentplace.go @@ -91,6 +91,9 @@ func RecentSessions(dir string, limit int) []Summary { if !ok { continue } + // Peek records the path it opened. The listing sets it again so the + // path a mention resolves is the transcript this walk opened. + summary.File = file.file if title := strings.TrimSpace(file.meta.Title); title != "" { summary.Title = title } diff --git a/internal/session/session.go b/internal/session/session.go index 32ac525bee..118f0592c1 100644 --- a/internal/session/session.go +++ b/internal/session/session.go @@ -2652,6 +2652,11 @@ type Agent struct { // landingOutcomes are owed landing reports returned in this turn. They are // completion evidence, not another part of the person's ask. landingOutcomes []string + // personCardAnswers are the compact lines for cards a person answered + // during THIS turn (checkpoint.go's [personCardAnswerLine]). Cleared when + // the next turn opens, with the owed asks, because a later turn is not + // still bound by a card this one already settled. + personCardAnswers []string // turnResults are the tasks whose RESULTS ARRIVED IN THIS TURN, by id, in // arrival order and cleared with owedAsks when a turn opens. // @@ -2785,7 +2790,20 @@ type Agent struct { // block would name a landing on one turn and forget it on the next — // see [deltaRemember]. elsewhereTold []deltaLanding - usage Usage + // teamDigestText is the team note's block (team.go): the digest of every + // team this conversation manages, "" for one that manages none. It sits + // under mu and rides its own note at the tail, like elsewhereText, so an + // unchanged team lands no second note. + teamDigestText string + // teamRoleText is what this conversation is in its teams (team.go's + // [teamRoleBlock]), set at every step boundary before the request and + // landed in a note of its own ahead of the others. + teamRoleText string + // team is this conversation's account of its teams: its key, its roles and + // its Traffic cursors (team.go). It has its own lock and is never read + // under mu. + team teamSeat + usage Usage // principal is WHO THIS SESSION IS WORKING FOR (principal.go), and it is // never nil: a session built with no posture at all gets a [Person], which // answers every question the way this package answered it before the diff --git a/internal/session/standing_test.go b/internal/session/standing_test.go index 5b628218d1..127d53bdf3 100644 --- a/internal/session/standing_test.go +++ b/internal/session/standing_test.go @@ -590,8 +590,19 @@ func TestStandingOnceCreatesNothing(t *testing.T) { if len(store.created) != 0 { t.Fatalf("a once answer created %d items", len(store.created)) } - if output := toolOutput(t, collected, "stand"); !strings.Contains(output, "do it once, now, as an ordinary turn") { - t.Fatalf("tool result = %q", output) + output := toolOutput(t, collected, "stand") + for _, want := range []string{ + "Do it now as an ordinary step and report what happened.", + "The person chose not to repeat it.", + "Do not set it up again unless they ask.", + "Do not investigate codeaf.", + } { + if !strings.Contains(output, want) { + t.Errorf("tool result missing %q\n%s", want, output) + } + } + if strings.Contains(output, "\u2014") || strings.Contains(output, "\u2013") { + t.Errorf("tool result still has a dash: %q", output) } } @@ -1751,15 +1762,14 @@ func TestAOneOffReminderOffersNoOnce(t *testing.T) { } } -// AND EVERYWHERE ELSE IT KEEPS IT: a watch, a rule, a routine and overnight -// work are all things a person may reasonably want done once, now. -func TestEverythingButAOneOffReminderKeepsOnce(t *testing.T) { +// A WATCH AND A CADENCE KEEP ONCE. A reminder has nothing to do now that is +// different from reminding, and a rule never runs, so neither offers it. +func TestAWatchAndACadenceKeepOnce(t *testing.T) { for _, item := range []standing.Item{ {When: standing.When{Kind: standing.WhenProbe}, Does: standing.Action{Kind: standing.ActionSay}}, {When: standing.When{Kind: standing.WhenEvery}, Does: standing.Action{Kind: standing.ActionTask}}, {When: standing.When{Kind: standing.WhenFile}, Does: standing.Action{Kind: standing.ActionTask}}, {When: standing.When{Kind: standing.WhenIdle}, Does: standing.Action{Kind: standing.ActionTask}}, - {When: standing.When{Kind: standing.WhenAt}, Does: standing.Action{Kind: standing.ActionTask}}, } { if !StandingOnceIsAnAnswer(item) { t.Fatalf("%s/%s lost its `once` answer", item.When.Kind, item.Does.Kind) diff --git a/internal/session/taskpresence.go b/internal/session/taskpresence.go index b8b15c3abd..dc87e1b2e3 100644 --- a/internal/session/taskpresence.go +++ b/internal/session/taskpresence.go @@ -667,12 +667,18 @@ func (a *Agent) presenceAskingOptions(kind QuestionKind, id uint64, text string, // question through the one door. The two go up and come down together, because a // lane that stopped waiting has stopped asking, and a window still drawing the // question would be offering a key the session would drop. +// +// AND A TEAM MEMBER'S MANAGER IS TOLD IT IS WAITING, for the same reason home +// is: every question that holds a turn comes through here, so this is the one +// place a member's asking event can be raised and taken down ([Agent.teamAsking]). func (a *Agent) presenceAskingWhole(q Question, announce func()) func() { forgetDesk := a.presenceAskingQuestion(q) letGo := a.raiseQuestion(q, announce) + teamDown := a.teamAsking(q) return func() { forgetDesk() letGo() + teamDown() } } diff --git a/internal/session/team.go b/internal/session/team.go new file mode 100644 index 0000000000..da539298ae --- /dev/null +++ b/internal/session/team.go @@ -0,0 +1,1445 @@ +package session + +// A CONVERSATION IN A TEAM: who it is there, what it is told, and what it is +// shown. +// +// internal/teams is the one store for teams (teams.json) and for the Traffic a +// team's members and manager write to each other (teams/<id>/traffic.jsonl). +// The conversations view writes it from the interface; this file is the other +// reader and writer, the session's half, and the two meet ONLY through that +// store. Nothing here calls into the interface and nothing there calls in here +// for a team feature, which is what lets either side restart, run on another +// build, or not be running at all without the other losing a message. +// +// THREE THINGS LIVE HERE, and each has one door: +// +// - IDENTITY ([Agent.teamRoles]). A conversation finds its teams by its own +// conversation key, which is the key the interface stores a member under: +// the transcript's path, cleaned and with its symlinks resolved (tui3's +// convKey, detach.go). Both spellings are kept, cleaned and resolved, because +// a hosted surface keys an engine's path by its cleaned spelling alone and +// /tmp against /private/tmp is one file with two names on a Mac. The manager +// is the member whose key is Team.Manager. +// - DELIVERY ([Agent.teamBoundary]). At every step boundary, the one legal place a +// user-role line may join a turn (agent.go's [Agent.drainSteering]), what was +// addressed to this conversation since its cursor is put in front of the +// model as ONE marked note: "◆ from manager: …", "from @web: …". It is the +// session's line and never the person's, and it is journaled as a note so +// a reopened page draws it in the harness's lane. The boundary itself +// starts no turn; the lines that ask for an answer (a directive to a +// member, a reply to the manager) wake an idle conversation through the +// traffic watch (team_wakewatch.go), which hands them over by this door. +// - THE ROLE ([teamRoleBlock]). What this conversation IS in each team, the +// manager of it with its members named and its three laws, or a member +// under a manager with its handle and its verb, rides a note of its own +// ([teamRoleNoteOpening]) worded as codeaf's instruction. It is composed +// from the same read the boundary makes before the request, so it is in +// front of the model from the first request a conversation sends as a +// manager, and never waits on a read beside the work. +// - THE DIGEST ([Agent.refreshTeamDigest]). A manager's turn carries +// [teams.Digest] for its team in a note of its own at the tail of the +// transcript ([teamNoteOpening]). It is read beside the work at the start +// of a turn, the way the other windows' block is (taskdelta.go), and never +// carries a member's transcript. +// +// WHO IS NEVER IN A TEAM. A task node, a worker and an auditor are not +// conversations anybody put in a team: their keys are not in the file, and a +// node's brief is its whole world by contract. They are answered no before any +// disk is read ([Config.teamProfile]). +// +// AN EMPTY PROFILE DIRECTORY IS NOT ONE OF THEM. It is the ordinary launch: +// CODEAF_PROFILE_DIR is what nearly nobody exports, so the engine daemon that +// builds a conversation hands it "" and means the profile where it always is +// ([config.ProfilePath] is the one place that says so). This file once read +// "" as "no team", and that made every team feature, the verbs, the brief, +// delivery, events and the wake, dead for everybody while every test here +// passed, because every test set the directory. A test keeps off the person's +// real teams the way this package's tests keep off every other file under the +// state root: hermetic_test.go moves HOME for the run, and internal/home +// refuses a test binary the root it inherited. + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/config" + "github.com/Agent-Field/codeaf/internal/exec/bare" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// teamRole is one team this conversation is in, as teams.json says right now. +type teamRole struct { + id string + name string + // handle is this conversation's short name in the team, empty while it has + // no title to derive one from. + handle string + // manager says this conversation is the team's manager. + manager bool + // managed says the team has a manager at all, its own or, for a sub-team + // with none, the nearest one above it (boss). A member's `team_post` is + // offered only in a team that has one, because the manager is the one the + // room is run by (docs/design/conversations-and-teams/DESIGN.md, section 5). + managed bool + // boss is the managed team whose manager this membership answers to: the + // team itself when it has a manager, and otherwise the nearest open + // ancestor with one (team_nest.go's [bossOf]). A member of an unmanaged + // sub-team asks that manager its questions and posts to it; it is not + // that manager's to direct, because it is not a member of its team. + boss string + bossName string + // root says the team is the root, `All teams` (teams' root.go): its + // manager is the global manager, and its other members are the top-level + // teams' managers. + root bool + // key is the conversation key this conversation is stored under in the + // team, the one spelling of [Agent.teamKeysLocked] the file holds. An event + // this conversation writes names it ([teams.Entry.Member]). + key string + // wakes says the team's traffic starts this conversation's turn when it is + // idle: the team's effective `wake` ([teams.Effective], inherited from + // its parents and the profile's `teams.wake`; team_wakewatch.go). + wakes bool + // questionsUp is the effective `questions_up` of the team this + // conversation reports to, which is what decides where its clarifying + // questions go (team_questions.go). + questionsUp bool + // shared says this conversation is a member (not the manager) of this + // managed team but reports to a manager elsewhere (teams.File.Home): this + // team's manager is a LINK, who may read it and send it notes, and whose + // directives and stops do not reach it as its manager's. reportsTo names + // the team it reports to, for the sentence that says so. + shared bool + reportsTo string + // derived says handle is the word list's guess, which the title model + // chooses again once (handlepick.go). + derived bool +} + +// fileStamp is what a stat says about a file, and the whole of how this file +// decides a read is worth doing: a teams file or a Traffic log whose size and +// modification time have not moved has nothing new in it. present is false for +// a file that is not there. +type fileStamp struct { + size int64 + mod time.Time + present bool + read bool +} + +func stampOf(path string) fileStamp { + info, err := os.Stat(path) + if err != nil { + return fileStamp{read: true} + } + return fileStamp{size: info.Size(), mod: info.ModTime(), present: true, read: true} +} + +// teamSeat is this session's own account of its teams: its keys, the teams it +// was last found in, and how far into each team's Traffic it has read. +// +// IT HAS ITS OWN LOCK and that lock is never held with the agent's: every road +// through here reads the disk, and a disk read under a.mu is a stall for every +// surface asking this agent anything. Callers take this one, read, let go, and +// only then take a.mu to hand over what they found. +type teamSeat struct { + mu sync.Mutex + // keys are the conversation key's spellings, resolved once the transcript + // exists ([Agent.teamKeysLocked]). + keys []string + resolved bool + // teamsAt is the teams file as it was when roles was read from it, and + // configAt the profile's config.json, whose `teams.` rows the roles' + // inherited settings fall back to ([teams.DefaultsAt]); defaults is what + // was read from it. + teamsAt fileStamp + configAt fileStamp + defaults teams.Defaults + roles []teamRole + // cursors is the id of the last Traffic entry read, per team, and + // trafficAt is each log as it was when this conversation last caught up on + // it. cursorsRead says cursors has been loaded from the session folder. + cursors map[string]string + cursorsRead bool + trafficAt map[string]fileStamp + // events is the lane this conversation's own events leave by (teamevent.go). + events teamEventLane + // file is the teams file roles was read from, kept so a manager's digest + // reads the members off it rather than loading the file a second time. + file *teams.File + // journals is what each member's journal last said (teamcache.go). + journals journalCache + // watch is the wake's own reading of the Traffic, and person counts the + // turns the person started, which the wake's loop breaker is reset by + // (team_wakewatch.go). + watch teamWatch + person personTurns + // spends is each cap pool's spend as last read, against its stamp + // (team_cap.go), and wraps each managed team's wrap-up in progress + // (team_wrapup.go). + spends map[string]spendMemo + wraps map[string]*wrapUp + // claims are the sub-teams this conversation's start named it to manage, + // found by the delivery that handed it the brief and made good after it + // (team_nest.go's [Agent.claimSubTeams]). + claims []subTeamClaim + // handleTried says this process has asked for its handle once + // (handlepick.go), so it is never asked for twice. + handleTried bool + // answering is, per team, the id of the last message the manager sent + // this conversation that it was handed: a note, a directive or its brief. + // It is what a member's reply to the manager answers when it names nothing + // else, and what the events its turn raises answer (internal/teams' + // thread.go). Memory only: a conversation reopened answers nothing until + // the manager next speaks to it, which reads as a thread of its own. + answering map[string]string +} + +// teamAnsweringLocked is the id this conversation's replies in team id answer +// by default, "" for none. The caller holds a.team.mu. +func (a *Agent) teamAnsweringLocked(id string) string { return a.team.answering[id] } + +// teamAnswering is [Agent.teamAnsweringLocked] under the seat's lock. +func (a *Agent) teamAnswering(id string) string { + a.team.mu.Lock() + defer a.team.mu.Unlock() + return a.teamAnsweringLocked(id) +} + +// teamLogStart is the cursor that reads a Traffic log from its first entry: +// [teams.ReadTraffic] pages forward from an id and reads the tail from "". +const teamLogStart = "000000000000" + +// teamPageLimit is how many entries one boundary reads from one team. A log +// that has more waiting is read again at the next boundary rather than all at +// once, so a conversation away for a week is caught up a page at a time. +const teamPageLimit = 100 + +// teamFirstLook is how far back a conversation looks the first time it meets a +// team, for the one entry it is owed from before it was born: its own start +// ([Agent.firstTeamCursor]). +const teamFirstLook = 200 + +// teamStartGrace is how long before this process began a start addressed to +// this conversation may be and still be the start that made it. The interface +// opens the conversation on seeing the start, which is seconds; ten minutes is +// generous and still keeps a week-old start from replaying a week of Traffic. +const teamStartGrace = 10 * time.Minute + +// teamEntryText is how many characters of one entry's text are delivered. A +// member writing a report should write it into a file and post the path. +const teamEntryText = 4000 + +// teamProfile is the profile directory this session's teams are read from, and +// "" for a session that is never in a team (see the file comment). +// +// THE ANSWER IS RESOLVED, NEVER THE RAW FIELD. "" is this function's word for +// "never in a team", and an empty [Config.ProfileDir] is the ordinary launch's +// word for "the usual profile", so handing the field through made the two one +// word. [config.ProfilePath] with no name is the profile directory itself, +// resolved the way every other reader of the profile resolves it. +func (c Config) teamProfile() string { + if c.InTask || c.taskID != 0 { + return "" + } + if strings.TrimSpace(c.transcriptPath()) == "" { + return "" + } + return config.ProfilePath(c.ProfileDir, "") +} + +// transcriptPath is the journal this conversation is keyed by. +func (c Config) transcriptPath() string { + if path := strings.TrimSpace(c.SessionFile); path != "" { + return path + } + return c.Place.Transcript() +} + +// teamKeysLocked is this conversation's key, in both spellings. The resolved +// one needs the file to exist, so until it does the cleaned one is answered and +// the resolution is tried again next time. +func (a *Agent) teamKeysLocked() []string { + if a.team.resolved { + return a.team.keys + } + path := strings.TrimSpace(a.config.transcriptPath()) + if path == "" { + return nil + } + clean := filepath.Clean(path) + keys := []string{clean} + real, err := filepath.EvalSymlinks(clean) + if err != nil { + return keys + } + if real = filepath.Clean(real); real != clean { + keys = append(keys, real) + } + a.team.keys, a.team.resolved = keys, true + return keys +} + +// teamRoles is every team this conversation is in, read again only when the +// teams file has moved. +func (a *Agent) teamRoles() []teamRole { + profile := a.config.teamProfile() + if profile == "" { + return nil + } + a.team.mu.Lock() + defer a.team.mu.Unlock() + return a.teamRolesLocked(profile) +} + +func (a *Agent) teamRolesLocked(profile string) []teamRole { + keys := a.teamKeysLocked() + if len(keys) == 0 { + return nil + } + now := stampOf(teams.Path(profile)) + settings := a.teamDefaultsMovedLocked(profile) + if now == a.team.teamsAt && !settings { + return a.team.roles + } + if !now.present { + a.team.teamsAt, a.team.roles, a.team.file = now, nil, nil + a.team.events.member.Store(false) + return nil + } + file, err := teams.Load(profile) + if err != nil { + // AN UNREADABLE FILE IS THE INTERFACE'S TO SET ASIDE ([teams.SetAside]), + // never this reader's. What was known a moment ago stays known, and the + // stamp is not taken, so the next boundary tries again. + return a.team.roles + } + a.team.teamsAt = now + a.team.roles = rolesFor(file, keys, a.team.defaults) + a.team.file = file + a.team.events.member.Store(eventfulRoles(a.team.roles)) + return a.team.roles +} + +// teamDefaultsMovedLocked reads the profile's `teams.` rows again when its +// config.json has moved since the last read, and reports whether it did. A +// config that has not moved costs one stat. The caller holds a.team.mu. +func (a *Agent) teamDefaultsMovedLocked(profile string) bool { + now := stampOf(config.BudgetConfigPath(profile)) + if now == a.team.configAt { + return false + } + a.team.configAt = now + a.team.defaults = teams.DefaultsAt(profile) + return true +} + +// teamDefaults is the profile's `teams.` rows, read again only when they moved. +func (a *Agent) teamDefaults(profile string) teams.Defaults { + a.team.mu.Lock() + defer a.team.mu.Unlock() + a.teamDefaultsMovedLocked(profile) + return a.team.defaults +} + +// rolesFor is the open teams whose members include one of keys, in file +// order, each with its settings resolved against d. +// +// A CLOSED TEAM IS NO PART AT ALL (teams' lifecycle.go): it spends nothing, +// so a conversation whose only teams closed has no verb, no role and no +// delivery, and takes no team turn. +func rolesFor(file *teams.File, keys []string, d teams.Defaults) []teamRole { + if file == nil { + return nil + } + home, hasHome := teams.Report{}, false + for _, key := range keys { + if report, ok := file.Home(key); ok { + home, hasHome = report, true + break + } + } + var roles []teamRole + for _, team := range file.Teams { + if team.Closed() { + continue + } + member, ok := memberOf(team, keys) + if !ok { + continue + } + effective := file.Effective(team.ID, d) + boss, bossName := bossOf(file, team, member.Key) + role := teamRole{ + id: team.ID, + name: team.Name, + handle: member.Handle, + manager: team.Manager != "" && team.Manager == member.Key, + managed: boss != "", + boss: boss, + bossName: bossName, + root: team.Root, + key: member.Key, + wakes: effective.Wake, + questionsUp: effective.QuestionsUp, + derived: member.HandleDerived(), + } + if hasHome { + role.questionsUp = file.Effective(home.Team, d).QuestionsUp + } + if role.managed && !role.manager && hasHome && home.Team != boss { + role.shared = true + if at, ok := file.Team(home.Team); ok { + role.reportsTo = at.Name + } + } + roles = append(roles, role) + } + return roles +} + +// memberOf is the member of team that is this conversation. +func memberOf(team teams.Team, keys []string) (teams.Member, bool) { + for _, key := range keys { + if member, ok := team.Member(key); ok { + return member, true + } + } + return teams.Member{}, false +} + +// ── delivery ──────────────────────────────────────────────────────────────── + +// teamBoundary is the step boundary's whole business with teams: the verbs this +// conversation's roles give it go onto the belt, and what was addressed to it is +// handed back as one note, "" for nothing. It is called by [Agent.drainSteering] +// before that drain takes the agent's lock. +// +// THE VERBS ARRIVE BY THE ARMING DOOR AND NEVER LEAVE. A conversation made a +// manager halfway through its life is given the manager's verbs at its next +// boundary through [Agent.armFamily], the door a connected account and a loaded +// group arrive through, on the same append law: at the tail, nothing already +// there moves. A conversation that stops being a manager keeps the verbs and +// each one refuses, because it asks the file again when it is called +// ([Agent.teamTarget]); taking a tool out of the block would re-price the whole +// conversation for a verb nobody will call. +func (a *Agent) teamBoundary() string { + profile := a.config.teamProfile() + if profile == "" { + return "" + } + a.team.mu.Lock() + roles := a.teamRolesLocked(profile) + news := a.teamNewsLocked(profile, roles) + claims := a.team.claims + a.team.claims = nil + if len(claims) > 0 { + // A START THAT NAMED A TEAM FOR THIS CONVERSATION TO RUN is made good + // before the role is composed, so the request that carries the brief + // also says this conversation is that team's manager. + a.team.mu.Unlock() + a.claimSubTeams(profile, claims) + a.team.mu.Lock() + roles = a.teamRolesLocked(profile) + } + role := teamRoleBlock(roles, a.team.file) + a.team.mu.Unlock() + // A wrap-up the delivery just started is written down here, after the + // seat's lock, so a restart keeps the clock (team_wrapup.go). + a.teamWrapUpNote(profile) + a.setTeamRole(role) + a.armTeamTools(roles) + // A handle that is still the word list's guess is chosen once, beside the + // turn (handlepick.go). + a.teamHandlePass(roles) + return news +} + +// armTeamTools puts the verbs these roles give onto the belt. +func (a *Agent) armTeamTools(roles []teamRole) { + var arriving []bare.Tool + manager, member := false, false + for _, role := range roles { + manager = manager || role.manager + member = member || (!role.manager && role.managed) + } + if manager { + arriving = append(arriving, a.managerTools()...) + arriving = append(arriving, a.packetTools()...) + arriving = append(arriving, a.wrapUpTools()...) + } + if member { + arriving = append(arriving, a.memberTools()...) + } + if manager || member { + arriving = append(arriving, a.raiseTools()...) + } + if len(arriving) == 0 { + return + } + // A schema that will not parse is a bug in this build, and every tool here + // is a literal; the error has nowhere useful to go at a boundary. + _, _ = a.armFamily(arriving) +} + +// teamNewsLocked reads each team's Traffic past this conversation's cursor and +// composes what is addressed to it. The caller holds a.team.mu. +func (a *Agent) teamNewsLocked(profile string, roles []teamRole) string { + if len(roles) == 0 { + return "" + } + a.readTeamCursorsLocked() + // THE CURSOR IS WRITTEN DOWN ONLY WHEN IT MATTERS AFTER A RESTART: when a + // team's first cursor is taken, because a restart would take a later one and + // skip what was said while this was closed, and when something was + // delivered, because a restart must not deliver it twice. A cursor that + // moved over lines addressed to somebody else is kept in memory; a restart + // reads those lines again and hands on none of them, which costs a read and + // never a message, where a write per step cost a file per step. + save := false + var groups []string + for _, role := range roles { + path := teams.TrafficPath(profile, role.id) + stamp := stampOf(path) + cursor, known := a.team.cursors[role.id] + if known && stamp == a.team.trafficAt[role.id] { + continue + } + if !known { + cursor = a.firstTeamCursor(profile, role) + a.team.cursors[role.id] = cursor + save = true + } + entries, err := teams.ReadTraffic(profile, role.id, cursor, teamPageLimit) + if err != nil { + continue + } + var lines []string + for _, entry := range entries { + cursor = entry.ID + if line := a.teamEntryLineLocked(profile, role, entry); line != "" { + lines = append(lines, line) + // WHAT THE MANAGER LAST SAID TO IT IS WHAT IT ANSWERS, until the + // manager says something else: its next reply to the manager, and + // the events its turn raises, name it. + if !role.manager && entry.From == teams.FromManager { + if a.team.answering == nil { + a.team.answering = map[string]string{} + } + a.team.answering[role.id] = entry.ID + } + } + } + a.team.cursors[role.id] = cursor + // CAUGHT UP IS WHAT THE STAMP MEANS. A page that came back full has more + // behind it, so the stamp is left unmatched and the next boundary reads on. + if len(entries) < teamPageLimit { + a.team.trafficAt[role.id] = stamp + } + if len(lines) > 0 { + groups = append(groups, teamNewsGroup(role, lines)) + save = true + } + } + if save { + a.saveTeamCursorsLocked() + } + return strings.Join(groups, "\n\n") +} + +// firstTeamCursor is where a conversation starts reading a team it has no +// cursor for. +// +// A FRESH CONVERSATION DOES NOT REPLAY THE TEAM'S HISTORY. It starts at the last +// entry written before this process began, so what it is handed is what was said +// while it was listening, and a member added to a team with a month of Traffic +// is not handed the month. +// +// THE ONE EXCEPTION IS ITS OWN START. A member the manager started with +// `team_start` is opened by the interface after the start is written, and the +// manager may have said something to it in between; so a start addressed to +// this conversation's handle, written shortly before this process began, is +// where it starts reading instead. It starts reading AT the start and not after +// it, because the start carries the brief, and the brief is handed to the new +// member here, marked as the manager's, on its first request ([teamBriefLine]). +// The person never typed it, so it must not arrive as the person's message. +func (a *Agent) firstTeamCursor(profile string, role teamRole) string { + tail, err := teams.ReadTraffic(profile, role.id, "", teamFirstLook) + if err != nil { + return teamLogStart + } + born := a.startedAt + cursor := teamLogStart + started := "" + for _, entry := range tail { + if !entry.At.After(born) { + cursor = entry.ID + } + if role.handle != "" && entry.Kind == teams.KindStart && entry.To == role.handle && + !entry.At.Before(born.Add(-teamStartGrace)) { + started = entry.ID + } + // AND THE DIRECTIVE IT WAS OPENED FOR. A member nobody had open is + // opened by the engine because a directive was just sent to it + // (team_wakewatch.go's [Agent.teamRouse]), and a member that never read + // this team before would otherwise start after that very directive. So + // the earliest directive to it inside the same grace is where it starts, + // for a member only: a manager is never opened for a line it sent. + if started == "" && !role.manager && role.wakes && teamWakes(role, entry) && + !entry.At.Before(born.Add(-teamStartGrace)) { + started = entry.ID + } + } + if started != "" && started <= cursor { + return teamCursorBefore(started) + } + return cursor +} + +// teamEntryLineLocked is one entry as this conversation is told it: a packet +// line by its packet ([teamPacketLine]), the person's wrap-up request to a +// manager as the instruction it is (and the wrap-up's clock started, +// team_wrapup.go), and everything else by [teamLine]. The caller holds +// a.team.mu. +func (a *Agent) teamEntryLineLocked(profile string, role teamRole, entry teams.Entry) string { + switch { + case entry.Kind == teams.KindPacket: + return teamPacketLine(profile, role, entry) + case entry.Kind == teams.KindStart && entry.Team != "": + line := teamBriefLine(role, entry) + if line == "" { + return "" + } + a.team.claims = append(a.team.claims, subTeamClaim{team: entry.Team, parent: role.id, key: role.key}) + return subTeamBriefLine(a.team.file, entry, line) + case role.manager && teams.IsWrapUp(entry): + a.teamWrapUpBeginLocked(role, entry.At) + return wrapUpLine(role, entry) + } + return teamLine(role, entry) +} + +// teamLine is one entry as this conversation is told it, or "" for an entry +// that is not addressed to it. +// +// WHAT A MEMBER IS TOLD is what is addressed to it: a line to its own handle, to +// everyone, or to the room. WHAT A MANAGER IS TOLD is every member's post, +// wherever it was aimed, because the room is the manager's to run; and never its +// own lines, the person's (which reach it in its own chat), a start or a stop +// (which the interface performs) or an event (which the digest carries). The +// one event everyone is told is codeaf's, that a handle changed. +func teamLine(role teamRole, entry teams.Entry) string { + // A CONFLICT'S RULING reaches the party it names whoever wrote it and + // whatever this conversation is in the team (team_nest.go). + if teams.IsRuling(entry) { + if rulingFor(role, entry) { + return rulingLine(entry) + } + return "" + } + if entry.Kind == teams.KindStart { + return teamBriefLine(role, entry) + } + // A HANDLE THAT CHANGED IS TOLD TO EVERYONE, manager included: it is how a + // member is addressed, and a line to the old one would reach nobody + // (handlepick.go's [handleRenameEntry]). + if entry.Kind == teams.KindEvent && entry.From == teams.FromSystem && entry.To == teams.ToEveryone { + if text := strings.TrimSpace(entry.Text); text != "" { + return teamSpeaker(entry.From) + ": " + cutRunesTeam(text, teamEntryText) + } + return "" + } + if entry.Kind != teams.KindNote && entry.Kind != teams.KindDirective { + return "" + } + text := strings.TrimSpace(entry.Text) + if text == "" { + return "" + } + text = indentAfterFirst(cutRunesTeam(text, teamEntryText)) + if role.manager { + switch entry.From { + case teams.FromManager, teams.FromYou, teams.FromSystem: + return "" + } + return teamSpeaker(entry.From) + teamAimed(entry.To, true) + ": " + text + } + if entry.From == role.handle && role.handle != "" { + return "" + } + if entry.To != teams.ToRoom && !entry.Addressed(role.handle) { + return "" + } + // A MEMBER IS TOLD EACH LINE'S NUMBER, "#42", so a reply can name the + // line it answers (team_post's thread); one to the manager names the + // manager's last line by itself. + number := teamNumber(entry) + if entry.From == teams.FromManager { + word := "◆ from manager" + if entry.Kind == teams.KindDirective { + word = "◆ directive from manager" + } + // A LINK'S WORD IS AN FYI. A member shared into this team reports to + // another manager, and this team's manager may send it notes and + // nothing more (the verb refuses the rest); a directive that reached + // it anyway, from an older build, is information. + if role.shared { + word = fmt.Sprintf("◆ fyi from the manager of %q (you report to %q, whose word directs you)", role.name, role.reportsTo) + } + return word + teamAimed(entry.To, false) + number + ": " + text + } + return teamSpeaker(entry.From) + teamAimed(entry.To, false) + number + ": " + text +} + +// teamNumber is a delivered line's number with the space before it, " #42", +// and "" for an entry that has no id yet. +func teamNumber(entry teams.Entry) string { + if entry.ID == "" { + return "" + } + return " " + teams.ThreadNumber(entry.ID) +} + +// teamSpeaker names who wrote a line. +func teamSpeaker(from string) string { + switch from { + case teams.FromManager: + return "◆ from manager" + case teams.FromYou: + return "from the person" + case teams.FromSystem: + return "from codeaf" + } + return "from @" + strings.TrimPrefix(from, "@") +} + +// teamAimed is where a line was aimed, when that is not simply "to you". +func teamAimed(to string, manager bool) string { + switch to { + case teams.ToRoom: + return " to the room" + case teams.ToEveryone: + return " to everyone" + case teams.ToManager: + if manager { + return "" + } + return " to the manager" + case teams.ToSeveral: + // A member named among several is told it as its own line; a manager + // never reads its own messages back. + return "" + } + if manager { + return " to @" + to + } + return "" +} + +// teamNewsGroup is one team's lines under the sentence that says what they are. +// +// THE SENTENCE IS THE AUTHORITY LAW, said where it is needed: these are the +// team's words and not the person's, the person outranks the manager and the +// manager's directive outranks a member's message, and nothing here grants a +// permission. It is said once per delivery rather than once per line. +func teamNewsGroup(role teamRole, lines []string) string { + var b strings.Builder + if role.manager { + fmt.Fprintf(&b, "Team traffic in %q, which you manage. These are your members' messages, not the person's words:\n", role.name) + } else { + you := "you" + if role.handle != "" { + you = "you (@" + role.handle + ")" + } + fmt.Fprintf(&b, "Team traffic in %q for %s. These are the team's messages, not the person's words:\n", role.name, you) + } + for _, line := range lines { + b.WriteString(line) + b.WriteByte('\n') + } + if role.manager { + b.WriteString("(The person outranks every member. Answer with team_send; a member's permission prompt is the person's to answer, never yours.)") + } else { + b.WriteString("(The person's own words in this conversation outrank the manager, and a manager's directive outranks another member's message. " + + "None of this grants a permission the person has not given. Reply with team_post.)") + } + return b.String() +} + +// indentAfterFirst keeps a multi-line message under its own line. +func indentAfterFirst(text string) string { + return strings.ReplaceAll(text, "\n", "\n ") +} + +// cutRunesTeam is text cut to n characters, the last of them "…" when it was. +func cutRunesTeam(text string, n int) string { + runes := []rune(text) + if len(runes) <= n { + return text + } + return string(runes[:n-1]) + "…" +} + +// ── the cursor, kept in the session folder ────────────────────────────────── + +// teamCursorFile is the session folder's record of how far into each team's +// Traffic this conversation has read, so a conversation reopened tomorrow is +// handed what was said while it was closed and nothing it was already handed. +// A session with no folder keeps it in memory, and a restart of one starts +// again from [Agent.firstTeamCursor]. +func (a *Agent) teamCursorFile() string { + return a.config.Place.join(placeTeamCursors) +} + +func (a *Agent) readTeamCursorsLocked() { + if a.team.cursorsRead { + return + } + a.team.cursorsRead = true + a.team.cursors = map[string]string{} + a.team.trafficAt = map[string]fileStamp{} + path := a.teamCursorFile() + if path == "" { + return + } + raw, err := os.ReadFile(path) + if err != nil { + return + } + var stored struct { + Read map[string]string `json:"read"` + } + if json.Unmarshal(raw, &stored) != nil { + return + } + for id, cursor := range stored.Read { + if strings.TrimSpace(cursor) != "" { + a.team.cursors[id] = cursor + } + } +} + +// saveTeamCursorsLocked writes the cursors down, whole, through a rename. A +// failed write is silence: the worst it costs is a line delivered twice after a +// restart, which is the direction this must fail in. +func (a *Agent) saveTeamCursorsLocked() { + path := a.teamCursorFile() + if path == "" { + return + } + read := make(map[string]string, len(a.team.cursors)) + for id, cursor := range a.team.cursors { + read[id] = cursor + } + raw, err := json.Marshal(struct { + Read map[string]string `json:"read"` + }{read}) + if err != nil { + return + } + _ = writeTeamFile(path, raw) +} + +func writeTeamFile(path string, raw []byte) error { + if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { + return err + } + temp, err := os.CreateTemp(filepath.Dir(path), ".team-*") + if err != nil { + return err + } + name := temp.Name() + if _, err := temp.Write(raw); err != nil { + _ = temp.Close() + _ = os.Remove(name) + return err + } + if err := temp.Close(); err != nil { + _ = os.Remove(name) + return err + } + if err := os.Rename(name, path); err != nil { + _ = os.Remove(name) + return err + } + return nil +} + +// ── the digest ────────────────────────────────────────────────────────────── + +// teamNoteOpening is the first line of the note a manager's team rides in. It is +// its own note rather than a paragraph of [volatileNoteOpening] because the two +// move on different beats: the card moves when work lands, and a team moves +// whenever a member does. +const teamNoteOpening = "A note from the session, not from the person: the team you manage, as it stands right now. Facts, not requests, and the last such note is the one that holds." + +// teamDigestBudget is how many characters of digest ride each managed team. +const teamDigestBudget = 1600 + +// teamRecent is how many Traffic entries a digest is offered. +const teamRecent = 20 + +// refreshTeamDigest reads, for every team this conversation manages, what each +// member is doing and the last few lines of Traffic, and leaves the composed +// block where the next request's note will carry it. It is started beside the +// work at the top of a turn (loop.go), so a slow disk costs the block a step +// and never costs the person a wait. +func (a *Agent) refreshTeamDigest(ctx context.Context) { + profile := a.config.teamProfile() + if profile == "" || ctx.Err() != nil { + return + } + block := a.teamDigest(profile) + a.mu.Lock() + defer a.mu.Unlock() + if a.closed { + return + } + a.teamDigestText = block +} + +// teamDigest is one digest per managed team, "" for a conversation that +// manages none. Who the manager is and what it does is not here: that is the +// role note's, which cannot arrive late ([teamRoleBlock]). +func (a *Agent) teamDigest(profile string) string { + a.team.mu.Lock() + roles := a.teamRolesLocked(profile) + keys := append([]string(nil), a.teamKeysLocked()...) + file := a.team.file + a.team.mu.Unlock() + var managed []teamRole + for _, role := range roles { + if role.manager { + managed = append(managed, role) + } + } + if len(managed) == 0 { + return "" + } + // THE FILE THE ROLES CAME OFF, not a second load: the role read above + // stats the teams file and reads it only when it moved. + if file == nil { + return "" + } + now := time.Now() + var parts []string + for _, role := range managed { + team, ok := file.Team(role.id) + if !ok { + continue + } + team = managedView(file, team) + log, _ := teams.ReadTraffic(profile, role.id, "", teamStateLook) + states := memberStates(team, keys, now, log, &a.team.journals) + markShared(file, team, states) + parts = append(parts, teams.Digest(team, states, recentOf(log), teamDigestBudget)) + } + return strings.TrimSpace(strings.Join(parts, "\n\n")) +} + +// teamBlockLocked is what the team note carries. +func (a *Agent) teamBlockLocked() string { return strings.TrimSpace(a.teamDigestText) } + +// ── what a member is doing, read off its journal ──────────────────────────── + +// memberStates is each member's state as its journal says it, keyed by +// conversation key, corrected by the events in log (the team's Traffic, oldest +// first) for the one state a journal cannot hold: a member held on a permission +// prompt ([askingFromEvents]). This conversation's own row is running: it is +// the one reading the file. +// +// A MEMBER'S JOURNAL IS READ ONLY WHEN IT MOVED: journals keeps what each said +// against its stamp, and a nil one reads every time. +func memberStates(team teams.Team, self []string, now time.Time, log []teams.Entry, journals *journalCache) map[string]teams.MemberState { + states := make(map[string]teams.MemberState, len(team.Members)) + for _, member := range team.Members { + if teamHoldsKey(self, member.Key) { + states[member.Key] = teams.MemberState{State: teams.StateRunning} + continue + } + if state, last, ok := journals.stateOf(member.File, now); ok { + states[member.Key] = askingFromEvents(state, last, member, log, now) + } + } + return states +} + +func teamHoldsKey(list []string, want string) bool { + for _, have := range list { + if have == want { + return true + } + } + return false +} + +// journalTail is how much of the end of a member's journal is read to learn +// what it is doing. A turn's last lines are what say so, and a quarter of a +// megabyte holds dozens of turns of ordinary work. +const journalTail = 256 << 10 + +// journalStale is how long a turn with no ending may go quiet before it is +// read as over. A process that died mid-turn writes no ending, and a member +// shown running forever would be a digest that lies. +const journalStale = 20 * time.Minute + +// journalFiles is how many touched files a state carries. +const journalFiles = 8 + +// journalState reads one member's journal WITHOUT opening it the way a session +// does ([Peek]'s discipline: no lock, no repair, no write) and says what the +// member is doing. The boolean is false for a file that cannot be read. +// +// WHAT THE FILE CAN SAY, and nothing more: +// +// - asking, when the last `ask` it called has no answer after it; +// - failed, when a turn's last word is an error or a failure line; +// - running, when the person (or the harness) spoke after the last turn's +// pace line and the file has moved within [journalStale]; +// - idle otherwise: a turn ended and nobody has said anything since. +// +// A permission prompt waiting on the person is not written to the journal, so a +// member held on one reads as running here; the member's own asking event in +// the Traffic log is what says otherwise ([askingFromEvents]). +func journalState(path string, now time.Time) (teams.MemberState, bool) { + state, _, ok := journalStateAt(path, now) + return state, ok +} + +// journalStateAt is [journalState] and the instant of the journal's last line, +// which is what an asking event is weighed against. +func journalStateAt(path string, now time.Time) (teams.MemberState, time.Time, bool) { + facts, ok := readJournalFacts(path) + if !ok { + return teams.MemberState{}, time.Time{}, false + } + return facts.state(now), facts.last, true +} + +// journalFacts is what a member's journal tail says, before the clock is +// asked: everything [journalState] needs that does not move while the file +// does not. It is what a cache keeps per file (teamcache.go), so a manager's +// turn that finds a member's journal unmoved reads nothing. +type journalFacts struct { + // last is the newest line's instant, the file's modification time when no + // line carried one. + last time.Time + // asking is a question the member called `ask` for and has no answer to, + // with its head, "" when it gave none. + asking bool + question string + // failed says a turn's last word was an error or a failure line; spoke says + // somebody spoke after the last turn's pace line. + failed bool + spoke bool + // files is the newest [journalFiles] files touched, newest first. + files []string +} + +// memberJournalLine is the few fields of a journal line a state is read from. The +// rest of each line (the message's content, its reasoning) is skipped rather +// than decoded. +type memberJournalLine struct { + Type string `json:"type"` + Role string `json:"role"` + Timestamp string `json:"timestamp"` + ToolCalls []ai.ToolCall `json:"toolCalls"` + ToolCallID string `json:"toolCallId"` +} + +// readJournalFacts reads the last [journalTail] bytes of a member's journal. +// The boolean is false for a file that cannot be read. +func readJournalFacts(path string) (journalFacts, bool) { + path = strings.TrimSpace(path) + if path == "" { + return journalFacts{}, false + } + lines, mod, err := journalTailLines(path, journalTail) + if err != nil { + return journalFacts{}, false + } + var ( + last time.Time + spokeAt = -1 + endedAt = -1 + failedAt = -1 + pending []string // the ids of asks with no answer yet, in order + heads = map[string]string{} + files []string + ) + for index, raw := range lines { + var entry memberJournalLine + if json.Unmarshal(raw, &entry) != nil { + continue + } + if at, err := time.Parse(time.RFC3339Nano, entry.Timestamp); err == nil { + last = at + } + switch entry.Type { + case "pace": + endedAt = index + case "error", "failure": + failedAt = index + case "message": + switch entry.Role { + case "user": + spokeAt = index + case "assistant": + for _, call := range entry.ToolCalls { + switch call.Function.Name { + case "ask": + var args struct { + Head string `json:"head"` + } + _ = json.Unmarshal([]byte(call.Function.Arguments), &args) + pending = append(pending, call.ID) + heads[call.ID] = strings.TrimSpace(args.Head) + case "edit", "write": + var args struct { + Path string `json:"path"` + } + if json.Unmarshal([]byte(call.Function.Arguments), &args) == nil && strings.TrimSpace(args.Path) != "" { + files = appendFresh(files, strings.TrimSpace(args.Path)) + } + } + } + case "tool": + delete(heads, entry.ToolCallID) + } + } + } + if last.IsZero() { + last = mod + } + facts := journalFacts{ + last: last, + failed: failedAt > endedAt && failedAt > spokeAt, + spoke: spokeAt > endedAt, + files: newestFirst(files, journalFiles), + } + for _, id := range pending { + head, open := heads[id] + if !open { + continue + } + facts.asking = true + if head != "" { + facts.question = head + } + } + return facts, true +} + +// state is the facts read against the clock: a turn with no ending that has +// gone quiet for [journalStale] is over. +func (f journalFacts) state(now time.Time) teams.MemberState { + state := teams.MemberState{SinceActive: now.Sub(f.last), Files: f.files} + if state.SinceActive <= 0 { + state.SinceActive = time.Second + } + switch { + case f.asking: + state.State = teams.StateAsking + state.Question = f.question + case f.failed: + state.State = teams.StateFailed + case f.spoke && now.Sub(f.last) < journalStale: + state.State = teams.StateRunning + default: + state.State = teams.StateIdle + } + return state +} + +// appendFresh moves path to the end of files, so the list is in the order the +// files were last touched. +func appendFresh(files []string, path string) []string { + for index, have := range files { + if have == path { + files = append(files[:index:index], files[index+1:]...) + break + } + } + return append(files, path) +} + +// newestFirst is the last n of files, newest first. +func newestFirst(files []string, n int) []string { + out := make([]string, 0, min(len(files), n)) + for index := len(files) - 1; index >= 0 && len(out) < n; index-- { + out = append(out, files[index]) + } + return out +} + +// journalTailLines is the complete lines in the last window bytes of a file, and the +// file's modification time. A first line cut by the window is dropped. +func journalTailLines(path string, window int64) ([][]byte, time.Time, error) { + file, err := os.Open(path) + if err != nil { + return nil, time.Time{}, err + } + defer file.Close() + info, err := file.Stat() + if err != nil { + return nil, time.Time{}, err + } + if info.IsDir() { + return nil, time.Time{}, errors.New("session: a journal is a file") + } + start := max(info.Size()-window, 0) + buf := make([]byte, info.Size()-start) + if _, err := file.ReadAt(buf, start); err != nil && len(buf) > 0 && !errors.Is(err, io.EOF) { + return nil, time.Time{}, err + } + parts := strings.Split(string(buf), "\n") + if start > 0 && len(parts) > 0 { + parts = parts[1:] + } + lines := make([][]byte, 0, len(parts)) + for _, part := range parts { + if part = strings.TrimSpace(part); part != "" { + lines = append(lines, []byte(part)) + } + } + return lines, info.ModTime(), nil +} + +// sortedTeamNames is the names of roles, for a refusal that lists them. +func sortedTeamNames(roles []teamRole) []string { + names := make([]string, 0, len(roles)) + for _, role := range roles { + names = append(names, fmt.Sprintf("%q", role.name)) + } + sort.Strings(names) + return names +} + +// ── the role ──────────────────────────────────────────────────────────────── + +// teamRoleNoteOpening is the first line of the note that says what this +// conversation is in its teams. +// +// IT IS AN INSTRUCTION AND SAYS SO. The digest's opening calls its note facts +// and not requests, which is right for a list of who is doing what and wrong +// for "you are this team's manager": a model told that its role is a fact +// beside the work, and not a request, weighs it like one, and the manager found +// on the ordinary launch answered "what is happening here" as an ordinary chat +// about its folder. So the role rides its own opening, in codeaf's voice. +const teamRoleNoteOpening = "Instructions from codeaf, not from the person: your part in a team. They hold until a later note that opens this way replaces them." + +// teamRoleWithdrawn is the role note for a conversation that had a part in a +// team and has none now. An earlier role note is never taken out of the +// transcript (the append law), so the change is said at the tail instead. +const teamRoleWithdrawn = "You are no longer the manager or a member of any team. What earlier notes that opened this way said no longer holds, and a team verb you still carry will refuse." + +// teamManagerLaws is how a manager works, stated once in the role. The verbs' +// own descriptions carry how each is called. +const teamManagerLaws = "Seven laws:\n" + + "1. Hand real work to members with team_send, or team_start for a new member, rather than doing it yourself, and keep track with team_status and team_read. Asked what is happening, answer from the team.\n" + + "2. The person outranks you: what they say in a member's own conversation stands over your directive, and a conflict goes to them.\n" + + "3. You cannot answer a member's permission prompt; tell the person it is waiting.\n" + + "4. You direct only the members who report to you, one level down: a team under yours is its manager's to run, so you direct that manager, never its members. A member team_status marks `reports to` another team is shared: read it and send it notes, never a directive or a stop.\n" + + "5. Members' questions come to you as decision packets: answer with team_decide, or send one up with team_escalate when it is not yours to decide. Your own questions go up the same way.\n" + + "6. A team's daily cap is the person's: you cannot raise it, and at the cap nothing new starts until they answer.\n" + + "7. A conflict between conversations is declared with team_raise and goes to the lowest manager above every party; when it waits on you, your team_decide reaches every party as a directive." + +// teamRosterMax is how many members the role names before it sends the model +// to team_status for the rest, and teamRosterWord how much of each member's +// title it quotes. +const ( + teamRosterMax = 12 + teamRosterWord = 60 +) + +// teamRoleBlock is what this conversation is in its teams, one paragraph per +// team it manages or is a managed member of, "" for none. A member of a team +// with no manager has no part to be told: it has no verb and nobody to report +// to. +// +// It is composed off the teams file the boundary has just read, under the +// seat's lock, so it costs no disk of its own. +func teamRoleBlock(roles []teamRole, file *teams.File) string { + var parts []string + for _, role := range roles { + switch { + case role.manager: + parts = append(parts, teamManagerRole(role, file)) + case role.managed: + parts = append(parts, teamMemberRole(role)) + } + } + return strings.Join(parts, "\n\n") +} + +func teamManagerRole(role teamRole, file *teams.File) string { + var b strings.Builder + fmt.Fprintf(&b, "You are the manager of the team %q. The person talks to you and you run the team for them: you decide who does what, hand the work out, and tell the person where it stands.\n", role.name) + b.WriteString(teamRoster(role, file)) + b.WriteString("\n") + if scope := teamManagerScope(role, file); scope != "" { + b.WriteString(scope) + b.WriteString("\n") + } + b.WriteString(teamManagerDelivery(role)) + b.WriteString("\n") + b.WriteString(teamManagerLaws) + return b.String() +} + +// teamManagerScope is where the manager's team sits in the tree, "" for a +// team alone at the top with nothing under it: whom it reports to (a +// sub-team's manager reports one level up; a top-level team's to the global +// manager when there is one), what runs under it, and, for the global manager, +// what its members are. +func teamManagerScope(role teamRole, file *teams.File) string { + if file == nil { + return "" + } + var parts []string + if role.root { + parts = append(parts, fmt.Sprintf("You are the global manager: %q holds every team, and your members are the managers of the top-level teams, never their members. "+ + "Direct those managers and they pass it on. Their questions and conflicts between teams come to you before the person. team_start with kind team starts a new top-level team.", role.name)) + } else if home, ok := file.Home(role.key); ok && home.Team != role.id { + boss := "its manager" + if t, ok := file.Team(home.Team); ok { + if m, ok := t.Member(t.Manager); ok && m.Handle != "" { + boss = "its manager, @" + m.Handle + } + what := "a team under" + if t.Root { + what = "a top-level team, under the global manager of" + } + parts = append(parts, fmt.Sprintf("Your team is %s %q: you report to %s. Post to it with team_post; your questions go to it before the person.", what, t.Name, boss)) + } + } + var under []string + for _, child := range file.Children(role.id) { + if child.Closed() || role.root { + continue + } + who := "no manager yet" + if m, ok := child.Member(child.Manager); ok && m.Handle != "" { + who = "run by @" + m.Handle + } + under = append(under, fmt.Sprintf("%q (%s)", child.Name, who)) + } + if len(under) > 0 { + parts = append(parts, "Teams under yours: "+strings.Join(under, ", ")+". Direct their managers, never their members.") + } + return strings.Join(parts, " ") +} + +// teamManagerDelivery is what happens to what the manager sends and what comes +// back, said as it is on this team: with the auto-wake on, a directive starts +// an idle member and replies start the manager (team_wakewatch.go); with it +// off, everything waits for the next turn each conversation takes. +func teamManagerDelivery(role teamRole) string { + if !role.wakes { + return "This team's auto-wake is off: what you send, and your members' replies, wait for each conversation's next turn, so an idle member does not start on a directive until it next runs." + } + return "A directive (team_send kind directive) starts an idle member's turn; a note waits for its next turn. Members' replies to you, and their finishing, failing or asking, come back to you and start your turn when you are idle, so do not wait or poll for them." +} + +// teamRoster names the manager's members by handle, with the start of each +// one's title. +func teamRoster(role teamRole, file *teams.File) string { + if file == nil { + return "team_status lists its members." + } + team, ok := file.Team(role.id) + if !ok { + return "team_status lists its members." + } + team = managedView(file, team) + var named []string + for _, member := range team.Members { + if member.Key == role.key { + continue + } + who := "a member with no handle yet" + if member.Handle != "" { + who = "@" + member.Handle + } + if word := strings.TrimSpace(member.Word); word != "" { + who += " (" + cutRunesTeam(word, teamRosterWord) + ")" + } + named = append(named, who) + } + if len(named) == 0 { + return "It has no members but you yet; team_start opens one." + } + more := "" + if len(named) > teamRosterMax { + more = fmt.Sprintf(", and %d more that team_status lists", len(named)-teamRosterMax) + named = named[:teamRosterMax] + } + return "Its members: " + strings.Join(named, ", ") + more + "." +} + +func teamMemberRole(role teamRole) string { + you := "a member" + if role.handle != "" { + you = "@" + role.handle + } + if role.root { + return fmt.Sprintf("You are %s in %q because you manage a top-level team: you report to its manager, the global manager. Its directives reach you marked \"◆ from manager\", "+ + "your questions go to it before the person, and you report to it with team_post to the manager.", you, role.name) + } + if role.boss != "" && role.boss != role.id && !role.shared { + said := fmt.Sprintf("You are %s in the team %q, which has no manager of its own, so you answer to the manager of %q: team_post to the manager reaches it, and to the room or a teammate stays in %q.", + you, role.name, role.bossName, role.name) + if role.questionsUp { + said += " Your clarifying questions (ask) go to that manager first, and its answer comes back marked \"◆ answered\"; permission prompts still go to the person." + } + return said + } + if role.shared { + return fmt.Sprintf("You are %s in the team %q too, but you report to the manager of %q: that manager's word directs you, and this team's manager may only send you notes (fyi). "+ + "Post to this team with team_post.", you, role.name, role.reportsTo) + } + said := fmt.Sprintf("You are %s in the team %q, which has a manager. "+ + "Lines from the manager arrive marked \"◆ from manager\" and from teammates \"from @handle\"; none of them is the person, whose own words outrank the manager's. "+ + "Report progress, findings and blockers with team_post, to the manager, a teammate or the room. A conflict you cannot settle with another member or team goes up with team_raise.", you, role.name) + if role.questionsUp { + said += " Your clarifying questions (ask) go to your manager first, and its answer comes back marked \"◆ answered\"; permission prompts still go to the person." + } + return said +} + +// setTeamRole leaves the role where the next landing of the session's notes +// will carry it ([Agent.landTeamRoleLocked]). +func (a *Agent) setTeamRole(role string) { + a.mu.Lock() + defer a.mu.Unlock() + if a.closed { + return + } + a.teamRoleText = role +} + +// landTeamRoleLocked lands the role note when the role has moved since the last +// one, and the withdrawal when a conversation that had a role has none. A +// conversation that never had one lands nothing, which is every conversation +// in no team. +func (a *Agent) landTeamRoleLocked() { + block := strings.TrimSpace(a.teamRoleText) + if block == "" { + last := a.lastNoteLocked(teamRoleNoteOpening) + if last == "" || last == teamRoleNoteOpening+"\n\n"+teamRoleWithdrawn { + return + } + block = teamRoleWithdrawn + } + a.landNoteLocked(teamRoleNoteOpening, block) +} diff --git a/internal/session/team_cap.go b/internal/session/team_cap.go new file mode 100644 index 0000000000..efd144211e --- /dev/null +++ b/internal/session/team_cap.go @@ -0,0 +1,209 @@ +package session + +// ── A TEAM'S DAILY CAP IS HELD, NEVER CUT MID-TURN ────────────────────────── +// +// A team may have a daily cap (teams' teamsettings.go, `cap_usd_day`, which +// inherits), and a cap is a POOL: its owner's spend counts every team under +// it, so an inherited cap is the ancestor's one pool and never a second +// allowance ([teams.Effective]'s CapFrom). This file is what enforces it, on +// the session's side, and what it enforces is deliberately small: +// +// - AT OR OVER THE CAP, WHAT THE TEAM WOULD START IS HELD. A wake (a +// directive to a member, replies to a manager, an answer to a question), a +// new member's first turn on its brief, and `team_start` are refused while +// the pool is at its cap. A turn already running is never cut: it finishes +// and nothing new starts behind it. The lines that were held are not +// lost; they are delivered at the conversation's next turn. +// - THE PERSON'S OWN WORDS ARE NOT HELD. A person typing into a member's +// conversation spends their own money in front of them, which is not what +// a cap on unattended work is for. +// - ONE CAP PACKET PER POOL AND CEILING goes to the person ([teams.Person]): +// `harbor reached its $5 cap today`, with `Raise to $10` and `Stop for +// today`, and a recommendation. Whoever meets the cap first raises it; +// everyone after finds it waiting and raises nothing, including a second +// process: [teams.Raise] keeps one packet per pool, day and ceiling under +// the decisions file's lock. A raise lifts the +// ceiling for the rest of that local day to the figure the option said +// ([teams.CapFacts].RaiseTo); a stop, or an answer in the person's own +// words, holds the pool until the day turns or the cap is changed. +// - A MANAGER NEVER RAISES A CAP. The packet waits on the person, and +// `team_decide` refuses a cap packet in words. +// +// IT IS NEVER A HOT-PATH LEDGER SCAN. The check runs only where the team would +// start something (a wake, a start), never per model request, and the spend +// it reads is kept against [teams.TeamSpendStamp] (a stat of the teams file +// and one of the ledger): a pool whose stamp has not moved is answered from +// memory, and one that moved is read by teams' own incremental fold. + +import ( + "fmt" + "math" + "sync" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// teamSpendOf and teamSpendStamp are the pool's spend and its stamp; vars so a +// test can count how often the spend is really read. +var ( + teamSpendOf = teams.TeamSpend + teamSpendStamp = teams.TeamSpendStamp + teamToday = teams.Today +) + +// capRaising serializes this process's cap raises, so two conversations in +// one pool do not both call [teams.Raise]. A second process is covered by the +// decisions file lock, not by this mutex. +var capRaising sync.Mutex + +// spendMemo is one pool's spend as last read, against its stamp. +type spendMemo struct { + stamp string + usd float64 +} + +// teamPoolSpend is the pool owner's spend today, read again only when its +// stamp moved. +func (a *Agent) teamPoolSpend(profile, owner, day string) float64 { + stamp := teamSpendStamp(profile, owner, day) + a.team.mu.Lock() + if held, ok := a.team.spends[owner]; ok && held.stamp == stamp { + a.team.mu.Unlock() + return held.usd + } + a.team.mu.Unlock() + spend, err := teamSpendOf(profile, owner, day) + if err != nil { + return 0 + } + a.team.mu.Lock() + if a.team.spends == nil { + a.team.spends = map[string]spendMemo{} + } + a.team.spends[owner] = spendMemo{stamp: stamp, usd: spend.USD} + a.team.mu.Unlock() + return spend.USD +} + +// capPool is the pool team id draws on: its owner and the cap, 0 for none. +// The owner is the team whose override the cap is, or, for the profile's +// default, the top of the chain (the root when there is one). +func capPool(file *teams.File, id string, d teams.Defaults) (teams.Team, float64) { + if file == nil { + return teams.Team{}, 0 + } + e := file.Effective(id, d) + if e.CapUSDDay <= 0 { + return teams.Team{}, 0 + } + owner := e.CapFrom.Team + if e.CapFrom.Kind == teams.OriginSettings { + owner = id + for _, up := range file.Ancestors(id) { + if !up.Closed() { + owner = up.ID + } + } + } + team, ok := file.Team(owner) + if !ok { + return teams.Team{}, 0 + } + return team, e.CapUSDDay +} + +// teamCapHold is why new team work may not start in any of roles' pools right +// now, "" when it may. Meeting a cap for the first time raises its packet. +func (a *Agent) teamCapHold(profile string, roles []teamRole) string { + if profile == "" || len(roles) == 0 { + return "" + } + a.team.mu.Lock() + file, d := a.team.file, a.team.defaults + a.team.mu.Unlock() + seen := map[string]bool{} + for _, role := range roles { + if !role.managed { + continue + } + owner, cap := capPool(file, role.id, d) + if cap <= 0 || seen[owner.ID] { + continue + } + seen[owner.ID] = true + if reason := a.poolHold(profile, owner, cap); reason != "" { + return reason + } + } + return "" +} + +// poolHold is why owner's pool is held, "" when it is not. +func (a *Agent) poolHold(profile string, owner teams.Team, cap float64) string { + day := teamToday() + spent := a.teamPoolSpend(profile, owner.ID, day) + latest, found := latestCapPacket(profile, owner.ID, day) + ceiling := cap + if found && latest.State == teams.PacketDecided && latest.Decision == teams.OptionRaiseCap && latest.Cap.RaiseTo > ceiling { + ceiling = latest.Cap.RaiseTo + } + if spent < ceiling { + return "" + } + held := fmt.Sprintf("%s reached its %s cap today (spent %s); the person has been asked whether to raise it, and nothing new starts until they answer", + owner.Name, teamMoney(ceiling), teamMoney(spent)) + if found && (latest.Waiting() || latest.Cap.CapUSD >= ceiling) { + if !latest.Waiting() { + held = fmt.Sprintf("%s reached its %s cap today and the person chose to stop it for today", owner.Name, teamMoney(ceiling)) + } + return held + } + capRaising.Lock() + defer capRaising.Unlock() + if again, ok := latestCapPacket(profile, owner.ID, day); ok && (again.Waiting() || again.Cap.CapUSD >= ceiling) { + return held + } + _, _ = teams.Raise(profile, capPacket(owner, day, ceiling, spent)) + return held +} + +// latestCapPacket is the last cap packet raised for owner's pool on day. +func latestCapPacket(profile, owner, day string) (teams.Packet, bool) { + list, err := teams.Packets(profile, owner) + if err != nil { + return teams.Packet{}, false + } + for i := len(list) - 1; i >= 0; i-- { + p := list[i] + if p.Kind == teams.PacketCap && p.Cap != nil && p.Cap.Team == owner && p.Cap.Day == day { + return p, true + } + } + return teams.Packet{}, false +} + +// capPacket is the packet a pool at its ceiling raises to the person. +func capPacket(owner teams.Team, day string, ceiling, spent float64) teams.Packet { + raiseTo := math.Round(ceiling*2*100) / 100 + return teams.Packet{ + Team: teams.Person, Origin: owner.ID, Kind: teams.PacketCap, RaisedBy: teams.FromSystem, + Question: fmt.Sprintf("%s reached its %s cap today", owner.Name, teamMoney(ceiling)), + Options: []teams.Option{ + {ID: teams.OptionRaiseCap, Label: "Raise to " + teamMoney(raiseTo), + Consequence: fmt.Sprintf("%s and its sub-teams go on until %s today", owner.Name, teamMoney(raiseTo))}, + {ID: teams.OptionStopToday, Label: "Stop for today", + Consequence: "members finish their current turn and start no new one until tomorrow"}, + }, + Recommendation: &teams.Recommendation{Option: teams.OptionStopToday, + Reason: "the cap is the limit you set; raise it only if today's work is worth more to you"}, + Cap: &teams.CapFacts{Team: owner.ID, Day: day, CapUSD: ceiling, SpentUSD: math.Round(spent*100) / 100, RaiseTo: raiseTo}, + } +} + +// teamMoney is dollars as the person reads them: $5, $5.50. +func teamMoney(usd float64) string { + if usd == math.Trunc(usd) { + return fmt.Sprintf("$%.0f", usd) + } + return fmt.Sprintf("$%.2f", usd) +} diff --git a/internal/session/team_delegation_test.go b/internal/session/team_delegation_test.go new file mode 100644 index 0000000000..999e15d438 --- /dev/null +++ b/internal/session/team_delegation_test.go @@ -0,0 +1,586 @@ +package session + +// DELEGATION, AS TESTS: questions go up as packets and answers come back +// down, links read and fyi but do not direct, a cap holds new work and asks +// the person once, and a wrap-up ends in a closing report that closes the +// team only when the person accepts it. Every fixture is a real teams.json, +// a real Traffic log and real packet files, through internal/teams. + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/filelock" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// clarifying is an `ask` a member writes when it needs an answer to go on. +const clarifying = `{"head":"JSON or form data?","kind":"clarification","reason":"the handler and the form disagree","stakes":"reversible",` + + `"options":[{"key":"1","label":"JSON","consequence":"the handler changes"},{"key":"2","label":"form data","consequence":"the form changes"}],` + + `"pick":{"key":"1","reason":"the other endpoints take JSON"}}` + +func callTool(t *testing.T, run func(context.Context, json.RawMessage) (string, bool, error), args string) (string, bool) { + t.Helper() + text, failed, err := run(context.Background(), json.RawMessage(args)) + if err != nil { + t.Fatalf("the tool returned an error: %v", err) + } + return text, failed +} + +func onlyPacket(t *testing.T, profile, scope string) teams.Packet { + t.Helper() + waiting, _, err := teams.OpenPackets(profile, scope) + if err != nil || len(waiting) != 1 { + t.Fatalf("packets waiting on %q: %+v %v", scope, waiting, err) + } + return waiting[0] +} + +// A MEMBER'S CLARIFYING QUESTION GOES TO ITS MANAGER AS A PACKET, the manager +// is handed it whole and answers it, and the member is handed the answer +// marked as answered. Nothing is put in front of the person. +func TestTeamQuestionGoesUpAsAPacketAndTheAnswerComesBack(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + web.teamBoundary() + + said, failed := callTool(t, web.executeAsk, clarifying) + if failed || !strings.Contains(said, "went to your manager (@boss") || !strings.Contains(said, "not to the person") { + t.Fatalf("the member was told %q", said) + } + p := onlyPacket(t, fixture.profile, fixture.teamID) + if p.Kind != teams.PacketQuestion || p.RaisedBy != "web" || p.Question != "JSON or form data?" || len(p.Options) != 2 || + p.Recommendation == nil || p.Recommendation.Option != "1" || len(p.Parties) != 1 || p.Parties[0].Context != "the handler and the form disagree" { + t.Fatalf("the packet is not self-contained: %+v", p) + } + if mine, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(mine) != 0 { + t.Fatal("a member's question reached the person") + } + + news := manager.teamBoundary() + for _, want := range []string{"◆ question " + p.ID + " from @web, waiting on you: JSON or form data?", "[1] JSON: the handler changes", "recommended: 1", "team_decide"} { + if !strings.Contains(news, want) { + t.Errorf("the manager's delivery lacks %q:\n%s", want, news) + } + } + answer, failed := callTool(t, manager.teamDecideTool, `{"packet":"`+p.ID+`","answer":"json","reason":"matches the rest"}`) + if failed || !strings.Contains(answer, "Decided "+p.ID) { + t.Fatalf("team_decide said %q", answer) + } + got := web.teamBoundary() + if !strings.Contains(got, "◆ answered: JSON (by ◆ @boss, because matches the rest). Your question was: JSON or form data?") { + t.Fatalf("the member was not handed the answer:\n%s", got) + } + log, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", 0) + if last := log[len(log)-1]; last.Text != "answered @web: JSON" { + t.Fatalf("the rail's line: %+v", last) + } + // The member's answer and the manager's packet both wake, on a team that + // wakes. + role := teamRole{id: fixture.teamID, handle: "web", managed: true, key: convKeyOf(t, fixture.web)} + if !teamPacketWakes(fixture.profile, role, last(log)) { + t.Error("the answer does not wake the member it answers") + } +} + +func last(log []teams.Entry) teams.Entry { return log[len(log)-1] } + +// PERMISSION PROMPTS AND QUESTIONS WITH questions_up OFF ARE THE PERSON'S. +func TestTeamQuestionsUpOffAndPermissionsStayThePersons(t *testing.T) { + if askGoesUp(AskPermission, false) || askGoesUp(AskPermission, true) || askGoesUp(AskLanding, true) { + t.Fatal("a permission or a landing goes up") + } + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + if _, up := web.askUp(Question{Ask: AskPermission, Head: "run bash?"}); up { + t.Fatal("a permission kind went up") + } + off := false + if err := teams.Update(fixture.profile, func(f *teams.File) error { + return f.SetSettings(fixture.teamID, func(s *teams.Settings) { s.QuestionsUp = &off }) + }); err != nil { + t.Fatal(err) + } + if _, up := web.askUp(Question{Ask: AskClarification, Head: "tabs?"}); up { + t.Fatal("a question went up with questions_up off") + } +} + +// A MANAGER'S OWN QUESTION IS A PACKET TO THE PERSON when it has no manager +// above it, and the person's answer is handed to it marked as answered. +func TestTeamAManagersOwnQuestionGoesToThePersonsInbox(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + said, _ := callTool(t, manager.executeAsk, clarifying) + if !strings.Contains(said, "the person's inbox") { + t.Fatalf("the manager was told %q", said) + } + p := onlyPacket(t, fixture.profile, teams.Person) + if p.Origin != fixture.teamID || p.RaisedBy != teams.FromManager { + t.Fatalf("the manager's packet: %+v", p) + } + if _, err := teams.Decide(fixture.profile, p.ID, teams.Person, "2", ""); err != nil { + t.Fatal(err) + } + if news := manager.teamBoundary(); !strings.Contains(news, "◆ answered: form data (by the person)") { + t.Fatalf("the manager was not handed the person's answer:\n%s", news) + } +} + +// linkedFixture is harbor (boss; web, parser) and dock (dockboss; web): web +// joined harbor first, so harbor is its home and dock's manager is a link. +func linkedFixture(t *testing.T) (teamFixture, string, string) { + t.Helper() + fixture := newTeamFixture(t, true) + dir := filepath.Join(filepath.Dir(filepath.Dir(fixture.manager)), "dockboss") + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + dockboss := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(dockboss, nil, 0o600); err != nil { + t.Fatal(err) + } + dock := teams.NewID() + err := teams.Update(fixture.profile, func(f *teams.File) error { + f.Teams = append(f.Teams, teams.Team{ID: dock, Name: "dock"}) + for _, m := range []teams.Member{ + {Key: convKeyOf(t, dockboss), File: dockboss, Word: "dock manager", Handle: "dockboss"}, + {Key: convKeyOf(t, fixture.web), File: fixture.web, Word: "web frontend", Handle: "web"}, + } { + if err := f.AddMember(dock, m); err != nil { + return err + } + } + return f.SetManager(dock, convKeyOf(t, dockboss)) + }) + if err != nil { + t.Fatal(err) + } + return fixture, dock, dockboss +} + +// A LINK READS AND SENDS NOTES, AND IS REFUSED A DIRECTIVE OR A STOP in a +// sentence that says whose the member is; its status marks the member shared. +func TestTeamALinkMayNoteButNotDirectOrStop(t *testing.T) { + fixture, dock, dockboss := linkedFixture(t) + link := teamAgent(t, fixture, dockboss, nil, nil) + link.teamBoundary() + said, failed := callTool(t, link.teamSendTool, `{"to":"web","text":"do the header","kind":"directive"}`) + if !failed || !strings.Contains(said, `@web reports to the manager of "harbor", not to you`) { + t.Fatalf("a link's directive: %q", said) + } + said, failed = callTool(t, link.teamStopTool, `{"handle":"web"}`) + if !failed || !strings.Contains(said, "not a stop") { + t.Fatalf("a link's stop: %q", said) + } + said, failed = callTool(t, link.teamSendTool, `{"to":"everyone","text":"do the header","kind":"directive"}`) + if !failed || !strings.Contains(said, "reports to another team's manager") { + t.Fatalf("a link's directive to everyone: %q", said) + } + if said, failed = callTool(t, link.teamSendTool, `{"to":"web","text":"fyi the api moved"}`); failed { + t.Fatalf("a link's note was refused: %q", said) + } + status, _ := callTool(t, link.teamStatusTool, `{}`) + if !strings.Contains(status, "reports to harbor") { + t.Fatalf("status does not mark the shared member:\n%s", status) + } + log, _ := teams.ReadTraffic(fixture.profile, dock, "", 0) + for _, entry := range log { + if entry.Kind == teams.KindDirective || entry.Kind == teams.KindStop { + t.Fatalf("a refused verb wrote %+v", entry) + } + } + // And the member reads a link's line as an fyi, and is not woken by one. + web := teamAgent(t, fixture, fixture.web, nil, nil) + roles := web.teamRoles() + var shared teamRole + for _, role := range roles { + if role.id == dock { + shared = role + } + } + if !shared.shared || shared.reportsTo != "harbor" { + t.Fatalf("web's role in dock: %+v", shared) + } + directive := teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "do it"} + if teamWakes(shared, directive) || !strings.Contains(teamLine(shared, directive), "fyi from the manager of \"dock\"") { + t.Fatal("a link's directive reads or wakes as the home manager's") + } + // Its home manager still directs it. + boss := teamAgent(t, fixture, fixture.manager, nil, nil) + boss.teamBoundary() + if said, failed := callTool(t, boss.teamSendTool, `{"to":"web","text":"do the header","kind":"directive"}`); failed { + t.Fatalf("the home manager's directive was refused: %q", said) + } +} + +// capSpend stands in for the ledger: a fixed spend under a stamp the test +// moves, counting every real read. +type capSpend struct { + usd float64 + stamp string + reads int +} + +func stubCapSpend(t *testing.T, spend *capSpend) { + t.Helper() + oldOf, oldStamp, oldDay := teamSpendOf, teamSpendStamp, teamToday + teamSpendOf = func(profile, team, day string) (teams.Spend, error) { + spend.reads++ + return teams.Spend{Team: team, Day: day, USD: spend.usd}, nil + } + teamSpendStamp = func(profile, team, day string) string { return spend.stamp + "|" + team } + teamToday = func() string { return "2026-09-24" } + t.Cleanup(func() { teamSpendOf, teamSpendStamp, teamToday = oldOf, oldStamp, oldDay }) +} + +// A POOL AT ITS CAP HOLDS NEW WORK AND ASKS THE PERSON ONCE. The spend is read +// once per stamp, never per check; team_start is refused; a raise lifts the +// ceiling for the day; meeting the raised ceiling asks again, once; a stop +// holds; and a manager cannot decide a cap. +func TestTeamACapHoldsNewWorkAndAsksThePersonOnce(t *testing.T) { + fixture := newTeamFixture(t, true) + five := 5.0 + if err := teams.Update(fixture.profile, func(f *teams.File) error { + return f.SetSettings(fixture.teamID, func(s *teams.Settings) { s.CapUSDDay = &five }) + }); err != nil { + t.Fatal(err) + } + spend := &capSpend{usd: 6, stamp: "s1"} + stubCapSpend(t, spend) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + roles := manager.teamRoles() + + held := manager.teamCapHold(fixture.profile, roles) + if !strings.Contains(held, "harbor reached its $5 cap today") { + t.Fatalf("held for %q", held) + } + for i := 0; i < 5; i++ { + manager.teamCapHold(fixture.profile, roles) + } + if spend.reads != 1 { + t.Fatalf("the spend was read %d times under one stamp", spend.reads) + } + p := onlyPacket(t, fixture.profile, teams.Person) + if p.Kind != teams.PacketCap || p.Cap == nil || p.Cap.RaiseTo != 10 || p.Options[0].Label != "Raise to $10" || + p.Options[1].ID != teams.OptionStopToday || p.Recommendation == nil { + t.Fatalf("the cap packet: %+v", p) + } + said, failed := callTool(t, manager.teamStartTool, `{"handle":"docs","brief":"write the README"}`) + if !failed || !strings.Contains(said, "No new member starts") { + t.Fatalf("team_start at the cap: %q", said) + } + if said, failed := callTool(t, manager.teamDecideTool, `{"packet":"`+p.ID+`","answer":"raise"}`); !failed || !strings.Contains(said, "waits on the person") { + t.Fatalf("a manager decided a cap: %q", said) + } + if _, err := teams.Decide(fixture.profile, p.ID, teams.Person, teams.OptionRaiseCap, ""); err != nil { + t.Fatal(err) + } + if held := manager.teamCapHold(fixture.profile, roles); held != "" { + t.Fatalf("a raised cap still holds: %q", held) + } + spend.usd, spend.stamp = 11, "s2" + if held := manager.teamCapHold(fixture.profile, roles); !strings.Contains(held, "$10 cap") { + t.Fatalf("the raised ceiling did not hold: %q", held) + } + second := onlyPacket(t, fixture.profile, teams.Person) + if second.ID == p.ID || second.Cap.CapUSD != 10 || second.Cap.RaiseTo != 20 { + t.Fatalf("the second cap packet: %+v", second) + } + if _, err := teams.Decide(fixture.profile, second.ID, teams.Person, teams.OptionStopToday, ""); err != nil { + t.Fatal(err) + } + if held := manager.teamCapHold(fixture.profile, roles); !strings.Contains(held, "chose to stop it for today") { + t.Fatalf("a stop did not hold: %q", held) + } + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 0 { + t.Fatalf("a stop raised another packet: %+v", waiting) + } +} + +// NO CAP, NO READ: a team with no cap never reads the spend at all. +func TestTeamNoCapReadsNoSpend(t *testing.T) { + fixture := newTeamFixture(t, true) + spend := &capSpend{usd: 100, stamp: "s1"} + stubCapSpend(t, spend) + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.teamBoundary() + if held := web.teamCapHold(fixture.profile, web.teamRoles()); held != "" || spend.reads != 0 { + t.Fatalf("no cap: held %q after %d reads", held, spend.reads) + } +} + +// WRAP UP FIRST ENDS IN A CLOSING REPORT, and the team closes when the person +// accepts it. +func TestTeamWrapUpEndsInAClosingReportThatClosesOnAccept(t *testing.T) { + fixture := newTeamFixture(t, true) + stubCapSpend(t, &capSpend{usd: 1.25, stamp: "s1"}) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + appendTraffic(t, fixture, teams.WrapUpRequest("")) + news := manager.teamBoundary() + if !strings.Contains(news, `Wrap up "harbor" now`) || !strings.Contains(news, "team_close_report") { + t.Fatalf("the manager was not told to wrap up:\n%s", news) + } + manager.team.mu.Lock() + going := len(manager.team.wraps) + manager.team.mu.Unlock() + if going != 1 { + t.Fatal("the wrap-up's clock did not start") + } + f, _ := teams.Load(fixture.profile) + if team, _ := f.Team(fixture.teamID); team.Wrap == nil || team.Wrap.Bound != wrapUpFor || team.Wrap.Started.IsZero() { + t.Fatalf("the wrap-up was not written down: %+v", team.Wrap) + } + said, failed := callTool(t, manager.teamCloseReportTool, `{"done":"the form","left":"the tests","files":["web/form.go"]}`) + if failed || !strings.Contains(said, "closing report went to the person") { + t.Fatalf("team_close_report said %q", said) + } + p := onlyPacket(t, fixture.profile, teams.Person) + if p.Kind != teams.PacketClosing || p.Report == nil || p.Report.Done != "the form" || p.Report.SpendUSD != 1.25 || p.Report.Incomplete { + t.Fatalf("the closing report: %+v", p) + } + if said, failed := callTool(t, manager.teamCloseReportTool, `{"done":"again"}`); !failed || !strings.Contains(said, "already waiting") { + t.Fatalf("a second report: %q", said) + } + if _, err := teams.Decide(fixture.profile, p.ID, teams.Person, teams.OptionClose, ""); err != nil { + t.Fatal(err) + } + if news := manager.teamBoundary(); !strings.Contains(news, "accepted the closing report") { + t.Fatalf("the manager was not told:\n%s", news) + } + f, _ = teams.Load(fixture.profile) + if team, _ := f.Team(fixture.teamID); !team.Closed() || team.Report != p.ID { + t.Fatalf("the team did not close on its report: %+v", team) + } +} + +// A WRAP-UP PAST ITS BOUND IS REPORTED INCOMPLETE by codeaf. +func TestTeamAWrapUpPastItsBoundIsReportedIncomplete(t *testing.T) { + old := wrapUpFor + wrapUpFor = 10 * time.Millisecond + t.Cleanup(func() { wrapUpFor = old }) + fixture := newTeamFixture(t, true) + stubCapSpend(t, &capSpend{usd: 0.5, stamp: "s1"}) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + appendTraffic(t, fixture, teams.WrapUpRequest("Wrap up first")) + manager.teamBoundary() + manager.teamWrapUpDue(fixture.profile, time.Now()) + time.Sleep(20 * time.Millisecond) + manager.teamWrapUpDue(fixture.profile, time.Now()) + p := onlyPacket(t, fixture.profile, teams.Person) + if p.Kind != teams.PacketClosing || p.Report == nil || !p.Report.Incomplete || p.Options[0].ID != teams.OptionCloseNow || + !strings.Contains(p.Question, "wrap-up incomplete") { + t.Fatalf("the incomplete report: %+v", p) + } + manager.teamWrapUpDue(fixture.profile, time.Now()) + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 1 { + t.Fatal("the incomplete report was raised twice") + } +} + +// A RESTART KEEPS THE TIME THAT IS LEFT. The clock on the team is what the +// next process arms, and it does not start the bound again. +func TestTeamWrapUpResumesWithTheTimeLeft(t *testing.T) { + fixture := newTeamFixture(t, true) + stubCapSpend(t, &capSpend{usd: 0.5, stamp: "s1"}) + started := time.Now().Add(-time.Minute).UTC() + bound := 15 * time.Minute + if err := teams.Update(fixture.profile, func(f *teams.File) error { + return f.SetWrap(fixture.teamID, started, bound) + }); err != nil { + t.Fatal(err) + } + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 0 { + t.Fatal("a wrap-up with time left raised a report on start") + } + manager.team.mu.Lock() + w := manager.team.wraps[fixture.teamID] + manager.team.mu.Unlock() + if w == nil || !w.started.Equal(started) || w.bound != bound { + t.Fatalf("the clock did not resume: %+v", w) + } + manager.teamWrapUpDue(fixture.profile, started.Add(bound)) + p := onlyPacket(t, fixture.profile, teams.Person) + if p.Kind != teams.PacketClosing || p.Report == nil || !p.Report.Incomplete { + t.Fatalf("the resumed clock did not report at its bound: %+v", p) + } + if err := manager.Close(); err != nil { + t.Fatal(err) + } + _ = teamAgent(t, fixture, fixture.manager, nil, nil) + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 1 { + t.Fatal("a second start raised the report again") + } +} + +// holdDecisions is this test holding the team's decisions lock, the way a +// writer that has not finished does. release lets the next raise through. +func holdDecisions(t *testing.T, profile, teamID string) func() { + t.Helper() + path := strings.TrimSuffix(teams.DecisionsPath(profile, teamID), ".jsonl") + ".lock" + if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { + t.Fatal(err) + } + file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o600) + if err != nil { + t.Fatal(err) + } + if err := filelock.Lock(file, true, true); err != nil { + file.Close() + t.Fatal(err) + } + return func() { + _ = filelock.Unlock(file) + file.Close() + } +} + +// A BUSY DECISIONS FILE DOES NOT FORGET THE WRAP-UP. The clock comes out of +// memory before the report is raised, so a raise that cannot take the lock +// used to leave it out: this process never tried again, and only a restart +// sent the report. The next look tries again, and the report goes out once. +func TestTeamWrapUpBusyDecisionsIsTriedAgain(t *testing.T) { + every := teamWatchEvery + teamWatchEvery = time.Hour + t.Cleanup(func() { teamWatchEvery = every }) + fixture := newTeamFixture(t, true) + stubCapSpend(t, &capSpend{usd: 0.5, stamp: "s1"}) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + appendTraffic(t, fixture, teams.WrapUpRequest("Wrap up first")) + manager.teamBoundary() + release := holdDecisions(t, fixture.profile, fixture.teamID) + past := time.Now().Add(wrapUpFor) + manager.teamWrapUpDue(fixture.profile, past) + manager.team.mu.Lock() + _, due := manager.team.wraps[fixture.teamID] + manager.team.mu.Unlock() + if !due { + t.Fatal("a raise that could not take the decisions lock forgot the wrap-up") + } + f, err := teams.Load(fixture.profile) + if err != nil { + t.Fatal(err) + } + if team, _ := f.Team(fixture.teamID); team.Wrap == nil { + t.Fatal("a failed raise cleared the clock on disk") + } + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 0 { + t.Fatalf("a failed raise still left a report: %+v", waiting) + } + release() + manager.teamWrapUpDue(fixture.profile, past) + if waiting, _, err := teams.OpenPackets(fixture.profile, teams.Person); err != nil || len(waiting) != 1 { + t.Fatalf("the next look did not raise the one report: %+v %v", waiting, err) + } + f, err = teams.Load(fixture.profile) + if err != nil { + t.Fatal(err) + } + if team, _ := f.Team(fixture.teamID); team.Wrap != nil { + t.Fatalf("the clock was left on the team: %+v", team.Wrap) + } + manager.team.mu.Lock() + _, still := manager.team.wraps[fixture.teamID] + manager.team.mu.Unlock() + if still { + t.Fatal("a sent report left the clock in memory") + } + manager.teamWrapUpDue(fixture.profile, past.Add(time.Minute)) + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 1 { + t.Fatal("the report was raised twice") + } +} + +// A WRAP-UP ALREADY PAST ITS BOUND CLOSES ON THE START, and only once. +func TestTeamWrapUpPastItsBoundClosesOnceOnStart(t *testing.T) { + fixture := newTeamFixture(t, true) + stubCapSpend(t, &capSpend{usd: 0.5, stamp: "s1"}) + started := time.Now().Add(-20 * time.Minute).UTC() + if err := teams.Update(fixture.profile, func(f *teams.File) error { + return f.SetWrap(fixture.teamID, started, 15*time.Minute) + }); err != nil { + t.Fatal(err) + } + first := teamAgent(t, fixture, fixture.manager, nil, nil) + p := onlyPacket(t, fixture.profile, teams.Person) + if p.Kind != teams.PacketClosing || p.Report == nil || !p.Report.Incomplete || + !strings.Contains(p.Question, "wrap-up incomplete") { + t.Fatalf("a past wrap-up did not close on start: %+v", p) + } + f, _ := teams.Load(fixture.profile) + if team, _ := f.Team(fixture.teamID); team.Wrap != nil { + t.Fatalf("the finished clock was left on the team: %+v", team.Wrap) + } + if err := first.Close(); err != nil { + t.Fatal(err) + } + _ = teamAgent(t, fixture, fixture.manager, nil, nil) + if waiting, _, _ := teams.OpenPackets(fixture.profile, teams.Person); len(waiting) != 1 { + t.Fatal("a second start closed the team again") + } +} + +// THE PROFILE'S teams.wake IS THE DEFAULT A TEAM WITH NO OVERRIDE TAKES. +func TestTeamWakeFollowsTheProfileDefault(t *testing.T) { + fixture := newWakingTeamFixture(t) + web := teamAgent(t, fixture, fixture.web, nil, nil) + if roles := web.teamRoles(); len(roles) != 1 || !roles[0].wakes { + t.Fatalf("a team with no override does not wake by default: %+v", roles) + } + if err := os.WriteFile(filepath.Join(fixture.profile, "config.json"), []byte(`{"teams.wake": false}`), 0o600); err != nil { + t.Fatal(err) + } + // The config's stamp moves; the teams file's does not. + later := time.Now().Add(2 * time.Second) + _ = os.Chtimes(filepath.Join(fixture.profile, "config.json"), later, later) + if roles := web.teamRoles(); len(roles) != 1 || roles[0].wakes { + t.Fatalf("teams.wake off did not reach the role: %+v", roles) + } +} + +// AT THE CAP A DIRECTIVE WAKES NOBODY: the member is held, the Traffic says +// so, and the person is asked once. +func TestTeamACapHoldsAWake(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + five := 5.0 + if err := teams.Update(fixture.profile, func(f *teams.File) error { + return f.SetSettings(fixture.teamID, func(s *teams.Settings) { s.CapUSDDay = &five }) + }); err != nil { + t.Fatal(err) + } + stubCapSpend(t, &capSpend{usd: 6, stamp: "s1"}) + webAnswers := oneAnswer(1) + teamAgent(t, fixture, fixture.web, webAnswers, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}) + deadline := time.Now().Add(teamWakeSettle + 40*teamWatchEvery) + held := false + for time.Now().Before(deadline) && !held { + log, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", 0) + for _, entry := range log { + held = held || strings.HasPrefix(entry.Text, "held @web: harbor reached its $5 cap today") + } + time.Sleep(teamWatchEvery) + } + if !held { + t.Fatal("the Traffic never said the wake was held") + } + if webAnswers.requests() != 0 { + t.Fatal("a member at the cap was woken") + } + onlyPacket(t, fixture.profile, teams.Person) +} diff --git a/internal/session/team_nest.go b/internal/session/team_nest.go new file mode 100644 index 0000000000..372cfae9e9 --- /dev/null +++ b/internal/session/team_nest.go @@ -0,0 +1,698 @@ +package session + +// ── NESTED TEAMS: SUB-TEAMS, CONFLICTS, ONE LEVEL, AND THE GLOBAL MANAGER ──── +// +// The rulings (c-5, c-6, c-7; docs/design/conversations-and-teams/DESIGN.md, +// section 8): work is handed down a tree of teams and decisions travel up it. +// This file is the session's half of the tree: +// +// - A SUB-TEAM IS STARTED LIKE A MEMBER. `team_start` of kind team makes the +// child team in the store under the manager's team (refused past the +// effective depth limit or under a closed team, with the reason), writes +// its share of the pool on it ([teams.File.SubTeamCap]), moves in the +// members it names, and writes ONE start to the parent's Traffic, the start +// the interface already carries out: it opens the new conversation behind +// the one in front and adds it to the parent team under its handle. The +// start names the child ([teams.Entry.Team]), and the new conversation, +// reading its brief at its first boundary, makes itself the child's manager +// ([Agent.claimSubTeams]). So its manager is a member of the parent and +// reports up by the ordinary home rule, and the interface needs nothing new. +// - A CONFLICT IS DECLARED, NEVER DETECTED. `team_raise` names the other +// parties by handle (across teams as `team/@handle`), finds the lowest +// common managed ancestor of all of them ([teams.File.LCA]), and raises a +// conflict packet there, or to the person when there is none. That manager +// is woken by the packet line and handed the packet whole; it decides with +// `team_decide` or sends it up with `team_escalate`, never sideways; and the +// store turns the decision into a directive to every party in its own team's +// log ([teams.IsRuling]), which wakes it. +// - ORDERS GO ONE LEVEL DOWN. A manager's directive and stop reach its own +// team's members, a sub-team's manager among them, and never a sub-team's +// members: a handle that names one is refused with the sentence that points +// to that sub-team's manager ([subTeamPointer]). +// - THE GLOBAL MANAGER is the manager of the root team (teams' root.go). The +// store seats every top-level manager as a member of the root, so its +// verbs, its delivery and its members' homes are the ordinary ones; its view +// of its team is only those managers ([managedView]), never their chats. +// - A SUB-TEAM WITH NO MANAGER OF ITS OWN answers to the nearest manager above +// it for questions and for `team_post` to the manager ([bossOf]); orders do +// not reach it, because its members are not that manager's members. + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "strconv" + "strings" + "time" + + "github.com/Agent-Field/codeaf/internal/exec/bare" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// bossOf is the managed team a member of team with key answers to: team +// itself when it has a manager, and otherwise the nearest open ancestor whose +// manager is not key. "" is none. +func bossOf(file *teams.File, team teams.Team, key string) (string, string) { + if team.Manager != "" { + return team.ID, team.Name + } + for _, up := range file.Ancestors(team.ID) { + if up.Closed() || up.Manager == "" || up.Manager == key { + continue + } + return up.ID, up.Name + } + return "", "" +} + +// managedView is team as its manager runs it. For the root team it is its +// manager and the top-level managers ([teams.File.TopManagers]) and nobody +// else, so the global manager's digest, roster and verbs see only the managers +// it directs; every other team is itself. +func managedView(file *teams.File, team teams.Team) teams.Team { + if file == nil || !team.Root { + return team + } + view := team.Clone() + view.Members = nil + if m, ok := team.Member(team.Manager); ok { + view.Members = append(view.Members, m) + } + view.Members = append(view.Members, file.TopManagers()...) + return view +} + +// subTeamPointer is the refusal for a handle that is not one of team's own +// members but names a member of a team under it, "" when it names nobody +// there. Orders go one level down: it names the sub-team's manager to send to +// instead, or says that sub-team has none. +func subTeamPointer(file *teams.File, team teams.Team, handle, what string) string { + if file == nil { + return "" + } + handle = strings.TrimPrefix(strings.ToLower(strings.TrimSpace(handle)), "@") + for _, below := range file.Descendants(team.ID) { + if below.Closed() { + continue + } + member, ok := below.ByHandle(handle) + if !ok { + continue + } + // The team one level under team on the way down to below is the one + // whose manager takes team's orders. + child := below + for _, up := range file.Ancestors(below.ID) { + if up.ID == team.ID { + break + } + child = up + } + if member.Key == below.Manager && below.ID == child.ID { + return fmt.Sprintf("@%s manages %q, a team under yours, but is not a member of %q, so it is not yours to send %s. "+ + "Nothing was sent. Ask the person to add it to %q; until then send it nothing but raise what matters with team_raise.", handle, below.Name, team.Name, what, team.Name) + } + for _, level := range append([]teams.Team{below}, file.Ancestors(below.ID)...) { + if level.ID == team.ID { + break + } + if level.Manager == "" || level.Manager == member.Key { + continue + } + boss := "its manager" + if m, ok := team.Member(level.Manager); ok && m.Handle != "" { + boss = "@" + m.Handle + } else if m, ok := level.Member(level.Manager); ok && m.Handle != "" { + boss = "@" + m.Handle + } + return fmt.Sprintf("@%s is in %q, a team under yours, and orders go one level down: it takes them from the manager of %q, not from you. "+ + "Nothing was sent. Send %s to %s, which passes on what it should.", handle, below.Name, level.Name, what, boss) + } + return fmt.Sprintf("@%s is in %q, a team under yours with no manager of its own. It asks you its questions and posts to you, but orders go only to your own members. "+ + "Nothing was sent. Ask the person to give %q a manager, or to move @%s into %q.", handle, below.Name, below.Name, handle, team.Name) + } + return "" +} + +// ── team_start of kind team ───────────────────────────────────────────────── + +// errNest is a sub-team start refused inside the store's write, in the words +// the model is handed. +type errNest string + +func (e errNest) Error() string { return string(e) } + +// teamStartSubTeam makes the child team under team, moves in the members +// named, and writes the start that opens its manager. It answers what to hand +// the model and whether that is a refusal. +func (a *Agent) teamStartSubTeam(team teams.Team, role teamRole, handle, brief, name string, moving []string) (string, bool) { + profile := a.config.teamProfile() + name = strings.Join(strings.Fields(name), " ") + if name == "" { + return invalidArgumentsPrefix + "a team needs its name", true + } + if reason := a.teamCapHold(profile, []teamRole{role}); reason != "" { + return "No sub-team starts: " + reason + ".", true + } + d := a.teamDefaults(profile) + a.team.mu.Lock() + keys := append([]string(nil), a.teamKeysLocked()...) + a.team.mu.Unlock() + var ( + childID string + capUSD float64 + moved []string + pool string + movedIn []teams.MoveNotice + ) + err := teams.Update(profile, func(f *teams.File) error { + snap := &teams.File{Teams: make([]teams.Team, len(f.Teams))} + for i, t := range f.Teams { + snap.Teams[i] = t.Clone() + } + parent, ok := f.Team(team.ID) + if !ok || !teamHoldsKey(keys, parent.Manager) { + return errNest("This conversation is not the manager of " + strconv.Quote(team.Name) + " now. Nothing was done.") + } + if parent.Closed() { + return errNest(fmt.Sprintf("%q is closed, and a closed team starts nothing. Nothing was done.", parent.Name)) + } + if !f.CanNest(parent.ID, d) { + e := f.Effective(parent.ID, d) + from := e.DepthFrom.Words() + if from == "" { + from = "its own setting" + } + return errNest(fmt.Sprintf("A team under %q would be level %d, past its depth limit of %d (%s). Nothing was done: hand the work to a member instead, or ask the person to raise the limit.", + parent.Name, f.Depth(parent.ID)+1, e.DepthLimit, from)) + } + if _, taken := parent.ByHandle(handle); taken { + return errNest(fmt.Sprintf("@%s is already a member of %q. Pick another handle for the new team's manager.", handle, parent.Name)) + } + for _, other := range f.Teams { + if !other.Closed() && strings.EqualFold(other.Name, name) { + return errNest(fmt.Sprintf("There is already a team called %q. Pick another name.", other.Name)) + } + } + var members []teams.Member + for _, h := range moving { + m, ok := teamMemberByHandle(parent, h) + if !ok || m.Key == parent.Manager { + return errNest(fmt.Sprintf("No member of %q has the handle %q to move in. Its members are: %s. Nothing was done.", parent.Name, h, teamHandles(parent, parent.Manager))) + } + if where := reportsElsewhere(f, parent, m); where != "" { + return errNest(fmt.Sprintf("@%s reports to the manager of %q, not to you, so it is not yours to move. Nothing was done.", m.Handle, where)) + } + members = append(members, m) + } + child := teams.Team{ID: teams.NewID(), Name: name, Parent: parent.ID, Made: time.Now()} + f.Teams = append(f.Teams, child) + if share := f.SubTeamCap(parent.ID, d); share > 0 { + if err := f.SetSettings(child.ID, func(s *teams.Settings) { s.CapUSDDay = &share }); err != nil { + return err + } + capUSD = share + } else if owner, cap := capPool(f, parent.ID, d); cap > 0 { + pool = owner.Name + } + for _, m := range members { + m.Home, m.Started = false, false + if err := f.AddMember(child.ID, m); err != nil { + return err + } + if err := f.RemoveMember(parent.ID, m.Key); err != nil { + return err + } + moved = append(moved, "@"+m.Handle) + } + childID = child.ID + movedIn = teams.MemberMoveNotices(snap, f) + return nil + }) + var refused errNest + if errors.As(err, &refused) { + return string(refused), true + } + if err != nil { + return "The team could not be made: " + err.Error(), true + } + // The members that left this team and joined the new one are told once, + // here, where the membership was written. A refusal returned above and + // wrote nothing. + _ = teams.WriteMoveNotices(profile, movedIn) + start := teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: handle, Text: brief, Team: childID} + if err := teams.AppendTraffic(profile, team.ID, start); err != nil { + return "The team " + strconv.Quote(name) + " was made, but its manager's start could not be written to the traffic: " + err.Error(), true + } + made := fmt.Sprintf("made by the manager of %q; its manager @%s starts on the brief: %s", team.Name, handle, cutRunesTeam(firstLineTeam(brief), 200)) + if len(moved) > 0 { + made += ". Moved in from " + strconv.Quote(team.Name) + ": " + strings.Join(moved, ", ") + } + a.teamSay(profile, childID, teams.Entry{Kind: teams.KindNote, From: teams.FromSystem, To: teams.ToRoom, Text: made}) + money := "It has no cap of its own and none above it." + switch { + case capUSD > 0: + money = fmt.Sprintf("Its cap is $%.2f a day, its share of your team's pool.", capUSD) + case pool != "": + money = fmt.Sprintf("It has no cap of its own and spends from %q's pool.", pool) + } + said := fmt.Sprintf("Made the team %q under %q and asked for its manager @%s. The conversations view opens @%s in %q's folder as a member of %q; it is handed your brief marked as yours, "+ + "makes itself the manager of %q, and reports to you. %s", name, team.Name, handle, handle, team.Name, team.Name, name, money) + if len(moved) > 0 { + said += " Moved in: " + strings.Join(moved, ", ") + "; they are its manager's to direct now, not yours." + } + return said, false +} + +// subTeamClaim is a start this conversation was opened by that names the +// team it is to manage. +type subTeamClaim struct { + team, parent, key string +} + +// subTeamBriefLine is a sub-team start's brief as its manager is handed it: +// the brief, under the words that say what it is to run. +func subTeamBriefLine(file *teams.File, entry teams.Entry, brief string) string { + name, parent := "a new team", "your manager's team" + if file != nil { + if t, ok := file.Team(entry.Team); ok { + name = strconv.Quote(t.Name) + if p, ok := file.Team(t.Parent); ok { + parent = strconv.Quote(p.Name) + } + } + } + return fmt.Sprintf("◆ you were started to manage the team %s, under %s: you run it and report to the manager who started you.\n", name, parent) + brief +} + +// claimSubTeams makes this conversation the manager of each team a start it +// was opened by names, once its brief has been read. It is a member of the +// parent (the interface added it there under its handle), and it is added to +// the child with the same record. A team that has another manager by now, or +// is gone or closed, is left alone, and the parent's Traffic says why. +func (a *Agent) claimSubTeams(profile string, claims []subTeamClaim) { + for _, claim := range claims { + var why string + err := teams.Update(profile, func(f *teams.File) error { + child, ok := f.Team(claim.team) + if !ok || child.Closed() { + why = "the team is gone or closed" + return nil + } + if child.Manager != "" && child.Manager != claim.key { + why = "it has another manager already" + return nil + } + parent, _ := f.Team(claim.parent) + m, ok := parent.Member(claim.key) + if !ok { + m = teams.Member{Key: claim.key} + } + m.Home, m.Started = false, false + if err := f.AddMember(child.ID, m); err != nil { + return err + } + return f.SetManager(child.ID, claim.key) + }) + if err != nil { + why = err.Error() + } + if why != "" { + a.teamSay(profile, claim.parent, teams.Entry{Kind: teams.KindEvent, From: teams.FromSystem, To: teams.ToManager, Member: claim.key, + State: teams.StateFailed, Text: "could not make the new conversation a team's manager: " + why}) + } + } +} + +// ── team_raise ────────────────────────────────────────────────────────────── + +const teamRaiseToolName = "team_raise" + +const teamRaiseDescription = "Raise a conflict you cannot settle with the other side yourself: two or more conversations (you and the parties you name) need incompatible things. " + + "It goes as one decision packet to the lowest manager above all of you who is not one of you, or to the person when there is none, and wakes that manager. " + + "Write it so the decider needs no transcript: the question, your side, and options each with what happens. The ruling comes back to every party as a directive." + +const teamRaiseSchema = `{"type":"object","properties":{` + + `"question":{"type":"string","description":"What must be decided, in one line."},` + + `"parties":{"type":"array","items":{"type":"string"},"description":"The other side(s): a handle like @api, or team/@handle for a member of another team. You are a party already."},` + + `"context":{"type":"string","description":"Your side, in your words."},` + + `"options":{"type":"array","items":{"type":"object","properties":{"label":{"type":"string"},"consequence":{"type":"string","description":"What happens if it is chosen."}},"required":["label","consequence"],"additionalProperties":false},"description":"At least two."},` + + `"recommend":{"type":"string","description":"The option you would pick, by number or label. Optional."},` + + `"reason":{"type":"string","description":"Why, when you recommend one."},` + + teamArgSchema + `},"required":["question","parties","options"],"additionalProperties":false}` + +// raiseTools is the verb every conversation in a managed team has, member or +// manager. +func (a *Agent) raiseTools() []bare.Tool { + return []bare.Tool{ + {Name: teamRaiseToolName, Description: teamRaiseDescription, Schema: json.RawMessage(teamRaiseSchema), Execute: a.teamRaiseTool}, + } +} + +// partyAt is one party found by the words that named it. +type partyAt struct { + member teams.Member + team teams.Team +} + +// resolveParty is the conversation words name: `team/@handle` (a team by name +// or id), or a bare handle looked for first in the teams this conversation is +// in and then in every open team. Several conversations answering one bare +// handle is a refusal that lists them. +func resolveParty(file *teams.File, roles []teamRole, words string) (partyAt, string) { + words = strings.TrimSpace(words) + teamWord, handle := "", words + if i := strings.LastIndex(words, "/"); i >= 0 { + teamWord, handle = strings.TrimSpace(words[:i]), words[i+1:] + } + handle = strings.TrimPrefix(strings.ToLower(strings.TrimSpace(handle)), "@") + if handle == "" { + return partyAt{}, fmt.Sprintf("%q names no handle.", words) + } + var found []partyAt + look := func(t teams.Team) { + if t.Closed() { + return + } + if m, ok := t.ByHandle(handle); ok { + for _, have := range found { + if have.member.Key == m.Key { + return + } + } + found = append(found, partyAt{member: m, team: t}) + } + } + if teamWord != "" { + for _, t := range file.Teams { + if t.ID == teamWord || strings.EqualFold(t.Name, teamWord) { + look(t) + } + } + if len(found) == 0 { + return partyAt{}, fmt.Sprintf("No open team called %q has a member @%s.", teamWord, handle) + } + } else { + for _, role := range roles { + if t, ok := file.Team(role.id); ok { + look(t) + } + } + if len(found) == 0 { + for _, t := range file.Teams { + look(t) + } + } + } + switch len(found) { + case 0: + return partyAt{}, fmt.Sprintf("No team has a member @%s. Name it as team/@handle.", handle) + case 1: + return found[0], "" + } + var named []string + for _, p := range found { + named = append(named, p.team.Name+"/@"+handle) + } + return partyAt{}, fmt.Sprintf("@%s is more than one conversation: %s. Say which as team/@handle.", handle, strings.Join(named, ", ")) +} + +// atOrUnder reports whether team id is top itself or a team under it. +func atOrUnder(file *teams.File, id, top string) bool { + if id == top { + return true + } + for _, up := range file.Ancestors(id) { + if up.ID == top { + return true + } + } + return false +} + +// membershipUnder is key's open membership at or under top: one where it is +// not the manager first, the deepest first among those. "" is none. +func membershipUnder(file *teams.File, key, top string) string { + best, bestManaged, bestDepth := "", true, -1 + for _, t := range file.Teams { + if t.Closed() || !t.Holds(key) || !atOrUnder(file, t.ID, top) { + continue + } + managed := t.Manager == key + depth := len(file.Ancestors(t.ID)) + if best == "" || (bestManaged && !managed) || (managed == bestManaged && depth > bestDepth) { + best, bestManaged, bestDepth = t.ID, managed, depth + } + } + return best +} + +func (a *Agent) teamRaiseTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Question string `json:"question"` + Parties []string `json:"parties"` + Context string `json:"context"` + Options []struct { + Label string `json:"label"` + Consequence string `json:"consequence"` + } `json:"options"` + Recommend string `json:"recommend"` + Reason string `json:"reason"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + question := strings.TrimSpace(parsed.Question) + if question == "" { + return invalidArgumentsPrefix + "question is empty", true, nil + } + if len(parsed.Parties) == 0 { + return invalidArgumentsPrefix + "name the other party or parties", true, nil + } + if len(parsed.Options) < 2 { + return invalidArgumentsPrefix + "a conflict needs at least two options, each with what happens", true, nil + } + var options []teams.Option + for i, o := range parsed.Options { + label, consequence := strings.TrimSpace(o.Label), strings.TrimSpace(o.Consequence) + if label == "" || consequence == "" { + return invalidArgumentsPrefix + "every option needs a label and what happens if it is chosen", true, nil + } + options = append(options, teams.Option{ID: strconv.Itoa(i + 1), Label: label, Consequence: consequence}) + } + var recommendation *teams.Recommendation + if pick := strings.TrimSpace(parsed.Recommend); pick != "" { + for _, o := range options { + if o.ID == pick || strings.EqualFold(o.Label, pick) { + reason := strings.TrimSpace(parsed.Reason) + if reason == "" { + reason = "the raiser's own pick" + } + recommendation = &teams.Recommendation{Option: o.ID, Reason: reason} + } + } + if recommendation == nil { + return invalidArgumentsPrefix + "recommend names none of the options", true, nil + } + } + profile := a.config.teamProfile() + if profile == "" { + return "This conversation is not in a team.", true, nil + } + file, keys, roles, d := a.teamSnapshot(profile) + if file == nil { + return "The teams file could not be read.", true, nil + } + var mine []teamRole + for _, role := range roles { + if role.managed { + mine = append(mine, role) + } + } + if want := strings.TrimSpace(parsed.Team); want != "" { + var chosen []teamRole + for _, role := range mine { + if role.id == want || strings.EqualFold(role.name, want) { + chosen = append(chosen, role) + } + } + mine = chosen + } + if len(mine) == 0 { + return "This conversation is in no team with a manager now, so there is nobody to raise a conflict to. Ask the person.", true, nil + } + // The raiser's own membership: a member's before a manager's, because a + // manager's conflict with another team is its team's, raised from where it + // is a member. + role := mine[0] + for _, r := range mine { + if !r.manager { + role = r + break + } + } + if role.handle == "" { + return "You have no handle in " + strconv.Quote(role.name) + " yet, so the decider could not tell who raised it. It is given once this conversation has a title.", true, nil + } + parties := []teams.Party{{Key: role.key, Handle: role.handle, Team: role.id, Context: strings.TrimSpace(parsed.Context)}} + partyKeys := []string{role.key} + for _, words := range parsed.Parties { + at, refusal := resolveParty(file, roles, words) + if refusal != "" { + return refusal + " Nothing was raised.", true, nil + } + if teamHoldsKey(keys, at.member.Key) { + return "You named yourself; you are a party already. Name the other side. Nothing was raised.", true, nil + } + if teamHoldsKey(partyKeys, at.member.Key) { + continue + } + partyKeys = append(partyKeys, at.member.Key) + parties = append(parties, teams.Party{Key: at.member.Key, Handle: at.member.Handle, Team: at.team.ID}) + } + decider, deciderName := teams.Person, "the person" + origin := role.id + var lca teams.Team + if at, ok := file.LCA(partyKeys...); ok { + lca = at + decider = at.ID + deciderName = fmt.Sprintf("the manager of %q", at.Name) + if m, ok := at.Member(at.Manager); ok && m.Handle != "" { + deciderName += " (@" + m.Handle + ")" + } + // Every party's line of the packet runs through a membership under the + // decider, so the origin is below it and each ruling lands in a team + // the party reads. + if !atOrUnder(file, origin, at.ID) { + origin = membershipUnder(file, role.key, at.ID) + } + parties[0].Team = origin + for i := 1; i < len(parties); i++ { + if !atOrUnder(file, parties[i].Team, at.ID) { + if under := membershipUnder(file, parties[i].Key, at.ID); under != "" { + parties[i].Team = under + } + } + } + } + if origin == "" { + origin = role.id + } + raised, err := teams.Raise(profile, teams.Packet{ + Team: decider, Origin: origin, Kind: teams.PacketConflict, RaisedBy: role.handle, + Parties: parties, Question: question, Options: options, Recommendation: recommendation, + }) + if err != nil { + return "The conflict could not be raised: " + teamErrorWords(err), true, nil + } + if lca.ID != "" { + if m, ok := lca.Member(lca.Manager); ok { + a.teamRouse(profile, lca, file.Effective(lca.ID, d).Wake, []teams.Member{m}, "") + } + } + var others []string + for _, p := range parties[1:] { + who := "@" + p.Handle + if t, ok := file.Team(p.Team); ok && p.Team != role.id { + who += " (" + t.Name + ")" + } + others = append(others, who) + } + return fmt.Sprintf("Raised conflict %s with %s for %s to decide. The ruling comes to every party, you included, as a directive and starts your turn if you are idle; "+ + "carry on with what does not depend on it, or end your turn and wait.", raised.ID, strings.Join(others, ", "), deciderName), false, nil +} + +// ── delivery ──────────────────────────────────────────────────────────────── + +// rulingFor reports whether a ruling entry ([teams.IsRuling]) is addressed to +// this conversation's membership: by its key, or by its handle when it +// carries none. +func rulingFor(role teamRole, entry teams.Entry) bool { + if !teams.IsRuling(entry) { + return false + } + if entry.Member != "" { + return entry.Member == role.key + } + return role.handle != "" && entry.To == role.handle +} + +// rulingLine is a ruling as its party is told it. It is binding whoever wrote +// it: a conflict's decider outranks the parties' own managers on the question +// it decided, and only the person outranks the decider. +func rulingLine(entry teams.Entry) string { + return "◆ " + indentAfterFirst(cutRunesTeam(strings.TrimSpace(entry.Text), teamEntryText)) + + " Follow it unless the person said otherwise in this conversation." +} + +// partyTold is a conflict newly raised, as a party that did not raise it is +// told it (without a wake): who raised it and who decides it. "" for anyone +// else. +func partyTold(role teamRole, entry teams.Entry, p teams.Packet) string { + if p.Kind != teams.PacketConflict || entry.State != teams.PacketOpen || p.State != teams.PacketOpen { + return "" + } + for i, party := range p.Parties { + if i == 0 || party.Key != role.key || party.Team != role.id { + continue + } + return fmt.Sprintf("◆ @%s raised a conflict naming you (%s), for %s to decide: %s. Its ruling comes to you as a directive.", + strings.TrimPrefix(p.RaisedBy, "@"), p.ID, packetDecider(p), oneLineTeam(p.Question)) + } + return "" +} + +// readableBelow is the member of a team under team that words names +// (team/@handle, or a handle only one conversation under team has), for a +// read. false is nobody there. +func readableBelow(profile string, team teams.Team, words string) (teams.Member, bool) { + file, err := teams.Load(profile) + if err != nil { + return teams.Member{}, false + } + var below []teamRole + for _, t := range file.Descendants(team.ID) { + if !t.Closed() { + below = append(below, teamRole{id: t.ID, name: t.Name}) + } + } + if len(below) == 0 { + return teams.Member{}, false + } + // Only the teams under team are searched: a bare handle looks there, and + // a named team must be one of them. + scoped := &teams.File{Version: file.Version} + for _, role := range below { + if t, ok := file.Team(role.id); ok { + scoped.Teams = append(scoped.Teams, t) + } + } + at, refusal := resolveParty(scoped, below, words) + if refusal != "" { + return teams.Member{}, false + } + return at.member, true +} + +// teamPostUp is a post to the manager from a member of a sub-team with no +// manager of its own: written to the log of the team whose manager it answers +// to, marked with the sub-team it came from, and that manager roused. +func (a *Agent) teamPostUp(team teams.Team, role teamRole, entry teams.Entry) (string, bool, error) { + profile := a.config.teamProfile() + entry.Member = role.key + entry.Text = fmt.Sprintf("(from %q, a team under yours with no manager of its own) %s", team.Name, entry.Text) + if err := teams.AppendTraffic(profile, role.boss, entry); err != nil { + return "The post could not be written to the traffic of " + strconv.Quote(role.bossName) + ": " + err.Error(), true, nil + } + file, _, _, _ := a.teamSnapshot(profile) + if file != nil { + if boss, ok := file.Team(role.boss); ok { + if manager, ok := boss.Member(boss.Manager); ok { + a.teamRouse(profile, boss, file.Effective(boss.ID, a.teamDefaults(profile)).Wake, []teams.Member{manager}, "") + } + } + } + return fmt.Sprintf("Posted to the manager of %q, which %q answers to while it has no manager of its own. It arrives at the start of its next step.", role.bossName, team.Name), false, nil +} diff --git a/internal/session/team_nest_test.go b/internal/session/team_nest_test.go new file mode 100644 index 0000000000..7a4646a08e --- /dev/null +++ b/internal/session/team_nest_test.go @@ -0,0 +1,471 @@ +package session + +// NESTED TEAMS, AS TESTS: a manager starts a sub-team whose manager makes +// itself one on its brief and reports up; orders go one level down and a +// handle below is pointed at its manager; a conflict goes to the lowest +// common manager, is ruled there, and the ruling reaches every party; the +// global manager runs the top-level managers and only them; and a sub-team +// with no manager of its own answers to the one above. Every fixture is a real +// teams.json and real Traffic, through internal/teams. + +import ( + "os" + "path/filepath" + "strings" + "testing" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// teamTree is a profile and a set of named transcripts, each in a session folder +// of its own, for trees the flat fixture cannot draw. +type teamTree struct { + fixture teamFixture + paths map[string]string +} + +func newTeamTree(t *testing.T, names ...string) teamTree { + t.Helper() + root := t.TempDir() + n := teamTree{fixture: teamFixture{profile: filepath.Join(root, "profile")}, paths: map[string]string{}} + for _, name := range names { + dir := filepath.Join(root, "sessions", name) + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + path := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(path, nil, 0o600); err != nil { + t.Fatal(err) + } + n.paths[name] = path + } + return n +} + +// member is the teams record for the transcript called name, with handle. +func (n teamTree) member(t *testing.T, name, handle string) teams.Member { + t.Helper() + path := n.paths[name] + return teams.Member{Key: convKeyOf(t, path), File: path, Word: name + " work", Handle: handle} +} + +func (n teamTree) key(t *testing.T, name string) string { return convKeyOf(t, n.paths[name]) } + +func (n teamTree) agent(t *testing.T, name string) *Agent { + t.Helper() + return teamAgent(t, n.fixture, n.paths[name], nil, nil) +} + +// team adds a team with a manager (by transcript name, "" for none) and +// members, under parent ("" for the top), with the auto-wake off so every +// delivery here is read at the boundaries the test runs. +func (n teamTree) team(t *testing.T, name, parent, manager string, members ...teams.Member) string { + t.Helper() + id := teams.NewID() + must := func(err error) { + if err != nil { + t.Fatal(err) + } + } + must(teams.Update(n.fixture.profile, func(file *teams.File) error { + off := false + team := teams.Team{ID: id, Name: name, Parent: parent} + team.Settings.Wake = &off + file.Teams = append(file.Teams, team) + for _, m := range members { + if err := file.AddMember(id, m); err != nil { + return err + } + } + if manager != "" { + return file.SetManager(id, n.key(t, manager)) + } + return nil + })) + return id +} + +func (n teamTree) file(t *testing.T) *teams.File { + t.Helper() + f, err := teams.Load(n.fixture.profile) + if err != nil { + t.Fatal(err) + } + return f +} + +// ── 1. a sub-team ─────────────────────────────────────────────────────────── + +// team_start OF KIND TEAM makes the child under the manager's team with its +// share of the pool, moves in the members named, writes the start the +// interface carries out, and the conversation it opens makes itself the +// child's manager on its brief and reports up. +func TestTeamStartOfKindTeamMakesASubTeamWhoseManagerReportsUp(t *testing.T) { + n := newTeamTree(t, "boss", "web", "parser", "api") + harbor := n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "web", "web"), n.member(t, "parser", "parser")) + capUSD := 10.0 + if err := teams.Update(n.fixture.profile, func(f *teams.File) error { + return f.SetSettings(harbor, func(s *teams.Settings) { s.CapUSDDay = &capUSD }) + }); err != nil { + t.Fatal(err) + } + boss := n.agent(t, "boss") + boss.teamBoundary() + said, failed := callTool(t, boss.teamStartTool, `{"handle":"api","brief":"Build the signup API.\nDone is a green handler test.","kind":"team","name":"backend","members":["parser"]}`) + if failed || !strings.Contains(said, `Made the team "backend" under "harbor"`) || !strings.Contains(said, "$5.00 a day") || !strings.Contains(said, "Moved in: @parser") { + t.Fatalf("team_start of kind team said %q", said) + } + f := n.file(t) + var backend teams.Team + for _, team := range f.Teams { + if team.Name == "backend" { + backend = team + } + } + if backend.Parent != harbor || !backend.Holds(n.key(t, "parser")) || backend.Settings.CapUSDDay == nil || *backend.Settings.CapUSDDay != 5 { + t.Fatalf("the sub-team: %+v", backend) + } + if h, _ := f.Team(harbor); h.Holds(n.key(t, "parser")) { + t.Fatal("the moved member is still in harbor") + } + log, _ := teams.ReadTraffic(n.fixture.profile, harbor, "", 0) + start := last(log) + if start.Kind != teams.KindStart || start.To != "api" || start.Team != backend.ID { + t.Fatalf("harbor's start line: %+v", start) + } + here, _ := teams.ReadTraffic(n.fixture.profile, backend.ID, "", 0) + if len(here) != 2 || here[0].Text != "@parser joined from harbor" || !strings.Contains(here[1].Text, "its manager @api starts on the brief") { + t.Fatalf("backend's own lines: %+v", here) + } + + // The interface carries out the start: the new conversation joins harbor + // under its handle. + if err := teams.Update(n.fixture.profile, func(f *teams.File) error { + m := n.member(t, "api", "api") + m.Started = true + return f.AddMember(harbor, m) + }); err != nil { + t.Fatal(err) + } + api := n.agent(t, "api") + news := api.teamBoundary() + for _, want := range []string{`◆ you were started to manage the team "backend", under "harbor"`, "◆ brief from manager #2: Build the signup API."} { + if !strings.Contains(news, want) { + t.Errorf("the new manager's first delivery lacks %q:\n%s", want, news) + } + } + f = n.file(t) + backend, _ = f.Team(backend.ID) + if backend.Manager != n.key(t, "api") { + t.Fatalf("the new conversation did not become backend's manager: %+v", backend) + } + if home, _ := f.Home(n.key(t, "api")); home.Team != harbor { + t.Fatalf("backend's manager reports to %+v, want harbor", home) + } + if home, _ := f.Home(n.key(t, "parser")); home.Team != backend.ID { + t.Fatalf("the moved member reports to %+v, want backend", home) + } + api.mu.Lock() + role := api.teamRoleText + api.mu.Unlock() + for _, want := range []string{`You are the manager of the team "backend".`, `Your team is a team under "harbor": you report to its manager, @boss.`, "@parser"} { + if !strings.Contains(role, want) { + t.Errorf("the sub-team manager's role lacks %q:\n%s", want, role) + } + } + if !holds(api, teamStatusToolName) || !holds(api, teamPostToolName) || !holds(api, teamRaiseToolName) { + t.Error("the sub-team manager lacks its verbs") + } + // The parent's manager is told what runs under it. + boss.teamBoundary() + boss.mu.Lock() + role = boss.teamRoleText + boss.mu.Unlock() + if !strings.Contains(role, `Teams under yours: "backend" (run by @api). Direct their managers, never their members.`) { + t.Errorf("harbor's manager is not told what runs under it:\n%s", role) + } +} + +// PAST THE DEPTH LIMIT, a sub-team is refused with the reason, and nothing is +// made. +func TestASubTeamPastTheDepthLimitIsRefusedWithTheReason(t *testing.T) { + n := newTeamTree(t, "boss", "web") + harbor := n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "web", "web")) + one := 1 + if err := teams.Update(n.fixture.profile, func(f *teams.File) error { + return f.SetSettings(harbor, func(s *teams.Settings) { s.DepthLimit = &one }) + }); err != nil { + t.Fatal(err) + } + boss := n.agent(t, "boss") + boss.teamBoundary() + said, failed := callTool(t, boss.teamStartTool, `{"handle":"api","brief":"b","kind":"team","name":"backend"}`) + if !failed || !strings.Contains(said, `A team under "harbor" would be level 2, past its depth limit of 1 (its own setting)`) { + t.Fatalf("a start past the limit said %q (failed %v)", said, failed) + } + if len(n.file(t).Teams) != 1 { + t.Fatal("a refused start made a team") + } + if log, _ := teams.ReadTraffic(n.fixture.profile, harbor, "", 0); len(log) != 0 { + t.Fatalf("a refused start wrote traffic: %+v", log) + } +} + +// ── 3. one level ──────────────────────────────────────────────────────────── + +// ORDERS GO ONE LEVEL DOWN: the sub-team's manager is the parent manager's to +// direct, and its members are not, and the refusal names whom to send to. +func TestOrdersGoOneLevelDownAndPointToTheSubTeamsManager(t *testing.T) { + n := newTeamTree(t, "boss", "api", "parser", "loner") + harbor := n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "api", "api")) + n.team(t, "backend", harbor, "api", n.member(t, "api", "lead"), n.member(t, "parser", "parser")) + n.team(t, "dock", harbor, "", n.member(t, "loner", "loner")) + boss, api, parser := n.agent(t, "boss"), n.agent(t, "api"), n.agent(t, "parser") + for _, a := range []*Agent{boss, api, parser} { + a.teamBoundary() + } + + said, failed := callTool(t, boss.teamSendTool, `{"to":"@parser","text":"use JSON","kind":"directive"}`) + if !failed || !strings.Contains(said, "orders go one level down") || !strings.Contains(said, "Send a message to @api") { + t.Fatalf("a directive to a grandchild said %q", said) + } + said, failed = callTool(t, boss.teamStopTool, `{"handle":"parser"}`) + if !failed || !strings.Contains(said, "Send a stop to @api") { + t.Fatalf("a stop of a grandchild said %q", said) + } + said, failed = callTool(t, boss.teamSendTool, `{"to":"loner","text":"x","kind":"directive"}`) + if !failed || !strings.Contains(said, "no manager of its own") { + t.Fatalf("a directive into an unmanaged sub-team said %q", said) + } + // The sub-team's manager itself is a member, and takes the directive. + if said, failed = callTool(t, boss.teamSendTool, `{"to":"api","text":"ship it","kind":"directive"}`); failed { + t.Fatalf("a directive to the sub-team's manager was refused: %q", said) + } + if news := api.teamBoundary(); !strings.Contains(news, "◆ directive from manager #1: ship it") { + t.Fatalf("the sub-team's manager did not get its manager's directive:\n%s", news) + } + // Everyone is the manager's own members only. + callTool(t, boss.teamSendTool, `{"to":"everyone","text":"standup","kind":"note"}`) + if news := parser.teamBoundary(); strings.Contains(news, "standup") { + t.Fatalf("a grandchild was handed its grandparent's note to everyone:\n%s", news) + } + // A read reaches down the tree. + if said, failed = callTool(t, boss.teamReadTool, `{"handle":"backend/@parser"}`); failed { + t.Fatalf("a read of a member below was refused: %q", said) + } +} + +// ── 2. conflicts ──────────────────────────────────────────────────────────── + +// siblingSubTeams is harbor (boss) over front (lead; web) and back (chief; +// api), each sub-team's manager a member of harbor. +func siblingSubTeams(t *testing.T) (teamTree, string, string, string) { + t.Helper() + n := newTeamTree(t, "boss", "lead", "chief", "web", "api") + harbor := n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "lead", "lead"), n.member(t, "chief", "chief")) + front := n.team(t, "front", harbor, "lead", n.member(t, "lead", "lead"), n.member(t, "web", "web")) + back := n.team(t, "back", harbor, "chief", n.member(t, "chief", "chief"), n.member(t, "api", "api")) + return n, harbor, front, back +} + +// A CONFLICT BETWEEN MEMBERS OF SIBLING SUB-TEAMS lands at their common +// parent's manager, which is handed it whole and rules; both parties receive +// the ruling as a directive, and it wakes them. +func TestAConflictBetweenSiblingSubTeamsIsRuledByTheirCommonManager(t *testing.T) { + n, harbor, front, back := siblingSubTeams(t) + web, api, boss, lead := n.agent(t, "web"), n.agent(t, "api"), n.agent(t, "boss"), n.agent(t, "lead") + for _, a := range []*Agent{web, api, boss, lead} { + a.teamBoundary() + } + if !holds(web, teamRaiseToolName) { + t.Fatal("a member was not offered team_raise") + } + said, failed := callTool(t, web.teamRaiseTool, `{"question":"which shape does the signup form send?","parties":["back/@api"],"context":"the form posts JSON",`+ + `"options":[{"label":"JSON","consequence":"@api changes the handler"},{"label":"form data","consequence":"@web rewrites the submit"}],"recommend":"JSON","reason":"matches the rest"}`) + if failed || !strings.Contains(said, `with @api (back) for the manager of "harbor" (@boss) to decide`) { + t.Fatalf("team_raise said %q", said) + } + p := onlyPacket(t, n.fixture.profile, harbor) + if p.Kind != teams.PacketConflict || p.Origin != front || len(p.Parties) != 2 || p.Parties[1].Team != back || p.Recommendation == nil { + t.Fatalf("the packet: %+v", p) + } + if mine, _, _ := teams.OpenPackets(n.fixture.profile, teams.Person); len(mine) != 0 { + t.Fatal("a conflict with a common manager reached the person") + } + // Not the sub-teams' managers: each is below the other party. + if news := lead.teamBoundary(); strings.Contains(news, p.ID) { + t.Fatalf("a party's own manager was handed the conflict:\n%s", news) + } + news := boss.teamBoundary() + for _, want := range []string{"◆ conflict " + p.ID + " from @web, waiting on you", "parties: @web, @api", "@web says: the form posts JSON", "[1] JSON: @api changes the handler"} { + if !strings.Contains(news, want) { + t.Errorf("the deciding manager's delivery lacks %q:\n%s", want, news) + } + } + if told := api.teamBoundary(); !strings.Contains(told, "◆ @web raised a conflict naming you ("+p.ID+")") { + t.Errorf("the other party was not told:\n%s", told) + } + // A party's manager may not decide it: it does not wait on lead's team. + if said, failed := callTool(t, lead.teamDecideTool, `{"packet":"`+p.ID+`","answer":"2"}`); !failed { + t.Fatalf("a party's own manager decided it: %q", said) + } + if said, failed := callTool(t, boss.teamDecideTool, `{"packet":"`+p.ID+`","answer":"1","reason":"the other endpoints take JSON"}`); failed { + t.Fatalf("the common manager could not decide: %q", said) + } + for name, a := range map[string]*Agent{"web": web, "api": api} { + got := a.teamBoundary() + for _, want := range []string{"◆ ruling on the conflict " + p.ID, `by ◆ @boss (manager of "harbor"): JSON: @api changes the handler`, "the other endpoints take JSON"} { + if !strings.Contains(got, want) { + t.Errorf("@%s's ruling lacks %q:\n%s", name, want, got) + } + } + if strings.Contains(got, "◆ answered") { + t.Errorf("@%s was handed the ruling twice:\n%s", name, got) + } + } + // Each ruling is in its party's team log, and wakes that party. + for team, handle := range map[string]string{front: "web", back: "api"} { + log, _ := teams.ReadTraffic(n.fixture.profile, team, "", 0) + ruling := last(log) + role := teamRole{id: team, handle: handle, managed: true, key: n.key(t, handle)} + if !teams.IsRuling(ruling) || !teamWakes(role, ruling) { + t.Errorf("%s's ruling does not wake @%s: %+v", team, handle, ruling) + } + } +} + +// NO COMMON MANAGER IS THE PERSON: two top-level teams with no root. +func TestAConflictWithNoCommonManagerGoesToThePerson(t *testing.T) { + n := newTeamTree(t, "boss", "yard", "web", "api") + n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "web", "web")) + n.team(t, "dock", "", "yard", n.member(t, "yard", "yard"), n.member(t, "api", "api")) + web := n.agent(t, "web") + web.teamBoundary() + said, failed := callTool(t, web.teamRaiseTool, `{"question":"who owns the schema?","parties":["@api"],"options":[{"label":"web","consequence":"web owns it"},{"label":"api","consequence":"api owns it"}]}`) + if failed || !strings.Contains(said, "for the person to decide") { + t.Fatalf("team_raise said %q", said) + } + onlyPacket(t, n.fixture.profile, teams.Person) +} + +// ── 4. the global manager ─────────────────────────────────────────────────── + +// THE GLOBAL MANAGER runs the top-level managers and only them: its digest and +// status list them, never their members; a directive reaches a top-level +// manager as its manager's; a member below is pointed at its manager; a +// top-level manager's own question goes to it before the person; and it +// starts top-level teams. +func TestTheGlobalManagerRunsTheTopLevelManagersOnly(t *testing.T) { + n := newTeamTree(t, "gm", "boss", "yard", "web", "api", "hq") + harbor := n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "web", "web")) + n.team(t, "dock", "", "yard", n.member(t, "yard", "yard"), n.member(t, "api", "api")) + root := "" + if err := teams.Update(n.fixture.profile, func(f *teams.File) error { + root = f.MakeRoot(f.Teams[0].Made) + off := false + if err := f.SetSettings(root, func(s *teams.Settings) { s.Wake = &off }); err != nil { + return err + } + if err := f.AddMember(root, n.member(t, "gm", "all")); err != nil { + return err + } + return f.SetManager(root, n.key(t, "gm")) + }); err != nil { + t.Fatal(err) + } + gm, boss := n.agent(t, "gm"), n.agent(t, "boss") + gm.teamBoundary() + boss.teamBoundary() + gm.mu.Lock() + role := gm.teamRoleText + gm.mu.Unlock() + for _, want := range []string{"You are the global manager", "@boss", "@yard"} { + if !strings.Contains(role, want) { + t.Errorf("the global manager's role lacks %q:\n%s", want, role) + } + } + if strings.Contains(role, "@web") || strings.Contains(role, "@api") { + t.Errorf("the global manager was handed the teams' members:\n%s", role) + } + status, _ := callTool(t, gm.teamStatusTool, `{}`) + if !strings.Contains(status, "@boss") || strings.Contains(status, "@web") { + t.Errorf("the global manager's status:\n%s", status) + } + if said, failed := callTool(t, gm.teamSendTool, `{"to":"web","text":"x","kind":"directive"}`); !failed || !strings.Contains(said, "Send a message to @boss") { + t.Fatalf("a directive past the top-level managers said %q", said) + } + if said, failed := callTool(t, gm.teamSendTool, `{"to":"boss","text":"ship harbor first","kind":"directive"}`); failed { + t.Fatalf("a directive to a top-level manager was refused: %q", said) + } + news := boss.teamBoundary() + if !strings.Contains(news, "◆ directive from manager #1: ship harbor first") { + t.Fatalf("the top-level manager did not get the global manager's directive:\n%s", news) + } + boss.mu.Lock() + role = boss.teamRoleText + boss.mu.Unlock() + if !strings.Contains(role, `Your team is a top-level team, under the global manager of "All teams": you report to its manager, @all.`) { + t.Errorf("the top-level manager is not told whom it reports to:\n%s", role) + } + // Its own question goes to the global manager, not the person. + said, _ := callTool(t, boss.executeAsk, clarifying) + if strings.Contains(said, "the person's inbox") { + t.Fatalf("a top-level manager's question skipped the global manager: %q", said) + } + if p := onlyPacket(t, n.fixture.profile, root); p.RaisedBy == "" { + t.Fatalf("the packet: %+v", p) + } + // It starts a top-level team. + said, failed := callTool(t, gm.teamStartTool, `{"handle":"ops","brief":"Run the ops.","kind":"team","name":"ops"}`) + if failed { + t.Fatalf("the global manager could not start a top-level team: %q", said) + } + f := n.file(t) + for _, team := range f.Teams { + if team.Name == "ops" && (team.Parent != root || f.Depth(team.ID) != 1) { + t.Fatalf("the new team is not top-level: %+v", team) + } + } + _ = harbor +} + +// ── 5. a sub-team with no manager ─────────────────────────────────────────── + +// A MEMBER OF A SUB-TEAM WITH NO MANAGER answers to the nearest manager above +// it: it has the member's verb, its post to the manager reaches that manager, +// and its question goes there as a packet from its own team. +func TestAnUnmanagedSubTeamsMemberAnswersToTheManagerAbove(t *testing.T) { + n := newTeamTree(t, "boss", "web", "loner") + harbor := n.team(t, "harbor", "", "boss", n.member(t, "boss", "boss"), n.member(t, "web", "web")) + dock := n.team(t, "dock", harbor, "", n.member(t, "loner", "loner")) + loner, boss := n.agent(t, "loner"), n.agent(t, "boss") + loner.teamBoundary() + boss.teamBoundary() + if !holds(loner, teamPostToolName) { + t.Fatal("a member of an unmanaged sub-team has no team_post") + } + loner.mu.Lock() + role := loner.teamRoleText + loner.mu.Unlock() + if !strings.Contains(role, `You are @loner in the team "dock", which has no manager of its own, so you answer to the manager of "harbor"`) { + t.Errorf("its role:\n%s", role) + } + said, failed := callTool(t, loner.teamPostTool, `{"to":"manager","text":"the dock is done"}`) + if failed || !strings.Contains(said, `Posted to the manager of "harbor"`) { + t.Fatalf("team_post to the manager said %q", said) + } + log, _ := teams.ReadTraffic(n.fixture.profile, harbor, "", 0) + if post := last(log); post.From != "loner" || post.To != teams.ToManager || !strings.Contains(post.Text, `(from "dock"`) { + t.Fatalf("harbor's log: %+v", post) + } + if news := boss.teamBoundary(); !strings.Contains(news, "from @loner") || !strings.Contains(news, "the dock is done") { + t.Fatalf("harbor's manager was not handed the post:\n%s", news) + } + said, _ = callTool(t, loner.executeAsk, clarifying) + if !strings.Contains(said, "went to your manager (@boss") { + t.Fatalf("its question said %q", said) + } + if p := onlyPacket(t, n.fixture.profile, harbor); p.Origin != dock || p.RaisedBy != "loner" { + t.Fatalf("the question's packet: %+v", p) + } +} diff --git a/internal/session/team_questions.go b/internal/session/team_questions.go new file mode 100644 index 0000000000..abd1f89040 --- /dev/null +++ b/internal/session/team_questions.go @@ -0,0 +1,553 @@ +package session + +// ── QUESTIONS GO UP AS DECISION PACKETS ───────────────────────────────────── +// +// The ruling (c-5, c-7): the person talks to the top manager and steps away, +// so a member's clarifying question goes to the manager it reports to first +// (its HOME, teams' home.go), and only what no manager may or can decide +// reaches the person. Whatever travels up travels as one self-contained +// DECISION PACKET ([teams.Packet]): the question, the asker's context, the +// options each with what happens if it is chosen, and the asker's own pick +// with its reason, so whoever decides it never has to read a transcript. +// +// THE ROAD, end to end: +// +// - A member calls `ask` with a clarifying question (a clarification, a +// choice or a confirmation) while `questions_up` is on for the team it +// reports to ([teams.Effective], inherited). Nothing is put on the +// person's screen: [Agent.askUp] raises a question packet addressed to +// the home manager's team and hands the model back a sentence saying +// so. The call does not park: a manager may take minutes, and a tool call +// parked across two conversations is a turn nobody can stop cleanly. +// - The raise appends a [teams.KindPacket] line to the team's Traffic, and +// the manager's traffic watch wakes it on that line +// ([Agent.teamPacketWakes]); its delivery hands it the packet whole +// ([teamPacketLine]). +// - The manager answers with `team_decide`, or sends it up with +// `team_escalate` to its own manager or to the person. The decision is one +// more packet line, which wakes the member and is delivered to it marked +// `◆ answered: …`, and the Traffic rail reads `answered @web: …`. +// +// PERMISSION PROMPTS NEVER TAKE THIS ROAD. They are the approval gate's, not +// `ask`'s, and a manager may not answer one (section 5 of the design); only the +// kinds in [askGoesUp] do, and a permission kind written into `ask` stays the +// person's. +// +// A MANAGER'S OWN QUESTION is a packet too: to its own home manager when it has +// one and questions go up there, and otherwise to the person (addressed +// [teams.Person], `you`), where the teams page's inbox shows it. The person's +// decision reaches the manager by the same delivery and wakes it. + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "strconv" + "strings" + + "github.com/Agent-Field/codeaf/internal/exec/bare" + "github.com/Agent-Field/codeaf/internal/teams" +) + +const ( + teamDecideToolName = "team_decide" + teamEscalateToolName = "team_escalate" +) + +const teamDecideDescription = "Decide a decision packet waiting on you: a member's question, or anything your members raised to you. " + + "answer is one of the packet's option ids, or your own words when no option fits. The asker is handed your answer marked as yours and continues. " + + "You cannot decide a cap or a closing report; those are the person's." + +const teamDecideSchema = `{"type":"object","properties":{"packet":{"type":"string","description":"The packet id, like p1a2b3c4d5e6f."},` + + `"answer":{"type":"string","description":"An option id, or your own answer."},` + + `"reason":{"type":"string","description":"One line: why."},` + + teamArgSchema + `},"required":["packet","answer"],"additionalProperties":false}` + +const teamEscalateDescription = "Send a decision packet waiting on you up the tree when it is not yours to decide: to your own manager, or to the person. " + + "to is up (your manager, or the person when you have none) or you (the person). Never sideways." + +const teamEscalateSchema = `{"type":"object","properties":{"packet":{"type":"string","description":"The packet id."},` + + `"to":{"type":"string","enum":["up","you"],"description":"Default up."},` + + `"reason":{"type":"string","description":"Why it is not yours to decide."},` + + teamArgSchema + `},"required":["packet","reason"],"additionalProperties":false}` + +// askGoesUp reports whether an `ask` of kind goes up as a packet: the +// clarifying kinds for a member, and a judgement as well for a manager, whose +// judgement calls are the person's to make (c-5). A permission, a landing, an +// assumption and a ratify never go up: the first is the person's safety gate, +// and the others are about this conversation's own work in front of the person. +func askGoesUp(kind AskKind, manager bool) bool { + switch kind { + case AskClarification, AskChoice, AskConfirmation: + return true + case AskJudgement: + return manager + } + return false +} + +// teamSnapshot is the teams file, this conversation's keys and roles, and the +// profile's defaults, from one hold of the seat's lock: a stat each of the +// teams file and config.json, and a read only when one moved. +func (a *Agent) teamSnapshot(profile string) (*teams.File, []string, []teamRole, teams.Defaults) { + a.team.mu.Lock() + defer a.team.mu.Unlock() + roles := a.teamRolesLocked(profile) + return a.team.file, append([]string(nil), a.teamKeysLocked()...), roles, a.team.defaults +} + +// homeOf is the manager keys report to. +func homeOf(file *teams.File, keys []string) (teams.Report, bool) { + if file == nil { + return teams.Report{}, false + } + for _, key := range keys { + if report, ok := file.Home(key); ok { + return report, true + } + } + return teams.Report{}, false +} + +// askUp is `ask`'s road up: the answer to hand the model and true when q went +// up as a packet, and false when it is the person's as it always was. A packet +// that cannot be written falls back to the person, because a question that +// reaches nobody is worse than one that reaches the person. +func (a *Agent) askUp(q Question) (string, bool) { + profile := a.config.teamProfile() + if profile == "" || q.Policy.Kind == PolicyDecide { + return "", false + } + file, keys, roles, d := a.teamSnapshot(profile) + if file == nil || len(roles) == 0 { + return "", false + } + var manages *teamRole + var member *teamRole + for i := range roles { + switch { + case roles[i].manager && manages == nil: + manages = &roles[i] + case !roles[i].manager && roles[i].managed && !roles[i].shared && member == nil: + member = &roles[i] + } + } + home, hasHome := homeOf(file, keys) + upThere := hasHome && file.Effective(home.Team, d).QuestionsUp + packet := askPacket(q) + switch { + case member != nil && askGoesUp(q.Ask, false) && upThere && home.Team == member.boss: + if member.handle == "" { + return "", false + } + packet.Team, packet.Origin, packet.RaisedBy = home.Team, member.id, member.handle + packet.Parties = []teams.Party{{Key: member.key, Handle: member.handle, Team: member.id, Context: strings.TrimSpace(q.Reason)}} + raised, err := teams.Raise(profile, packet) + if err != nil { + return "", false + } + who := "your manager" + if team, ok := file.Team(home.Team); ok { + if m, ok := team.Member(team.Manager); ok { + if m.Handle != "" { + who = fmt.Sprintf("your manager (@%s, manager of %q)", m.Handle, team.Name) + } + // A MANAGER NOBODY HOLDS IS OPENED to answer it, as a reply + // to it would open it (team_wakewatch.go). + a.teamRouse(profile, team, member.wakes, []teams.Member{m}, "") + } + } + return fmt.Sprintf("Your question went to %s as packet %s, not to the person: in this team questions go to the manager first. "+ + "Its answer comes back to you as a message marked \"◆ answered\" and starts your turn if you are idle. "+ + "Carry on with what does not depend on it, or end your turn and wait.", who, raised.ID), true + case manages != nil && askGoesUp(q.Ask, true): + if q.Ask == AskJudgement { + packet.Kind = teams.PacketJudgement + } + packet.RaisedBy = teams.FromManager + packet.Parties = []teams.Party{{Key: manages.key, Handle: manages.handle, Team: manages.id, Context: strings.TrimSpace(q.Reason)}} + // UP TO ITS OWN MANAGER when it has one and questions go up there; + // otherwise the person. Its own team is the origin either way, which + // is under the manager it reports to (a manager's home is one level + // up, home.go). + packet.Origin, packet.Team = manages.id, teams.Person + to := "the person's inbox (a decision card on the teams page)" + if hasHome && upThere && packet.Kind == teams.PacketQuestion { + packet.Team = home.Team + if team, ok := file.Team(home.Team); ok { + to = fmt.Sprintf("your own manager, the manager of %q", team.Name) + } + } + if len(packet.Options) == 0 && packet.Kind != teams.PacketQuestion { + // A judgement needs its options; one written with none is asked of + // the person as it always was. + return "", false + } + raised, err := teams.Raise(profile, packet) + if err != nil { + return "", false + } + return fmt.Sprintf("Your question went to %s as packet %s. "+ + "The answer comes back to you as a message marked \"◆ answered\" and starts your turn if you are idle; do not wait or poll for it.", to, raised.ID), true + } + return "", false +} + +// askPacket is q as a question packet: its head, its answers each with what +// happens, and the asker's pick with its reason. The caller fills in who +// decides, where it is from and who raised it. +func askPacket(q Question) teams.Packet { + p := teams.Packet{Kind: teams.PacketQuestion, Question: strings.TrimSpace(q.Head)} + byKey := map[string]string{} + for _, option := range q.Options { + label := strings.TrimSpace(option.Label) + if label == "" { + continue + } + consequence := strings.TrimSpace(option.Consequence) + if consequence == "" { + consequence = strings.TrimSpace(option.Body) + } + if consequence == "" { + consequence = "the asker goes on with " + label + } + id := strconv.Itoa(len(p.Options) + 1) + byKey[option.Key] = id + p.Options = append(p.Options, teams.Option{ID: id, Label: label, Consequence: consequence}) + } + if q.Pick != nil { + if id, ok := byKey[q.Pick.Key]; ok { + reason := strings.TrimSpace(q.Pick.Reason) + if reason == "" { + reason = "the asker's own pick" + } + p.Recommendation = &teams.Recommendation{Option: id, Reason: reason} + } + } + return p +} + +// ── the manager's two verbs ───────────────────────────────────────────────── + +// packetTools are the manager's verbs for packets waiting on it. +func (a *Agent) packetTools() []bare.Tool { + return []bare.Tool{ + {Name: teamDecideToolName, Description: teamDecideDescription, Schema: json.RawMessage(teamDecideSchema), Execute: a.teamDecideTool}, + {Name: teamEscalateToolName, Description: teamEscalateDescription, Schema: json.RawMessage(teamEscalateSchema), Execute: a.teamEscalateTool}, + } +} + +// managedPacket is packet id when it waits on a team this conversation +// manages, with that team, and the refusal to hand the model otherwise. +func (a *Agent) managedPacket(id, want string) (teams.Packet, teams.Team, string) { + id = strings.TrimSpace(id) + team, _, refusal := a.teamTarget(want, true) + if refusal != "" { + // One manager in several teams names none: the packet says which. + if want != "" || !strings.Contains(refusal, "more than one") { + return teams.Packet{}, teams.Team{}, refusal + } + } + profile := a.config.teamProfile() + p, err := teams.PacketByID(profile, id) + if err != nil { + return teams.Packet{}, teams.Team{}, fmt.Sprintf("There is no packet %q.", id) + } + if !p.Waiting() { + return teams.Packet{}, teams.Team{}, fmt.Sprintf("Packet %s was already decided (%s). Nothing was done.", p.ID, p.Decision) + } + if p.Team == teams.Person { + return teams.Packet{}, teams.Team{}, fmt.Sprintf("Packet %s waits on the person, not on you: a %s is theirs to decide.", p.ID, p.Kind) + } + file, keys, _, _ := a.teamSnapshot(profile) + if file == nil { + return teams.Packet{}, teams.Team{}, "The teams file could not be read." + } + at, ok := file.Team(p.Team) + if !ok || !teamHoldsKey(keys, at.Manager) { + return teams.Packet{}, teams.Team{}, fmt.Sprintf("Packet %s waits on another team's manager, not on you. Nothing was done.", p.ID) + } + if team.ID != "" && team.ID != at.ID { + return teams.Packet{}, teams.Team{}, fmt.Sprintf("Packet %s waits on %q, not on %q.", p.ID, at.Name, team.Name) + } + return p, at, "" +} + +func (a *Agent) teamDecideTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Packet string `json:"packet"` + Answer string `json:"answer"` + Reason string `json:"reason"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + answer := strings.TrimSpace(parsed.Answer) + if answer == "" { + return invalidArgumentsPrefix + "answer is empty", true, nil + } + p, team, refusal := a.managedPacket(parsed.Packet, parsed.Team) + if refusal != "" { + return refusal, true, nil + } + switch p.Kind { + case teams.PacketCap, teams.PacketClosing: + return fmt.Sprintf("A %s is the person's to decide, never a manager's. Nothing was done.", p.Kind), true, nil + } + // AN OPTION MAY BE NAMED BY ITS LABEL: a model that writes "JSON" for + // option 1 means option 1. + for _, option := range p.Options { + if strings.EqualFold(option.Label, answer) { + answer = option.ID + } + } + decided, err := teams.Decide(a.config.teamProfile(), p.ID, teams.FromManager, answer, strings.TrimSpace(parsed.Reason)) + if err != nil { + return "The decision could not be recorded: " + teamErrorWords(err), true, nil + } + return fmt.Sprintf("Decided %s in %q: %s. %s is handed your answer marked \"◆ answered\" and continues; the traffic shows it.", + decided.ID, team.Name, packetWord(decided), raiserWord(decided.RaisedBy)), false, nil +} + +func (a *Agent) teamEscalateTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Packet string `json:"packet"` + To string `json:"to"` + Reason string `json:"reason"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + reason := strings.TrimSpace(parsed.Reason) + if reason == "" { + return invalidArgumentsPrefix + "reason is empty", true, nil + } + p, team, refusal := a.managedPacket(parsed.Packet, parsed.Team) + if refusal != "" { + return refusal, true, nil + } + profile := a.config.teamProfile() + to, where := teams.Person, "the person" + if strings.TrimSpace(parsed.To) != teams.Person { + file, _, _, _ := a.teamSnapshot(profile) + if home, ok := homeOf(file, []string{team.Manager}); ok { + to = home.Team + if at, ok := file.Team(home.Team); ok { + where = fmt.Sprintf("the manager of %q", at.Name) + } + } + } + if _, err := teams.Escalate(profile, p.ID, teams.FromManager, to, reason); err != nil { + return "The packet could not be sent up: " + teamErrorWords(err), true, nil + } + return fmt.Sprintf("Sent %s up to %s. Its asker is told it went up and is handed the answer when it is decided.", p.ID, where), false, nil +} + +// teamErrorWords is a store error as a sentence for the model. +func teamErrorWords(err error) string { + switch { + case errors.Is(err, teams.ErrDecided): + return "it was already decided." + case errors.Is(err, teams.ErrNotDecider): + return "it does not wait on you." + case errors.Is(err, teams.ErrSideways): + return "a packet goes up the tree or to the person, never sideways or down." + case errors.Is(err, teams.ErrNoPacket): + return "there is no such packet." + } + return err.Error() +} + +// raiserWord names a packet's raiser in a sentence. +func raiserWord(by string) string { + switch by { + case teams.FromManager: + return "The manager" + case teams.FromSystem: + return "codeaf" + case teams.Person: + return "The person" + } + return "@" + strings.TrimPrefix(by, "@") +} + +// packetWord is a decided packet's decision in words: the option's label, or +// the decider's own words. +func packetWord(p teams.Packet) string { + if option, ok := p.Option(p.Decision); ok { + return option.Label + } + return p.Decision +} + +// ── delivery and the wake ─────────────────────────────────────────────────── + +// teamPacketText bounds one packet as delivered. +const teamPacketText = 3000 + +// teamPacketLine is a [teams.KindPacket] line as this conversation is told it, +// "" for one that is not its business. Its packet is read by id (the packet +// files' fold, stat-first, teams' decision.go), which only a packet line +// costs. +// +// - A MANAGER is handed a packet newly waiting on its team whole, and told +// when a packet it raised (its own question) was decided or sent up, and +// when the person decided its team's closing report, which closes the +// team on a Close ([closingDecidedLine]). +// - A MEMBER is told when its own question was answered (`◆ answered: …`) +// or sent up. +func teamPacketLine(profile string, role teamRole, entry teams.Entry) string { + p, ok := packetOf(profile, entry) + if !ok { + return "" + } + if closingDecided(role, entry, p) { + return closingDecidedLine(profile, p) + } + return packetLineFor(role, entry, p) +} + +// packetOf is the packet a packet line is about, as it stands. +func packetOf(profile string, entry teams.Entry) (teams.Packet, bool) { + if entry.Kind != teams.KindPacket || entry.Packet == "" { + return teams.Packet{}, false + } + p, err := teams.PacketByID(profile, entry.Packet) + return p, err == nil +} + +// closingDecided reports whether entry is the decision on role's own team's +// closing report, for its manager. +func closingDecided(role teamRole, entry teams.Entry, p teams.Packet) bool { + return role.manager && p.Kind == teams.PacketClosing && p.Origin == role.id && entry.State == teams.PacketDecided +} + +// packetLineFor is [teamPacketLine] for every packet but a closing report's +// decision, off the packet already read. +func packetLineFor(role teamRole, entry teams.Entry, p teams.Packet) string { + mine := p.Origin == role.id && (role.manager && p.RaisedBy == teams.FromManager || + !role.manager && role.handle != "" && p.RaisedBy == role.handle) + if p.Kind == teams.PacketClosing || p.Kind == teams.PacketCap { + // The person's cards: a manager is told of its closing report's + // decision above, and of nothing else about these two here. + return "" + } + if p.Kind == teams.PacketConflict { + // A CONFLICT'S DECISION REACHES THE PARTIES AS A RULING, a directive + // the store writes to each (team_nest.go), so its packet line hands + // them nothing more; a party that did not raise it is told it was + // raised. + if entry.State == teams.PacketDecided { + return "" + } + if told := partyTold(role, entry, p); told != "" && !(role.manager && p.Team == role.id) { + return told + } + } + switch entry.State { + case teams.PacketOpen, teams.PacketEscalated: + if role.manager && p.Waiting() && p.Team == role.id && entry.State == p.State { + return cutRunesTeam(packetBrief(p), teamPacketText) + } + if mine && entry.State == teams.PacketEscalated { + return fmt.Sprintf("◆ your question %s was sent up, to %s: %s. Its answer comes to you when it is decided.", p.ID, packetDecider(p), oneLineTeam(p.Reason)) + } + case teams.PacketDecided: + if !mine { + return "" + } + return answeredLine(p) + } + return "" +} + +// answeredLine is a decided packet as its raiser is handed it. +func answeredLine(p teams.Packet) string { + by := "by the manager" + if p.DecidedBy == teams.Person { + by = "by the person" + } else if p.DecidedBy != "" && p.DecidedBy != teams.FromManager { + by = "by ◆ @" + p.DecidedBy + } + line := "◆ answered: " + indentAfterFirst(cutRunesTeam(packetWord(p), teamEntryText)) + " (" + by + if reason := strings.TrimSpace(p.Reason); reason != "" { + line += ", because " + oneLineTeam(reason) + } + return line + "). Your question was: " + oneLineTeam(p.Question) +} + +// packetDecider names who a packet waits on. +func packetDecider(p teams.Packet) string { + if p.Team == teams.Person { + return "the person" + } + return "a manager above" +} + +// packetBrief is a packet whole, as the manager it waits on is handed it. +func packetBrief(p teams.Packet) string { + var b strings.Builder + fmt.Fprintf(&b, "◆ %s %s from %s, waiting on you: %s", p.Kind, p.ID, raiserName(p.RaisedBy), oneLineTeam(p.Question)) + if p.Kind == teams.PacketConflict { + var sides []string + for _, party := range p.Parties { + sides = append(sides, "@"+party.Handle) + } + fmt.Fprintf(&b, "\n parties: %s. Your ruling reaches each of them as a directive; you may team_read a party first (team/@handle for one in a team under yours).", strings.Join(sides, ", ")) + } + for _, party := range p.Parties { + if context := strings.TrimSpace(party.Context); context != "" { + who := "@" + party.Handle + if party.Handle == "" { + who = "the asker" + } + fmt.Fprintf(&b, "\n %s says: %s", who, oneLineTeam(context)) + } + } + for _, option := range p.Options { + fmt.Fprintf(&b, "\n [%s] %s: %s", option.ID, option.Label, oneLineTeam(option.Consequence)) + } + if r := p.Recommendation; r != nil { + fmt.Fprintf(&b, "\n recommended: %s, because %s", r.Option, oneLineTeam(r.Reason)) + } + for _, hop := range p.Trail { + fmt.Fprintf(&b, "\n sent up by %s: %s", hop.By, oneLineTeam(hop.Reason)) + } + b.WriteString("\n Decide it with team_decide (an option id, or your own words), or send it up with team_escalate if it is not yours to decide.") + return b.String() +} + +// raiserName names a raiser in a packet's first line. +func raiserName(by string) string { + switch by { + case teams.FromManager: + return "a manager" + case teams.FromSystem: + return "codeaf" + case teams.Person: + return "the person" + } + return "@" + strings.TrimPrefix(by, "@") +} + +// teamPacketWakes reports whether a packet line starts this conversation's +// turn when it is idle: for a manager, a packet newly waiting on its team, its +// own packet decided or sent up, or its team's closing report decided; for a +// member, its own question decided. It closes nothing: that is the delivery's. +func teamPacketWakes(profile string, role teamRole, entry teams.Entry) bool { + p, ok := packetOf(profile, entry) + if !ok { + return false + } + if closingDecided(role, entry, p) { + return true + } + if partyTold(role, entry, p) != "" && !(role.manager && p.Team == role.id) { + // Told, not woken: the ruling is what it acts on. + return false + } + return packetLineFor(role, entry, p) != "" && (role.manager || entry.State == teams.PacketDecided) +} diff --git a/internal/session/team_role_test.go b/internal/session/team_role_test.go new file mode 100644 index 0000000000..b31c30d092 --- /dev/null +++ b/internal/session/team_role_test.go @@ -0,0 +1,163 @@ +package session + +// THE ROLE, AS TESTS: a conversation is told what it is in its teams on the +// first request it sends as that, in codeaf's voice, whatever a read beside the +// work has or has not finished; told again only when it changes; and told when +// it stops. + +import ( + "context" + "strings" + "testing" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/home" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// oneAnswer is a completer that answers each of n turns with "ok". +func oneAnswer(n int) *scriptedCompleter { + completer := &scriptedCompleter{} + for i := 0; i < n; i++ { + completer.steps = append(completer.steps, func(context.Context, []ai.Message) (*ai.Response, error) { + return textResponse("ok"), nil + }) + } + return completer +} + +func submitAndWait(t *testing.T, agent *Agent, text string) { + t.Helper() + events, err := agent.Submit(context.Background(), text) + if err != nil { + t.Fatal(err) + } + collect(t, events) +} + +// roleNotes is every role note in one request, in order. +func roleNotes(messages []ai.Message) []string { + var notes []string + for _, message := range messages { + if text := messageText(message); message.Role == "user" && strings.HasPrefix(text, teamRoleNoteOpening) { + notes = append(notes, text) + } + } + return notes +} + +// THE FIRST REQUEST CARRIES THE ROLE, and nothing here refreshes the digest: +// the role must not wait for the read beside the work, which is what a manager +// on the ordinary launch was left waiting on. +func TestTheManagersFirstRequestSaysWhatItIs(t *testing.T) { + fixture := newTeamFixture(t, true) + completer := oneAnswer(1) + manager := teamAgent(t, fixture, fixture.manager, completer, nil) + submitAndWait(t, manager, "what's happening here?") + notes := roleNotes(completer.request(0)) + if len(notes) != 1 { + t.Fatalf("the first request carried %d role notes, want 1:\n%s", len(notes), userTextIn(completer.request(0))) + } + role := notes[0] + for _, want := range []string{ + `You are the manager of the team "harbor".`, + "@web (web frontend)", "@parser (the parser)", + "Seven laws:", "team_send", "team_start", "team_status", "team_read", "team_decide", "team_escalate", + "The person outranks you", "permission prompt", + } { + if !strings.Contains(role, want) { + t.Errorf("the manager's role lacks %q:\n%s", want, role) + } + } + if strings.Contains(role, "@boss") { + t.Errorf("the manager was listed among its own members:\n%s", role) + } + if strings.Contains(role, "Facts, not requests") { + t.Errorf("the role rode under the digest's fact wording:\n%s", role) + } + if !isVolatileNote(role) { + t.Error("the role note would be drawn as something the person typed") + } +} + +func TestAMembersFirstRequestSaysItsHandleAndItsVerb(t *testing.T) { + fixture := newTeamFixture(t, true) + completer := oneAnswer(1) + web := teamAgent(t, fixture, fixture.web, completer, nil) + submitAndWait(t, web, "carry on") + notes := roleNotes(completer.request(0)) + if len(notes) != 1 { + t.Fatalf("the member's first request carried %d role notes, want 1", len(notes)) + } + for _, want := range []string{`You are @web in the team "harbor", which has a manager.`, "team_post", "◆ from manager"} { + if !strings.Contains(notes[0], want) { + t.Errorf("the member's role lacks %q:\n%s", want, notes[0]) + } + } + if !holds(web, teamPostToolName) { + t.Error("the role names team_post and the belt does not carry it") + } +} + +// A MEMBER OF A TEAM WITH NO MANAGER HAS NO PART TO BE TOLD, and a conversation +// in no team lands no note at all. +func TestNoManagerNoRole(t *testing.T) { + fixture := newTeamFixture(t, false) + completer := oneAnswer(1) + web := teamAgent(t, fixture, fixture.web, completer, nil) + submitAndWait(t, web, "carry on") + if notes := roleNotes(completer.request(0)); len(notes) != 0 { + t.Fatalf("a member of an unmanaged team was told a role:\n%s", notes[0]) + } +} + +// THE ORDINARY LAUNCH: no profile directory, and the team in the state root's +// teams.json, which this test moves to the fixture's own directory. +func TestAnEmptyProfileIsTheOrdinaryLaunchAndFindsTheTeam(t *testing.T) { + fixture := newTeamFixture(t, true) + t.Setenv(home.EnvVar, fixture.profile) + completer := oneAnswer(1) + manager := teamAgent(t, fixture, fixture.manager, completer, func(config *Config) { config.ProfileDir = "" }) + submitAndWait(t, manager, "what's happening here?") + notes := roleNotes(completer.request(0)) + if len(notes) != 1 || !strings.Contains(notes[0], `manager of the team "harbor"`) { + t.Fatalf("a manager with an empty profile directory was not told it manages harbor:\n%s", userTextIn(completer.request(0))) + } + if !holds(manager, teamStatusToolName) { + t.Fatal("a manager with an empty profile directory was offered no team verb") + } +} + +// AN UNCHANGED ROLE LANDS ONCE, a changed one lands again at the tail, and a +// role that ends is said to have ended. +func TestTheRoleLandsOnceMovesWithTheTeamAndIsWithdrawn(t *testing.T) { + fixture := newTeamFixture(t, true) + completer := oneAnswer(4) + manager := teamAgent(t, fixture, fixture.manager, completer, nil) + submitAndWait(t, manager, "one") + submitAndWait(t, manager, "two") + if notes := roleNotes(completer.request(1)); len(notes) != 1 { + t.Fatalf("an unchanged role landed %d times over two turns, want once", len(notes)) + } + + err := teams.Update(fixture.profile, func(file *teams.File) error { + return file.SetHandle(fixture.teamID, convKeyOf(t, fixture.web), "frontend") + }) + if err != nil { + t.Fatal(err) + } + submitAndWait(t, manager, "three") + notes := roleNotes(completer.request(2)) + if len(notes) != 2 || !strings.Contains(notes[1], "@frontend") { + t.Fatalf("a renamed member did not move the role (%d notes):\n%s", len(notes), strings.Join(notes, "\n---\n")) + } + + if err := teams.Update(fixture.profile, func(file *teams.File) error { return file.ClearManager(fixture.teamID) }); err != nil { + t.Fatal(err) + } + submitAndWait(t, manager, "four") + notes = roleNotes(completer.request(3)) + if len(notes) != 3 || !strings.HasSuffix(notes[2], teamRoleWithdrawn) { + t.Fatalf("a manager made an ordinary member was not told so (%d notes):\n%s", len(notes), strings.Join(notes, "\n---\n")) + } +} diff --git a/internal/session/team_test.go b/internal/session/team_test.go new file mode 100644 index 0000000000..6b13953450 --- /dev/null +++ b/internal/session/team_test.go @@ -0,0 +1,607 @@ +package session + +// THE TEAM, AS TESTS: who is offered which verb, what the verbs write, what a +// conversation is told and how often, and what only a manager carries. +// +// Every fixture here builds a real teams.json and a real Traffic log through +// internal/teams, the one store the interface writes too, so what is asserted is +// the contract between the two sides and not a second copy of it. + +import ( + "context" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/home" + "github.com/Agent-Field/codeaf/internal/manual" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// teamFixture is one profile with one team in it: a manager conversation, a +// member called web, and a member called parser, each with its own journal. +type teamFixture struct { + profile string + teamID string + // manager, web and parser are the three transcripts. + manager, web, parser string +} + +// convKeyOf is the interface's key for a transcript (tui3's convKey): the path +// cleaned, with its symlinks resolved once the file exists. +func convKeyOf(t *testing.T, path string) string { + t.Helper() + if real, err := filepath.EvalSymlinks(path); err == nil { + return filepath.Clean(real) + } + return filepath.Clean(path) +} + +// newTeamFixture makes the three transcripts and the team. managed says whether +// the manager conversation is recorded as the team's manager. +// +// ITS TEAM HAS THE AUTO-WAKE OFF, so every test here reads delivery at the +// turns it starts itself, with no turn started behind it by the traffic +// watch; the wake's own tests build theirs with [newWakingTeamFixture]. +func newTeamFixture(t *testing.T, managed bool) teamFixture { + t.Helper() + return makeTeamFixture(t, managed, false) +} + +// newWakingTeamFixture is [newTeamFixture] with the team's auto-wake on, as a +// team is made in the product. +func newWakingTeamFixture(t *testing.T) teamFixture { + t.Helper() + return makeTeamFixture(t, true, true) +} + +func makeTeamFixture(t *testing.T, managed, wakes bool) teamFixture { + t.Helper() + root := t.TempDir() + fixture := teamFixture{profile: filepath.Join(root, "profile")} + for _, name := range []string{"manager", "web", "parser"} { + dir := filepath.Join(root, "sessions", name) + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + path := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(path, nil, 0o600); err != nil { + t.Fatal(err) + } + switch name { + case "manager": + fixture.manager = path + case "web": + fixture.web = path + case "parser": + fixture.parser = path + } + } + fixture.teamID = teams.NewID() + err := teams.Update(fixture.profile, func(file *teams.File) error { + team := teams.Team{ID: fixture.teamID, Name: "harbor"} + if !wakes { + off := false + team.Settings.Wake = &off + } + file.Teams = append(file.Teams, team) + for _, member := range []teams.Member{ + {Key: convKeyOf(t, fixture.manager), File: fixture.manager, Word: "Harbor manager", Handle: "boss"}, + {Key: convKeyOf(t, fixture.web), File: fixture.web, Word: "web frontend", Handle: "web"}, + {Key: convKeyOf(t, fixture.parser), File: fixture.parser, Word: "the parser", Handle: "parser"}, + } { + if err := file.AddMember(fixture.teamID, member); err != nil { + return err + } + } + if managed { + return file.SetManager(fixture.teamID, convKeyOf(t, fixture.manager)) + } + return nil + }) + if err != nil { + t.Fatalf("make the team: %v", err) + } + return fixture +} + +// teamAgent is a conversation on one of the fixture's transcripts, with a +// session folder of its own beside it so its cursor has somewhere to live. +func teamAgent(t *testing.T, fixture teamFixture, transcript string, completer Completer, mutate func(*Config)) *Agent { + t.Helper() + if completer == nil { + completer = &scriptedCompleter{} + } + agent, _ := newTestAgent(t, completer, func(config *Config) { + config.ProfileDir = fixture.profile + config.SessionFile = transcript + config.Place = Place{Dir: filepath.Dir(transcript)} + if mutate != nil { + mutate(config) + } + }) + return agent +} + +func appendTraffic(t *testing.T, fixture teamFixture, entry teams.Entry) { + t.Helper() + if err := teams.AppendTraffic(fixture.profile, fixture.teamID, entry); err != nil { + t.Fatalf("append traffic: %v", err) + } +} + +func holds(agent *Agent, name string) bool { return agent.hasTool(name) } + +// ── gating ────────────────────────────────────────────────────────────────── + +func TestTheManagerIsOfferedTheManagersVerbsAndNotThePost(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + for _, name := range teamToolNames { + if holds(manager, name) { + t.Fatalf("%s is on the belt before any boundary found the team", name) + } + } + manager.teamBoundary() + for _, name := range []string{teamStatusToolName, teamReadToolName, teamSendToolName, teamStopToolName, teamStartToolName} { + if !holds(manager, name) { + t.Errorf("the manager was not offered %s", name) + } + } + if holds(manager, teamPostToolName) { + t.Error("the manager was offered team_post, which is a member's verb") + } +} + +func TestAMemberIsOfferedThePostAndNoManagersVerb(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.teamBoundary() + if !holds(web, teamPostToolName) { + t.Error("a member of a managed team was not offered team_post") + } + for _, name := range []string{teamStatusToolName, teamReadToolName, teamSendToolName, teamStopToolName, teamStartToolName} { + if holds(web, name) { + t.Errorf("a member was offered the manager's %s", name) + } + } +} + +func TestNoTeamNoManagerAnEmptyProfileAndATaskAreOfferedNothing(t *testing.T) { + cases := map[string]func(t *testing.T) *Agent{ + "a conversation in no team": func(t *testing.T) *Agent { + fixture := newTeamFixture(t, true) + other := filepath.Join(t.TempDir(), "elsewhere", placeTranscript) + _ = os.MkdirAll(filepath.Dir(other), 0o700) + return teamAgent(t, fixture, other, nil, nil) + }, + "a member of a team with no manager": func(t *testing.T) *Agent { + fixture := newTeamFixture(t, false) + return teamAgent(t, fixture, fixture.web, nil, nil) + }, + // AN EMPTY PROFILE IS THE ORDINARY LAUNCH AND READS THE STATE ROOT'S + // teams.json, which here is a root of this test's own holding no team. + // The fixture's team is in another directory, so the manager's journal + // is nobody's manager on this launch. + "a conversation whose own profile holds no team": func(t *testing.T) *Agent { + t.Setenv(home.EnvVar, t.TempDir()) + fixture := newTeamFixture(t, true) + return teamAgent(t, fixture, fixture.manager, nil, func(config *Config) { config.ProfileDir = "" }) + }, + "a task node on the manager's own journal": func(t *testing.T) *Agent { + fixture := newTeamFixture(t, true) + return teamAgent(t, fixture, fixture.manager, nil, func(config *Config) { config.InTask = true }) + }, + } + for name, build := range cases { + t.Run(name, func(t *testing.T) { + agent := build(t) + if news := agent.teamBoundary(); news != "" { + t.Errorf("it was told %q", news) + } + for _, tool := range teamToolNames { + if holds(agent, tool) { + t.Errorf("it was offered %s", tool) + } + } + }) + } +} + +// THE FIXED PREFIX IS NOT A TEAM'S TO PAY FOR. The verbs are armed at a +// boundary, never built into the belt a conversation is constructed with, so +// every shape prefixbudget_test.go weighs is the shape it was. +func TestTheConstructedBeltCarriesNoTeamVerbEvenForAManager(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + for _, tool := range manager.belt() { + for _, name := range teamToolNames { + if tool.Name == name { + t.Fatalf("belt() built %s; team verbs must arrive by the arming door", name) + } + } + } +} + +// A MANAGER REMOVED IS TOLD SO BY THE VERB. The verb stays on the belt (the +// append law), and the file is asked again on the call. +func TestAVerbKeptAfterTheManagerWasRemovedRefuses(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + if err := teams.Update(fixture.profile, func(file *teams.File) error { return file.ClearManager(fixture.teamID) }); err != nil { + t.Fatal(err) + } + text, failed, _ := manager.teamSendTool(context.Background(), json.RawMessage(`{"to":"web","text":"hi"}`)) + if !failed || !strings.Contains(text, "not the manager") { + t.Fatalf("a removed manager's send answered %q (failed=%v)", text, failed) + } + if entries, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", 0); len(entries) != 0 { + t.Fatalf("a refused send wrote %d entries", len(entries)) + } +} + +// ── what the verbs write ──────────────────────────────────────────────────── + +func TestTheVerbsWriteTrafficToTheContract(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + web := teamAgent(t, fixture, fixture.web, nil, nil) + ctx := context.Background() + calls := []struct { + agent *Agent + run func(context.Context, json.RawMessage) (string, bool, error) + args string + want teams.Entry + }{ + {manager, manager.teamSendTool, `{"to":"@web","text":"ship the header"}`, + teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "ship the header", Member: convKeyOf(t, fixture.web)}}, + {manager, manager.teamSendTool, `{"to":"everyone","text":"freeze main","kind":"directive"}`, + teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: teams.ToEveryone, Text: "freeze main"}}, + {manager, manager.teamStopTool, `{"handle":"parser","reason":"wrong file"}`, + teams.Entry{Kind: teams.KindStop, From: teams.FromManager, To: "parser", Text: "wrong file", Member: convKeyOf(t, fixture.parser)}}, + {manager, manager.teamStartTool, `{"handle":"docs","brief":"write the README"}`, + teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: "docs", Text: "write the README"}}, + {web, web.teamPostTool, `{"to":"room","text":"header shipped"}`, + teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToRoom, Text: "header shipped"}}, + {web, web.teamPostTool, `{"to":"manager","text":"blocked on the API"}`, + teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToManager, Text: "blocked on the API"}}, + {web, web.teamPostTool, `{"to":"parser","text":"what does the token look like?"}`, + teams.Entry{Kind: teams.KindNote, From: "web", To: "parser", Text: "what does the token look like?", Member: convKeyOf(t, fixture.parser)}}, + } + for index, call := range calls { + text, failed, err := call.run(ctx, json.RawMessage(call.args)) + if err != nil || failed { + t.Fatalf("call %d %s answered %q (failed=%v, err=%v)", index, call.args, text, failed, err) + } + } + entries, err := teams.ReadTraffic(fixture.profile, fixture.teamID, teamLogStart, 0) + if err != nil || len(entries) != len(calls) { + t.Fatalf("traffic holds %d entries (err %v), want %d", len(entries), err, len(calls)) + } + for index, entry := range entries { + want := calls[index].want + if entry.Kind != want.Kind || entry.From != want.From || entry.To != want.To || entry.Text != want.Text || entry.Member != want.Member { + t.Errorf("entry %d is %+v, want kind %s from %s to %s text %q member %q", + index, entry, want.Kind, want.From, want.To, want.Text, want.Member) + } + } +} + +func TestTheVerbsRefuseWhatTheContractCannotCarry(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + ctx := context.Background() + refused := []struct { + run func(context.Context, json.RawMessage) (string, bool, error) + args string + }{ + {manager.teamSendTool, `{"to":"nobody","text":"hi"}`}, + {manager.teamSendTool, `{"to":"boss","text":"to myself"}`}, + {manager.teamSendTool, `{"to":"web","text":"hi","kind":"order"}`}, + {manager.teamStartTool, `{"handle":"web","brief":"a second web"}`}, + {manager.teamStartTool, `{"handle":"Not A Handle!","brief":"x"}`}, + {manager.teamStopTool, `{"handle":"boss"}`}, + {manager.teamReadTool, `{"handle":"boss"}`}, + {manager.teamPostTool, `{"to":"room","text":"a manager is not a member here"}`}, + } + for _, call := range refused { + if text, failed, _ := call.run(ctx, json.RawMessage(call.args)); !failed { + t.Errorf("%s was not refused: %q", call.args, text) + } + } + if entries, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", 0); len(entries) != 0 { + t.Fatalf("refused calls wrote %d entries", len(entries)) + } +} + +// ── delivery ──────────────────────────────────────────────────────────────── + +func TestAMemberIsToldWhatIsAddressedToItOnceAndOnlyThat(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + if news := web.teamBoundary(); news != "" { + t.Fatalf("a fresh member was told %q before anything was said", news) + } + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "ship the header"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: teams.ToEveryone, Text: "freeze main"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "parser", To: teams.ToRoom, Text: "tokens are ready"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "parser", Text: "not for web"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToRoom, Text: "my own post"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindStop, From: teams.FromManager, To: "web", Text: "stop"}) + + news := web.teamBoundary() + for _, want := range []string{"◆ from manager #1: ship the header", "◆ directive from manager to everyone #2: freeze main", "from @parser to the room #3: tokens are ready", "not the person's words"} { + if !strings.Contains(news, want) { + t.Errorf("the member's note lacks %q:\n%s", want, news) + } + } + for _, never := range []string{"not for web", "my own post", "stop"} { + if strings.Contains(news, never+"\n") || strings.Contains(news, ": "+never) { + t.Errorf("the member was told %q, which was not addressed to it:\n%s", never, news) + } + } + if again := web.teamBoundary(); again != "" { + t.Fatalf("the same traffic was delivered twice:\n%s", again) + } +} + +func TestTheManagerIsToldEveryMembersPostAndNotItsOwnLines(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToManager, Text: "blocked on the API"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "parser", To: "web", Text: "token shape attached"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "my own send"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindYou, From: teams.FromYou, To: teams.ToManager, Text: "what the person typed"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: teams.FromSystem, To: teams.ToManager, Text: "web finished"}) + news := manager.teamBoundary() + for _, want := range []string{"from @web: blocked on the API", "from @parser to @web: token shape attached", "which you manage"} { + if !strings.Contains(news, want) { + t.Errorf("the manager's note lacks %q:\n%s", want, news) + } + } + for _, never := range []string{"my own send", "what the person typed", "web finished"} { + if strings.Contains(news, never) { + t.Errorf("the manager was told %q:\n%s", never, news) + } + } +} + +// THE CURSOR OUTLIVES THE PROCESS. A conversation reopened is handed what was +// said while it was closed, and nothing it was handed before. +func TestAReopenedConversationResumesFromItsCursor(t *testing.T) { + fixture := newTeamFixture(t, true) + first := teamAgent(t, fixture, fixture.web, nil, nil) + first.teamBoundary() + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "one"}) + if news := first.teamBoundary(); !strings.Contains(news, "one") { + t.Fatalf("the first life was not told: %q", news) + } + _ = first.Close() + first.SettleWrites() + + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "two"}) + second := teamAgent(t, fixture, fixture.web, nil, nil) + news := second.teamBoundary() + if !strings.Contains(news, "◆ from manager #2: two") { + t.Fatalf("the reopened conversation was not told what was said while it was closed: %q", news) + } + if strings.Contains(news, ": one") { + t.Fatalf("the reopened conversation was told again what it was already told: %q", news) + } +} + +// A FRESH CONVERSATION DOES NOT REPLAY THE TEAM, except what came after its own +// start. +func TestAFreshConversationStartsAtItsBirthOrItsOwnStart(t *testing.T) { + fixture := newTeamFixture(t, true) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "old history"}) + web := teamAgent(t, fixture, fixture.web, nil, nil) + if news := web.teamBoundary(); news != "" { + t.Fatalf("a fresh member was handed the team's history: %q", news) + } + + // parser was started by the manager, and the manager spoke to it before the + // interface had opened it. + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "parser", Text: "before its start"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: "parser", Text: "the brief"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "parser", Text: "after its start"}) + time.Sleep(2 * time.Millisecond) + parser := teamAgent(t, fixture, fixture.parser, nil, nil) + news := parser.teamBoundary() + if !strings.Contains(news, "after its start") { + t.Fatalf("a started member lost what the manager said after its start: %q", news) + } + if !strings.Contains(news, teamBriefWord+" #3: the brief") { + t.Fatalf("a started member was not handed its brief, marked as the manager's: %q", news) + } + if strings.Contains(news, "before its start") { + t.Fatalf("a started member was handed history: %q", news) + } +} + +// AND DELIVERY IS A STEP BOUNDARY'S: a line the manager wrote reaches the +// member's next request, marked, and never as the person. +func TestDeliveredTrafficReachesTheNextRequestAsTheSessionsNote(t *testing.T) { + fixture := newTeamFixture(t, true) + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("on it"), nil }, + }} + web := teamAgent(t, fixture, fixture.web, completer, nil) + web.teamBoundary() + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "use the blue header"}) + events, err := web.Submit(context.Background(), "carry on") + if err != nil { + t.Fatal(err) + } + collect(t, events) + request := userTextIn(completer.request(0)) + if !strings.Contains(request, "◆ directive from manager #1: use the blue header") { + t.Fatalf("the request did not carry the directive:\n%s", request) + } + web.mu.Lock() + defer web.mu.Unlock() + for _, message := range web.messages { + if message.Role == "user" && strings.HasPrefix(messageText(message), "◆") { + t.Fatal("the directive was recorded as a bare line, not under its team sentence") + } + } +} + +// ── the digest ────────────────────────────────────────────────────────────── + +func TestOnlyAManagerCarriesTheDigest(t *testing.T) { + fixture := newTeamFixture(t, true) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToManager, Text: "header done"}) + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("noted"), nil }, + }} + manager := teamAgent(t, fixture, fixture.manager, completer, nil) + manager.refreshTeamDigest(context.Background()) + manager.mu.Lock() + block := manager.teamDigestText + manager.mu.Unlock() + for _, want := range []string{`Team "harbor": 3 members, manager @boss.`, "@web", "@parser", "header done"} { + if !strings.Contains(block, want) { + t.Errorf("the manager's digest lacks %q:\n%s", want, block) + } + } + events, err := manager.Submit(context.Background(), "how is the team?") + if err != nil { + t.Fatal(err) + } + collect(t, events) + if request := userTextIn(completer.request(0)); !strings.Contains(request, teamNoteOpening) { + t.Fatalf("the manager's request did not carry the team note:\n%s", request) + } + + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.refreshTeamDigest(context.Background()) + web.mu.Lock() + defer web.mu.Unlock() + if web.teamDigestText != "" { + t.Fatalf("a member was given a digest:\n%s", web.teamDigestText) + } +} + +func TestTheTeamNoteIsNeverThePersonsWords(t *testing.T) { + if !isVolatileNote(teamNoteOpening + "\n\nanything") { + t.Fatal("the team note would be drawn as something the person typed") + } +} + +// ── a member's state, off its journal ─────────────────────────────────────── + +func writeJournal(t *testing.T, path string, entries ...sessionEntry) { + t.Helper() + var lines []string + for _, entry := range entries { + if entry.Timestamp == "" { + entry.Timestamp = time.Now().Format(time.RFC3339Nano) + } + raw, err := json.Marshal(entry) + if err != nil { + t.Fatal(err) + } + lines = append(lines, string(raw)) + } + if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")+"\n"), 0o600); err != nil { + t.Fatal(err) + } +} + +func TestAMembersStateIsReadOffItsJournal(t *testing.T) { + path := filepath.Join(t.TempDir(), placeTranscript) + now := time.Now() + call := func(id, name, args string) ai.ToolCall { + return ai.ToolCall{ID: id, Type: "function", Function: ai.ToolCallFunction{Name: name, Arguments: args}} + } + cases := []struct { + name string + entries []sessionEntry + state string + detail string + }{ + {"a turn that ended", []sessionEntry{ + {Type: "message", Role: "user", Content: "do it"}, + {Type: "message", Role: "assistant", Content: "done", ToolCalls: nil}, + {Type: "pace"}, + }, teams.StateIdle, ""}, + {"a turn under way", []sessionEntry{ + {Type: "pace"}, + {Type: "message", Role: "user", Content: "next"}, + {Type: "message", Role: "assistant", ToolCalls: []ai.ToolCall{call("c1", "edit", `{"path":"web/header.go"}`)}}, + }, teams.StateRunning, "web/header.go"}, + {"a question waiting", []sessionEntry{ + {Type: "message", Role: "user", Content: "next"}, + {Type: "message", Role: "assistant", ToolCalls: []ai.ToolCall{call("c2", "ask", `{"head":"Which colour for the header?"}`)}}, + }, teams.StateAsking, "Which colour for the header?"}, + {"a turn that failed", []sessionEntry{ + {Type: "message", Role: "user", Content: "next"}, + {Type: "error"}, + }, teams.StateFailed, ""}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + writeJournal(t, path, c.entries...) + state, ok := journalState(path, now) + if !ok || state.State != c.state { + t.Fatalf("state %+v (ok %v), want %s", state, ok, c.state) + } + if c.detail != "" && state.Question != c.detail && (len(state.Files) == 0 || state.Files[0] != c.detail) { + t.Fatalf("state %+v does not carry %q", state, c.detail) + } + }) + } +} + +func TestTeamReadIsBoundedAndSkipsTheSessionsOwnNotes(t *testing.T) { + fixture := newTeamFixture(t, true) + big := strings.Repeat("x", 5000) + var entries []sessionEntry + for index := 0; index < 60; index++ { + entries = append(entries, sessionEntry{Type: "message", Role: "assistant", Content: big}) + } + entries = append(entries, + sessionEntry{Type: "message", Role: "user", Content: volatileNoteOpening + "\n\ncard"}, + sessionEntry{Type: "message", Role: "assistant", Content: "the newest line"}) + writeJournal(t, fixture.web, entries...) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + text, failed, _ := manager.teamReadTool(context.Background(), json.RawMessage(`{"handle":"web","messages":40}`)) + if failed { + t.Fatalf("team_read failed: %s", text) + } + if len(text) > teamReadBytes+1024 { + t.Fatalf("team_read handed back %d bytes, over its bound", len(text)) + } + if !strings.Contains(text, "the newest line") { + t.Fatal("team_read lost the newest message to the bound") + } + if strings.Contains(text, "card") { + t.Fatal("team_read showed the session's own note as the person's words") + } +} + +// ── the gates the rest of the build keeps ─────────────────────────────────── + +func TestEveryTeamVerbHasAFamilyAndAManualPage(t *testing.T) { + for _, name := range teamToolNames { + if ActionCategoryForTool(name) == ActionWork { + t.Errorf("%s has no family in actioncategory.go", name) + } + if !manual.Chat().Mentions(name) { + t.Errorf("no chat manual page mentions %s", name) + } + } + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + manager.teamBoundary() + if _, err := toolDefinitions(append(manager.managerTools(), manager.memberTools()...)); err != nil { + t.Fatalf("a team verb's schema does not parse: %v", err) + } +} diff --git a/internal/session/team_thread_test.go b/internal/session/team_thread_test.go new file mode 100644 index 0000000000..bfe11ad4b9 --- /dev/null +++ b/internal/session/team_thread_test.go @@ -0,0 +1,150 @@ +package session + +import ( + "context" + "encoding/json" + "strings" + "testing" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// threadLog is the fixture's whole log, oldest first. +func threadLog(t *testing.T, fixture teamFixture) []teams.Entry { + t.Helper() + entries, err := teams.ReadTraffic(fixture.profile, fixture.teamID, teamLogStart, 0) + if err != nil { + t.Fatal(err) + } + return entries +} + +// ONE QUESTION TO SEVERAL MEMBERS IS ONE ENTRY with their handles, the answer +// names its number, and each named member is told it once while a member it +// does not name is told nothing. +func TestTeamThreadASendToSeveralIsOneEntryDeliveredToEach(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + web := teamAgent(t, fixture, fixture.web, nil, nil) + parser := teamAgent(t, fixture, fixture.parser, nil, nil) + web.teamBoundary() + parser.teamBoundary() + said, failed, err := manager.teamSendTool(context.Background(), json.RawMessage(`{"to":"@web @parser","text":"a brief status, please","kind":"directive"}`)) + if err != nil || failed { + t.Fatalf("team_send: %q %v", said, err) + } + log := threadLog(t, fixture) + if len(log) != 1 || log[0].To != teams.ToSeveral || strings.Join(log[0].Handles, ",") != "web,parser" { + t.Fatalf("the send wrote %+v", log) + } + if !strings.Contains(said, "#1") { + t.Errorf("the answer does not carry the message's number: %q", said) + } + for name, agent := range map[string]*Agent{"web": web, "parser": parser} { + news := agent.teamBoundary() + if !strings.Contains(news, "◆ directive from manager #1: a brief status, please") { + t.Errorf("@%s was told:\n%s", name, news) + } + if again := agent.teamBoundary(); again != "" { + t.Errorf("@%s was told twice: %s", name, again) + } + } + // The same handle twice is one recipient, and a stranger refuses the lot. + if said, failed, _ := manager.teamSendTool(context.Background(), json.RawMessage(`{"to":"web, @web","text":"x"}`)); failed { + t.Fatalf("a repeated handle was refused: %q", said) + } + if log := threadLog(t, fixture); log[len(log)-1].To != "web" { + t.Errorf("a repeated handle wrote %+v", log[len(log)-1]) + } + if _, failed, _ := manager.teamSendTool(context.Background(), json.RawMessage(`{"to":"web nobody","text":"x"}`)); !failed { + t.Error("a send naming a stranger was not refused") + } +} + +// A MEMBER'S REPLY TO THE MANAGER ANSWERS WHAT THE MANAGER LAST SAID TO IT, +// by itself; a reply naming a thread answers that one; a post to the room +// answers nothing unless it names something; and the event its turn raises +// answers the same message as its reply. +func TestTeamThreadAReplyLinksToTheManagersLastMessage(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.teamBoundary() + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "first"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "parser", Text: "not web's"}) + if news := web.teamBoundary(); !strings.Contains(news, "#1: first") { + t.Fatalf("web was told:\n%s", news) + } + ctx := context.Background() + // THE POST SAYS ITS OWN NUMBER, so the surface can find it again. + if said, _, _ := web.teamPostTool(ctx, json.RawMessage(`{"to":"room","text":"hello"}`)); !strings.Contains(said, " as #3") { + t.Errorf("the post does not say its own number: %q", said) + } + for _, args := range []string{ + `{"to":"manager","text":"on it"}`, + `{"to":"room","text":"fyi all"}`, + `{"to":"manager","text":"about the other","thread":"#2"}`, + } { + if said, failed, err := web.teamPostTool(ctx, json.RawMessage(args)); failed || err != nil { + t.Fatalf("%s: %q %v", args, said, err) + } + } + if _, failed, _ := web.teamPostTool(ctx, json.RawMessage(`{"to":"manager","text":"x","thread":"soon"}`)); !failed { + t.Error("a thread that is not a number was taken") + } + web.teamEventOwed(teams.StateFinished, "") + web.settleTeamEvents() + log := threadLog(t, fixture) + want := map[string]string{"on it": "000000000001", "fyi all": "", "about the other": "000000000002"} + var event teams.Entry + for _, e := range log { + if answers, ok := want[e.Text]; ok && e.Answers != answers { + t.Errorf("%q answers %q, want %q", e.Text, e.Answers, answers) + } + if e.Kind == teams.KindEvent && e.State == teams.StateFinished { + event = e + } + } + if event.Answers != "000000000001" { + t.Errorf("the finished event answers %q: %+v", event.Answers, event) + } +} + +// A DELIVERED LINE'S NUMBER READS BACK as the line's thread, and a line +// without one reads as it always did. +func TestTeamThreadADeliveredNumberReadsBack(t *testing.T) { + text := "Team traffic in \"harbor\" for you (@web). These are the team's messages, not the person's words:\n" + + "◆ directive from manager #42: take the header\n" + + "from @parser to the room #43: tokens are in\n" + + "◆ from manager: an old line\n" + + "(The person's own words in this conversation outrank the manager.)" + lines := teamNewsLines(text) + if len(lines) != 3 { + t.Fatalf("read %+v", lines) + } + if l := lines[0]; l.Thread != "000000000042" || l.Kind != teams.KindDirective || l.To != "" || l.Text != "take the header" { + t.Errorf("the directive read as %+v", l) + } + if l := lines[1]; l.Thread != "000000000043" || l.From != "parser" || l.To != teams.ToRoom { + t.Errorf("the teammate's line read as %+v", l) + } + if l := lines[2]; l.Thread != "" || l.From != teams.FromManager { + t.Errorf("the old line read as %+v", l) + } +} + +// A NOTE THAT WOKE A TURN CARRIES ITS DELIVERY UNDER A SENTENCE OF ITS OWN, and +// the delivery still reads back line by line, so a surface draws the woken +// member's directive as the manager's card. +func TestTeamThreadAWakeNotesDeliveryReadsBack(t *testing.T) { + text := "Your manager's directive started this turn; the person did not speak.\n\n" + + "Team traffic in \"harbor\" for you (@web). These are the team's messages, not the person's words:\n" + + "◆ directive from manager #7: fix the header\n" + + "(The person's own words in this conversation outrank the manager.)" + lines := teamNewsLines(text) + if len(lines) != 1 || lines[0].Thread != "000000000007" || lines[0].Text != "fix the header" { + t.Fatalf("the wake's delivery read as %+v", lines) + } + if teamNewsLines("Your team's replies started this turn.\n\nWhat your members did:\n@web finished its turn") != nil { + t.Error("a wake note with no delivery read as one") + } +} diff --git a/internal/session/team_wake.go b/internal/session/team_wake.go new file mode 100644 index 0000000000..60044dcffa --- /dev/null +++ b/internal/session/team_wake.go @@ -0,0 +1,170 @@ +package session + +import ( + "time" + + "github.com/Agent-Field/codeaf/internal/guard" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── A MEMBER THE MANAGER STARTED TAKES ITS FIRST TURN ON ITS OWN ──────────── +// +// `team_start` writes a start to the team's Traffic, and the interface that +// holds the manager answers it by opening a new conversation BEHIND the one in +// front and putting it in the team under the manager's handle for it +// (internal/tui3's teamtraffic.go). Nobody types into that conversation: the +// person's words are theirs, and a brief sent as if they had typed it would +// outrank the manager and draw as the person's own line. So the brief has to +// reach the member by the one road the manager's words take, the Traffic +// delivery at a step boundary ([Agent.teamBoundary]), and there has to be a +// turn for that boundary to be in. +// +// THIS IS THAT TURN, and nothing else starts it. The interface and the session +// meet only through internal/teams, and over a session host the interface holds +// a client with no door for "start a turn with no words" (internal/remote). So +// the conversation watches for its own start: for a short window after it +// opens, and only on a profile where some team has a manager, it looks at the +// teams file (a stat, and a read only when the stat moved) until it finds +// itself a member with a handle and a start addressed to that handle. Then it +// reads what is addressed to it exactly as a boundary would, and if that is not +// empty it queues it as a note that wakes the conversation ([Agent.wakeLocked]). +// The watch ends at the first of: the wake, a turn begun some other way, the +// window running out, or the session closing. +// +// A TEAM WHOSE AUTO-WAKE IS OFF IS THE EXCEPTION. The member is still opened, +// and the brief is still waiting in the Traffic for its first turn, but no +// turn is started for it. The Traffic says so, in the same voice as a wake +// that could not run. +// +// A conversation that is never started by a manager pays one stat of the teams +// file at open and, where a team has a manager, one stat every +// [teamWakeEvery] for [teamWakeFor]. + +const ( + // teamWakeEvery is how often the teams file is looked at while waiting. + teamWakeEvery = 250 * time.Millisecond + // teamWakeFor is how long a fresh conversation waits to be made a member. + // The interface writes the member within a moment of opening it. + teamWakeFor = 20 * time.Second +) + +// watchTeamStart starts the watch described above, or does nothing. +func (a *Agent) watchTeamStart() { + profile := a.config.teamProfile() + // AND EVERY CONVERSATION THAT COULD BE IN A TEAM WATCHES ITS TRAFFIC for + // the lines that wake it (team_wakewatch.go), which costs nothing while it + // is in no managed team but a stat the whole process shares. + a.watchTeamTraffic(profile) + if profile == "" || !teamsHaveManager(profile) { + return + } + // FRESH IS MEASURED FROM HERE: whatever the transcript holds at open, a + // turn begun some other way grows it, and that ends the watch. + // ONLY A CONVERSATION WITH NOTHING IN IT YET. One reopened with a history + // is not being started; what wakes it later is the traffic watch. + base, busy := a.teamWakeState() + if busy || base > 0 { + return + } + guard.Go("team start wake", func() { a.awaitTeamStart(profile, base) }) +} + +// teamsHaveManager reports whether any team in the profile has a manager. +func teamsHaveManager(profile string) bool { + if !stampOf(teams.Path(profile)).present { + return false + } + file, err := teams.Load(profile) + if err != nil { + return false + } + for _, t := range file.Teams { + if t.Manager != "" { + return true + } + } + return false +} + +// teamWakeState is how many messages the transcript holds past its system +// prompt, and whether a turn is running or the session has closed, which both +// end the watch. +func (a *Agent) teamWakeState() (int, bool) { + a.mu.Lock() + defer a.mu.Unlock() + said := 0 + for _, message := range a.messages { + if message.Role != "system" { + said++ + } + } + return said, a.running || a.closed +} + +// awaitTeamStart is the watch's body, off every lock but for the moments it +// asks the agent whether it is still fresh. +func (a *Agent) awaitTeamStart(profile string, base int) { + ticker := time.NewTicker(teamWakeEvery) + defer ticker.Stop() + deadline := time.Now().Add(teamWakeFor) + for time.Now().Before(deadline) { + <-ticker.C + if grown, busy := a.teamWakeState(); busy || grown > base { + return + } + started := a.teamStarts(profile) + if len(started) == 0 { + continue + } + var waking []teamRole + for _, role := range started { + if role.wakes { + waking = append(waking, role) + continue + } + // WAKE OFF HONOURS THE SWITCH. The conversation is already open, + // which is what "opened" means here, and the brief stays unread + // until a turn something else starts. Consuming it now would hand + // it over with nobody to read it. + a.teamSay(profile, role.id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromSystem, To: role.handle, Member: role.key, + State: teams.StateIdle, + Text: "opened @" + role.handle + "; this team's auto-wake is off, so no turn was started. It reads the brief when it next runs.", + }) + } + if len(waking) == 0 { + return + } + if news := a.teamBoundary(); news != "" { + // AT THE CAP THE BRIEF WAITS: it is queued without the wake, and + // the member reads it at its first turn (team_cap.go). + held := a.teamCapHold(profile, a.teamRoles()) != "" + a.enqueueNote(userMessage{message: textMessage("user", news), wake: !held}) + } + return + } +} + +// teamStarts is every team this conversation was just started into: a member +// with a handle, and a start addressed to that handle in the team's recent +// traffic. +func (a *Agent) teamStarts(profile string) []teamRole { + var started []teamRole + for _, role := range a.teamRoles() { + if role.manager || role.handle == "" { + continue + } + tail, err := teams.ReadTraffic(profile, role.id, "", teamFirstLook) + if err != nil { + continue + } + for _, entry := range tail { + if entry.Kind == teams.KindStart && entry.To == role.handle && + !entry.At.Before(a.startedAt.Add(-teamStartGrace)) { + started = append(started, role) + break + } + } + } + return started +} diff --git a/internal/session/team_wake_test.go b/internal/session/team_wake_test.go new file mode 100644 index 0000000000..56422b9d32 --- /dev/null +++ b/internal/session/team_wake_test.go @@ -0,0 +1,127 @@ +package session + +import ( + "context" + "os" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// A MEMBER THE MANAGER STARTED TAKES ITS FIRST TURN ON ITS OWN, AND IS HANDED +// THE BRIEF ONCE. The conversation opens before it is a member, as the +// interface opens it; once it is made one under the handle the start names, it +// wakes with no person's words, its first request carries the brief marked as +// the manager's, and nothing hands it the brief a second time. +func TestAStartedMemberWakesOnItsOwnWithTheBriefOnce(t *testing.T) { + fixture := newWakingTeamFixture(t) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: "lexer", Text: "Rewrite the lexer."}) + dir := filepath.Join(filepath.Dir(filepath.Dir(fixture.parser)), "lexer") + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + transcript := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(transcript, nil, 0o600); err != nil { + t.Fatal(err) + } + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("on it"), nil }, + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("again"), nil }, + }} + lexer := teamAgent(t, fixture, transcript, completer, nil) + time.Sleep(3 * teamWakeEvery) + if completer.requests() != 0 { + t.Fatal("a conversation that is not a member yet woke") + } + if err := teams.Update(fixture.profile, func(file *teams.File) error { + return file.AddMember(fixture.teamID, teams.Member{Key: convKeyOf(t, transcript), File: transcript, Handle: "lexer"}) + }); err != nil { + t.Fatal(err) + } + deadline := time.Now().Add(5 * time.Second) + for completer.requests() == 0 && time.Now().Before(deadline) { + time.Sleep(20 * time.Millisecond) + } + if completer.requests() == 0 { + t.Fatal("the started member never took its first turn") + } + first := userTextIn(completer.request(0)) + if !briefIn(first, "Rewrite the lexer.") { + t.Fatalf("the first request did not carry the brief:\n%s", first) + } + for _, entry := range lexer.Transcript() { + if entry.Role == "user" { + t.Fatalf("the woken turn carries words as the person's: %+v", entry) + } + } + if news := lexer.teamBoundary(); strings.Contains(news, "Rewrite the lexer") { + t.Fatalf("the brief would be handed over twice: %q", news) + } +} + +// WITH THE TEAM'S AUTO-WAKE OFF, A START OPENS THE MEMBER AND STARTS NO TURN. +// The brief stays in the Traffic and is handed over on the first turn something +// else starts, and the Traffic says why nothing ran. +func TestAStartedMemberWithWakeOffIsOpenedAndNotWoken(t *testing.T) { + fixture := newTeamFixture(t, true) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: "lexer", Text: "Rewrite the lexer."}) + dir := filepath.Join(filepath.Dir(filepath.Dir(fixture.parser)), "lexer") + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + transcript := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(transcript, nil, 0o600); err != nil { + t.Fatal(err) + } + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("on it"), nil }, + }} + lexer := teamAgent(t, fixture, transcript, completer, nil) + if err := teams.Update(fixture.profile, func(file *teams.File) error { + return file.AddMember(fixture.teamID, teams.Member{Key: convKeyOf(t, transcript), File: transcript, Handle: "lexer"}) + }); err != nil { + t.Fatal(err) + } + deadline := time.Now().Add(2 * time.Second) + for completer.requests() == 0 && time.Now().Before(deadline) { + time.Sleep(20 * time.Millisecond) + } + if completer.requests() != 0 { + t.Fatal("a team with auto-wake off started the new member's turn") + } + said := waitEvent(t, fixture, "auto-wake is off") + if said.From != teams.FromSystem || said.To != "lexer" || said.State != teams.StateIdle { + t.Fatalf("the wake-off line is %+v", said) + } + if !strings.Contains(said.Text, "no turn was started") { + t.Fatalf("the wake-off line does not say no turn was started: %q", said.Text) + } + events, err := lexer.Submit(context.Background(), "go") + if err != nil { + t.Fatal(err) + } + collect(t, events) + first := userTextIn(completer.request(0)) + if !briefIn(first, "Rewrite the lexer.") { + t.Fatalf("the first turn did not carry the brief:\n%s", first) + } +} + +// briefIn reports whether a request's text hands over the manager's brief +// with text as its words. It reads the line the way a surface does +// ([teamLineParts]) rather than matching its wording, so the line's number +// (" #42" at the end of its head) is the delivery's to write. +func briefIn(request, text string) bool { + for _, line := range strings.Split(request, "\n") { + parsed, ok := teamLineParts(strings.TrimSpace(line)) + if ok && parsed.Kind == teams.KindStart && parsed.From == teams.FromManager && parsed.Text == text { + return true + } + } + return false +} diff --git a/internal/session/team_wakewatch.go b/internal/session/team_wakewatch.go new file mode 100644 index 0000000000..00ac96046a --- /dev/null +++ b/internal/session/team_wakewatch.go @@ -0,0 +1,755 @@ +package session + +import ( + "fmt" + "os" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/Agent-Field/codeaf/internal/filelock" + "github.com/Agent-Field/codeaf/internal/guard" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── TEAM TRAFFIC WAKES THE CONVERSATION IT IS FOR ─────────────────────────── +// +// v1 delivered a team's lines only when a conversation next ran, and a manager +// is idle as often as its members are: it sent a directive to three idle +// members, told the person the answers would be reported as they arrived, and +// nothing ran again until the person typed. So the lines that ask for an +// answer now start one: +// +// - A DIRECTIVE WAKES THE MEMBER IT IS ADDRESSED TO (its handle, or +// everyone). A note does not: it is information, and it is read at the +// member's next turn as before. A member that is busy is not started again; +// it reads the directive at its next step boundary, the steering road +// ([Agent.teamBoundary]). +// - A MEMBER'S REPLY WAKES THE MANAGER: a team_post addressed to the manager, +// and the events a member writes on its own (finished, failed, asking, +// teamevent.go). They COALESCE: the first one arms [teamWakeSettle], and one +// turn carries everything that arrived by the time it runs out, because +// three members finishing within a few seconds of each other is one thing +// to act on, not three turns that each see a third of it. +// +// THE WOKEN TURN IS NEVER THE PERSON'S. What wakes it is the same marked note +// the step boundary hands over ("◆ directive from manager: …", "from @web: …"), +// queued as the session's line with the wake bit ([Agent.wakeLocked]), so it +// is drawn in the harness's lane and every gate a wake passes (the spend rail, +// the wall, a closed or stopped session) still decides whether it may run. +// +// THE WATCH LIVES WITH THE CONVERSATION, ON THE ENGINE. Every conversation is +// an [Agent] in the process that holds its journal (the workspace's session +// host, locally and over --host alike), and the Traffic log is the one channel +// between conversations (team.go), so each conversation watches the log for +// itself. It costs, per tick of [teamWatchEvery]: +// +// - nothing at all while a turn is running, or once the session is closed; +// - one stat of the teams file SHARED BY EVERY CONVERSATION IN THE PROCESS +// ([sharedTeamsStamp]) while it is idle, which is how a conversation made a +// member while it sat idle is noticed; +// - one stat of each team's log only while it is idle AND in a managed team +// with wake on, and a page read only when that stat moved. +// +// A CONVERSATION NOBODY HAS OPEN IS OPENED. A directive to a member no window +// and no host holds, and a reply to a manager in the same state, would wake +// nobody, so the side that wrote the line asks the engine to open that +// conversation headless ([SetTeamResume]); it attaches no surface, and a window +// that opens it later joins the running one. Where there is no such road, the +// Traffic says so (`could not wake @x: …`) rather than the writer pretending. +// +// AND IT IS BOUNDED TWICE. A conversation is woken at most [teamWakesPerHour] +// times in an hour, and a manager woken [teamLoopRounds] times by its team with +// no word from the person stops being woken and asks the person instead: a +// manager and its members answering each other forever is spend nobody asked +// for. Both are said in the Traffic, and each wake is too (`◆ woke @web`, +// `@web woke ◆`), so the rail shows why a conversation is running. + +// teamWatchEvery is how often an idle conversation looks at its team's +// Traffic. A var so a test can ask in milliseconds what the product decides in +// seconds; nothing in the product writes it. +var teamWatchEvery = time.Second + +// teamWakeSettle is how long a manager's wake waits after the first reply +// that asks for it, gathering whatever else arrives. Five seconds: long enough +// that members finishing on one burst of work (a fan-out's replies land within +// a second or two of each other) are one turn, short enough that a person +// watching the manager does not read the pause as the promise being broken. It +// is measured from the FIRST reply and never extended, so a steady trickle +// cannot hold the manager asleep. A var for the reason [teamWatchEvery] is. +var teamWakeSettle = 5 * time.Second + +// teamWakesPerHour is the most times team traffic starts one conversation's +// turn in an hour. Twenty is a directive every three minutes for an hour, +// which is a busy team and not yet a runaway one; past it the lines still +// arrive, at the conversation's next turn. +const teamWakesPerHour = 20 + +// teamLoopRounds is how many times a manager is woken by its team with no word +// from the person before it stops being woken and asks the person. Ten rounds +// of hand out, hear back, hand out again is a real piece of delegated work; a +// manager and members still answering each other after that are more likely +// talking in a circle than finishing, and the person is the one who can tell. +const teamLoopRounds = 10 + +// teamResumeWait is how long opening an absent conversation may take before it +// is reported as a failure: a session host has to start and load it. +const teamResumeWait = 60 * time.Second + +// teamWatch is one conversation's side of the wake: how far into each team's +// Traffic it has looked, the batch a manager is gathering, and the two bounds. +// It is the watch goroutine's own, under [teamSeat.mu] where it shares a read +// with the boundary. +type teamWatch struct { + cursors map[string]string + trafficAt map[string]fileStamp + // pending is what has arrived for a manager since the first line that asks + // for a wake, per team, and due is when the batch is handed over. + pending map[string][]teams.Entry + due time.Time + // woken is when this conversation was woken in the last hour, and limitSaid + // when the Traffic was last told the limit was reached. + woken []time.Time + limitSaid time.Time + // rounds is how many team wakes this conversation (as a manager) has had + // since the person last spoke, heard the person's count at, and held says + // the loop breaker has tripped and is waiting for the person. + rounds int + heard int64 + held bool + // capSaid is the last cap hold the Traffic was told of. + capSaid string +} + +// personTurns counts turns the person started, for the loop breaker. It is +// bumped where every turn begins ([Agent.startTurnLocked]) and read by the +// watch, so it is atomic rather than under either lock. +type personTurns struct{ n atomic.Int64 } + +// notePersonTurn counts a turn that opens on the person's own words. +func (a *Agent) notePersonTurn(user userMessage) { + if user.wake || user.authored || user.empty() { + return + } + a.team.person.n.Add(1) +} + +// watchTeamTraffic starts the watch, or does nothing for a conversation that +// is never in a team ([Config.teamProfile]). +func (a *Agent) watchTeamTraffic(profile string) { + if profile == "" { + return + } + // A wrap-up that was in progress when this process last stopped is armed + // before the loop, so one already past its bound closes on the start + // rather than waiting out a tick (team_wrapup.go). + a.teamWrapUpResume(profile, time.Now()) + guard.Go("team traffic wake", func() { a.teamWatchLoop(profile) }) +} + +func (a *Agent) teamWatchLoop(profile string) { + ticker := time.NewTicker(teamWatchEvery) + defer ticker.Stop() + for range ticker.C { + if !a.teamWatchTick(profile, time.Now()) { + return + } + } +} + +// teamWatchTick is one look, and false once the session has closed. +func (a *Agent) teamWatchTick(profile string, now time.Time) bool { + a.mu.Lock() + closed, running := a.closed, a.running + a.mu.Unlock() + if closed { + return false + } + // THE WRAP-UP'S CLOCK is looked at running or idle (team_wrapup.go), and + // costs nothing while no wrap-up is in progress. + a.teamWrapUpDue(profile, now) + if running { + // A RUNNING TURN READS ITS OWN TRAFFIC at every step boundary. A batch a + // manager was gathering goes with it: its posts land at the next + // boundary, and its events are in the digest that turn carries. + a.team.mu.Lock() + a.team.watch.pending, a.team.watch.due = nil, time.Time{} + a.team.mu.Unlock() + return true + } + a.team.mu.Lock() + roles := a.team.roles + if sharedTeamsStamp(profile) != a.team.teamsAt { + roles = a.teamRolesLocked(profile) + } + var wakeMembers []teamRole + for _, role := range roles { + if !role.managed || !role.wakes || (!role.manager && role.handle == "") { + continue + } + arrived := a.teamWatchReadLocked(profile, role) + var waking []teams.Entry + for _, entry := range arrived { + if teamWakes(role, entry) || teamPacketWakes(profile, role, entry) { + waking = append(waking, entry) + } + } + if len(waking) == 0 { + continue + } + if role.manager { + if a.team.watch.pending == nil { + a.team.watch.pending = map[string][]teams.Entry{} + } + if a.team.watch.due.IsZero() { + a.team.watch.due = now.Add(teamWakeSettle) + } + a.team.watch.pending[role.id] = append(a.team.watch.pending[role.id], waking...) + continue + } + wakeMembers = append(wakeMembers, role) + } + var batch map[string][]teams.Entry + if w := &a.team.watch; len(w.pending) > 0 && !now.Before(w.due) { + batch, w.pending, w.due = w.pending, nil, time.Time{} + } + a.team.mu.Unlock() + if len(wakeMembers) > 0 { + a.teamWakeMember(profile, wakeMembers, now) + } + if len(batch) > 0 { + a.teamWakeManager(profile, roles, batch, now) + } + return true +} + +// teamWatchReadLocked is what has been written to one team's log since this +// conversation last looked, or nothing when the log has not moved. The caller +// holds a.team.mu. +// +// THE LOOK NEVER STARTS BEHIND THE DELIVERY. What a turn's boundary already +// handed over is not a reason to start another turn, so the watch cursor is +// moved up to the delivery cursor whenever that is further on; and a +// conversation with neither starts where its delivery would ([Agent.firstTeamCursor]). +func (a *Agent) teamWatchReadLocked(profile string, role teamRole) []teams.Entry { + w := &a.team.watch + if w.cursors == nil { + w.cursors, w.trafficAt = map[string]string{}, map[string]fileStamp{} + } + a.readTeamCursorsLocked() + cursor, known := w.cursors[role.id] + if delivered, ok := a.team.cursors[role.id]; ok && (!known || delivered > cursor) { + cursor, known = delivered, true + } + if !known { + cursor = a.firstTeamCursor(profile, role) + } + stamp := stampOf(teams.TrafficPath(profile, role.id)) + if known && stamp == w.trafficAt[role.id] && cursor == w.cursors[role.id] { + return nil + } + entries, err := teams.ReadTraffic(profile, role.id, cursor, teamPageLimit) + if err != nil { + w.cursors[role.id] = cursor + return nil + } + for _, entry := range entries { + cursor = entry.ID + } + w.cursors[role.id] = cursor + if len(entries) < teamPageLimit { + w.trafficAt[role.id] = stamp + } else { + w.trafficAt[role.id] = fileStamp{} + } + return entries +} + +// teamWakes reports whether an entry starts this conversation's turn when it +// is idle: a directive from the manager to its handle or to everyone, for a +// member; a member's post to the manager, or a member's finished, failed or +// asking event, for the manager. +func teamWakes(role teamRole, entry teams.Entry) bool { + if role.manager && teams.IsWrapUp(entry) { + return true + } + // A CONFLICT'S RULING wakes the party it names, member or manager, whoever + // wrote it (team_nest.go). + if teams.IsRuling(entry) { + return rulingFor(role, entry) + } + if role.manager { + switch entry.From { + case "", teams.FromManager, teams.FromYou, teams.FromSystem: + return false + } + switch entry.Kind { + case teams.KindNote: + return entry.To == teams.ToManager && strings.TrimSpace(entry.Text) != "" + case teams.KindEvent: + switch entry.State { + case teams.StateFinished, teams.StateFailed, teams.StateAsking: + return true + } + } + return false + } + if entry.Kind != teams.KindDirective || entry.From != teams.FromManager || strings.TrimSpace(entry.Text) == "" || role.shared { + return false + } + return entry.Addressed(role.handle) +} + +// ── the two wakes ─────────────────────────────────────────────────────────── + +// teamWakeMember starts a member's turn on the directives it was sent. +func (a *Agent) teamWakeMember(profile string, roles []teamRole, now time.Time) { + if reason := a.teamWakeLimited(now); reason != "" { + a.teamWakeLimitSay(profile, roles, reason, now) + return + } + if reason := a.teamCapHold(profile, roles); reason != "" { + a.teamCapSay(profile, roles, reason) + return + } + news := a.teamBoundary() + if news == "" { + // A boundary that ran in the moment between the look and here has + // handed the directive over already; there is nothing left to wake on. + return + } + text := "Your manager started this turn (a directive, or the answer to your question); the person did not speak.\n\n" + news + woke, reason := a.teamWakeWith(text) + if woke { + a.teamWakeCount(now) + } + for _, role := range roles { + // The wake answers the directive that caused it, the one the + // boundary above just handed over, so a reader draws the member as + // working on that thread rather than as a line of its own. + answers := a.teamAnswering(role.id) + if woke { + a.teamSay(profile, role.id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromManager, To: role.handle, Member: role.key, + State: teams.StateRunning, Text: "woke @" + role.handle, Answers: answers, + }) + continue + } + if reason != "" { + a.teamSay(profile, role.id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromSystem, To: role.handle, Member: role.key, + State: teams.StateIdle, Text: "could not wake @" + role.handle + ": " + reason, Answers: answers, + }) + } + } +} + +// teamWakeManager starts a manager's turn on the batch its members' replies +// made, or, past the loop bound, asks the person instead. +func (a *Agent) teamWakeManager(profile string, roles []teamRole, batch map[string][]teams.Entry, now time.Time) { + byID := map[string]teamRole{} + for _, role := range roles { + byID[role.id] = role + } + if a.teamLoopHeld(profile, byID, batch) { + return + } + if reason := a.teamWakeLimited(now); reason != "" { + var said []teamRole + for id := range batch { + said = append(said, byID[id]) + } + a.teamWakeLimitSay(profile, said, reason, now) + return + } + var batchRoles []teamRole + for id := range batch { + batchRoles = append(batchRoles, byID[id]) + } + if reason := a.teamCapHold(profile, batchRoles); reason != "" { + a.teamCapSay(profile, batchRoles, reason) + return + } + news := a.teamBoundary() + var groups []string + for id, entries := range batch { + role := byID[id] + if lines := teamEventLines(entries); len(lines) > 0 { + groups = append(groups, fmt.Sprintf("What your members in %q did:\n%s", role.name, strings.Join(lines, "\n"))) + } + } + if news != "" { + groups = append(groups, news) + } + if len(groups) == 0 { + return + } + text := "Your team's replies started this turn; the person did not speak. Act on them: hand out what comes next, or tell the person where the work stands.\n\n" + + strings.Join(groups, "\n\n") + woke, reason := a.teamWakeWith(text) + if woke { + a.teamWakeCount(now) + a.team.mu.Lock() + a.team.watch.rounds++ + a.team.mu.Unlock() + } + for id, entries := range batch { + role := byID[id] + if woke { + a.teamSay(profile, id, teams.Entry{ + Kind: teams.KindEvent, From: teamWakers(entries)[0], To: teams.ToManager, Member: role.key, + State: teams.StateRunning, Text: teamWokeManagerText(entries), + }) + continue + } + if reason != "" { + a.teamSay(profile, id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromSystem, To: teams.ToManager, Member: role.key, + State: teams.StateIdle, Text: "could not wake ◆: " + reason, + }) + } + } +} + +// teamWakeWith queues text as the session's note and starts a turn on it, +// under one hold of the agent's lock so the answer is the wake's own. It +// reports whether a turn was started (or one was already running, which takes +// the note at its next boundary), and why not when neither. +func (a *Agent) teamWakeWith(text string) (bool, string) { + note := userMessage{message: textMessage("user", strings.TrimSpace(text)), wake: true, authored: true} + a.mu.Lock() + defer a.mu.Unlock() + if a.closed { + return false, "its conversation has closed" + } + a.steering = append(a.steering, note) + if a.running { + return true, "" + } + if a.wakeLocked() { + return true, "" + } + switch { + case a.workStopped: + return false, "its work was stopped; it reads this at its next turn" + case wallIsUp(a.steward()): + return false, "its time limit has passed; it reads this at its next turn" + } + if err := a.railBlockLocked(); err != nil { + return false, "its spending limit is reached; it reads this at its next turn" + } + return false, "it cannot start a turn on its own here; it reads this at its next turn" +} + +// ── the bounds ────────────────────────────────────────────────────────────── + +// teamWakeLimited is why this conversation may not be woken again this hour, +// "" when it may. +func (a *Agent) teamWakeLimited(now time.Time) string { + a.team.mu.Lock() + defer a.team.mu.Unlock() + w := &a.team.watch + kept := w.woken[:0] + for _, at := range w.woken { + if now.Sub(at) < time.Hour { + kept = append(kept, at) + } + } + w.woken = kept + if len(kept) < teamWakesPerHour { + return "" + } + return fmt.Sprintf("woken %d times in the last hour, the most team traffic may; it reads the rest at its next turn", teamWakesPerHour) +} + +// teamWakeCount records one wake against the hour. +func (a *Agent) teamWakeCount(now time.Time) { + a.team.mu.Lock() + defer a.team.mu.Unlock() + a.team.watch.woken = append(a.team.watch.woken, now) +} + +// teamCapSay tells the Traffic a wake was held at the cap, once per +// conversation and reason: every held wake says the same thing, and the cap +// packet is what asks the person. +func (a *Agent) teamCapSay(profile string, roles []teamRole, reason string) { + a.team.mu.Lock() + say := a.team.watch.capSaid != reason + a.team.watch.capSaid = reason + a.team.mu.Unlock() + if !say { + return + } + for _, role := range roles { + who, to := "◆", teams.ToManager + if !role.manager { + who, to = "@"+role.handle, role.handle + } + a.teamSay(profile, role.id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromSystem, To: to, Member: role.key, + State: teams.StateIdle, Text: "held " + who + ": " + reason, + }) + } +} + +// teamWakeLimitSay tells the Traffic the limit was reached, once an hour. +func (a *Agent) teamWakeLimitSay(profile string, roles []teamRole, reason string, now time.Time) { + a.team.mu.Lock() + say := a.team.watch.limitSaid.IsZero() || now.Sub(a.team.watch.limitSaid) >= time.Hour + if say { + a.team.watch.limitSaid = now + } + a.team.mu.Unlock() + if !say { + return + } + for _, role := range roles { + who, to := "◆", teams.ToManager + if !role.manager { + who, to = "@"+role.handle, role.handle + } + a.teamSay(profile, role.id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromSystem, To: to, Member: role.key, + State: teams.StateIdle, Text: "could not wake " + who + ": " + reason, + }) + } +} + +// teamLoopHeld is the loop breaker, and true when the manager is not to be +// woken. A turn the person started since the last team wake resets it. +// +// ON THE TRIP IT ASKS THE PERSON: an asking event from the manager in each +// team's Traffic, which the rail draws in the needs-you colour and a digest +// reads as the manager waiting, and a note queued (not waking) in the +// manager's own conversation, so its next turn knows why nothing woke it. +func (a *Agent) teamLoopHeld(profile string, byID map[string]teamRole, batch map[string][]teams.Entry) bool { + heard := a.team.person.n.Load() + a.team.mu.Lock() + w := &a.team.watch + if heard != w.heard { + w.heard, w.rounds, w.held = heard, 0, false + } + if w.rounds < teamLoopRounds { + a.team.mu.Unlock() + return false + } + trip := !w.held + w.held = true + a.team.mu.Unlock() + if !trip { + return true + } + said := fmt.Sprintf("asks: the team has woken me %d times with no word from you, so I have stopped being woken by it until you say something", teamLoopRounds) + for id := range batch { + role := byID[id] + a.teamSay(profile, id, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromManager, To: teams.ToRoom, Member: role.key, + State: teams.StateAsking, Text: said, + }) + } + a.enqueueNote(userMessage{message: textMessage("user", fmt.Sprintf( + "codeaf stopped waking you on your team's replies: they woke you %d times with no word from the person. "+ + "Their lines are still delivered at your next turn. Tell the person where the work stands and ask whether to go on.", teamLoopRounds))}) + return true +} + +// ── what is said ──────────────────────────────────────────────────────────── + +// teamSay appends one entry and forgets a failure: a wake that could not be +// logged still happened, and the conversation's own turn is the record. +func (a *Agent) teamSay(profile, teamID string, entry teams.Entry) { + _ = teams.AppendTraffic(profile, teamID, entry) +} + +// teamEventLines are a manager's batch's events, one line each. +func teamEventLines(entries []teams.Entry) []string { + var lines []string + for _, entry := range entries { + if entry.Kind != teams.KindEvent { + continue + } + who := "@" + strings.TrimPrefix(entry.From, "@") + text := strings.TrimSpace(entry.Text) + switch entry.State { + case teams.StateFinished: + lines = append(lines, who+" finished its turn") + case teams.StateFailed: + if text == "" { + text = "failed" + } + lines = append(lines, who+" "+text) + case teams.StateAsking: + lines = append(lines, who+" is waiting on the person: "+strings.TrimPrefix(text, "asks: ")) + } + } + return lines +} + +// teamWakers is who in a batch woke the manager, in the order they wrote, +// each once. +func teamWakers(entries []teams.Entry) []string { + var out []string + seen := map[string]bool{} + for _, entry := range entries { + if !seen[entry.From] { + seen[entry.From] = true + out = append(out, entry.From) + } + } + if len(out) == 0 { + out = append(out, teams.FromSystem) + } + return out +} + +// teamWokeManagerText is the wake's line on the rail, under the first waker's +// name: "woke ◆", and the others who replied in the same batch. +func teamWokeManagerText(entries []teams.Entry) string { + wakers := teamWakers(entries) + if len(wakers) == 1 { + return "woke ◆" + } + others := make([]string, 0, len(wakers)-1) + for _, from := range wakers[1:] { + others = append(others, "@"+from) + } + return "woke ◆ (with " + strings.Join(others, ", ") + ")" +} + +// ── one stat of the teams file per process per tick ───────────────────────── + +// teamsStampMemo is the teams file's stamp, shared by every conversation this +// process holds, so a host with a dozen idle conversations stats the file once +// per [teamWatchEvery] and not a dozen times. +var teamsStampMemo struct { + mu sync.Mutex + at map[string]memoStamp +} + +type memoStamp struct { + stamp fileStamp + taken time.Time +} + +// sharedTeamsStamp is the teams file's stamp, at most [teamWatchEvery] old. +func sharedTeamsStamp(profile string) fileStamp { + path := teams.Path(profile) + teamsStampMemo.mu.Lock() + defer teamsStampMemo.mu.Unlock() + if teamsStampMemo.at == nil { + teamsStampMemo.at = map[string]memoStamp{} + } + if held, ok := teamsStampMemo.at[path]; ok && time.Since(held.taken) < teamWatchEvery { + return held.stamp + } + stamp := stampOf(path) + teamsStampMemo.at[path] = memoStamp{stamp: stamp, taken: time.Now()} + return stamp +} + +// ── opening a conversation nobody holds ───────────────────────────────────── + +// teamResume is the engine's door for opening a conversation headless, set by +// the process that can ([SetTeamResume]); nil where nothing can. +var teamResume atomic.Pointer[func(file, workspace string) error] + +// SetTeamResume gives this process a way to open a team conversation that no +// window and no host holds, by its transcript and its folder, so the traffic +// that should wake it can. cmd/codeaf's engine sets it to a hello to that +// folder's session host, which opens the conversation and keeps it running +// with no surface attached; a window that opens it later joins that one. nil +// takes the door away. +func SetTeamResume(open func(file, workspace string) error) { + if open == nil { + teamResume.Store(nil) + return + } + teamResume.Store(&open) +} + +// teamRouse opens every one of targets that nothing holds, off the path, and +// says in the Traffic when one could not be. A conversation that is open +// somewhere watches for itself and is left alone. answers is the entry that +// asked for the wake, which a failure to wake answers, "" for none. +func (a *Agent) teamRouse(profile string, team teams.Team, wakes bool, targets []teams.Member, answers string) { + if profile == "" || !wakes || len(targets) == 0 { + return + } + a.team.mu.Lock() + self := append([]string(nil), a.teamKeysLocked()...) + a.team.mu.Unlock() + var absent []teams.Member + for _, member := range targets { + if teamHoldsKey(self, member.Key) { + continue + } + absent = append(absent, member) + } + if len(absent) == 0 { + return + } + guard.Go("team rouse", func() { + for _, member := range absent { + if reason := rouseMember(member); reason != "" { + who, to := "@"+member.Handle, member.Handle + if member.Key == team.Manager { + who, to = "◆", teams.ToManager + } + if to == "" { + who, to = "a member with no handle", teams.ToRoom + } + a.teamSay(profile, team.ID, teams.Entry{ + Kind: teams.KindEvent, From: teams.FromSystem, To: to, Member: member.Key, + State: teams.StateIdle, Text: "could not wake " + who + ": " + reason, Answers: answers, + }) + } + } + }) +} + +// rouseMember opens one conversation when nothing holds it, and says why not +// when it could not; "" is open, either already or now. +func rouseMember(member teams.Member) string { + file := strings.TrimSpace(member.File) + if file == "" { + return "the team has no transcript recorded for it" + } + if _, err := os.Stat(file); err != nil { + return "its transcript is not on this machine" + } + if journalHeld(file) { + return "" + } + open := teamResume.Load() + if open == nil { + return "no window has it open, and this process cannot open a conversation headless; it reads the message when it is next opened" + } + done := make(chan error, 1) + guard.Go("team resume", func() { done <- (*open)(file, strings.TrimSpace(member.Where)) }) + select { + case err := <-done: + if err != nil { + return "opening it headless failed: " + oneLineTeam(err.Error()) + } + return "" + case <-time.After(teamResumeWait): + return "opening it headless did not finish in time" + } +} + +// journalHeld reports whether some process has a conversation's journal open: +// the journal's own flock ([lockSessionFile]), probed without blocking and +// let go at once. A file that cannot be locked at all reads as not held. +func journalHeld(path string) bool { + file, err := os.OpenFile(path, os.O_RDONLY, 0) + if err != nil { + return false + } + defer file.Close() + if err := filelock.Lock(file, true, true); err != nil { + return filelock.IsBusy(err) + } + _ = filelock.Unlock(file) + return false +} diff --git a/internal/session/team_wakewatch_test.go b/internal/session/team_wakewatch_test.go new file mode 100644 index 0000000000..97dd87af6b --- /dev/null +++ b/internal/session/team_wakewatch_test.go @@ -0,0 +1,424 @@ +package session + +import ( + "context" + "encoding/json" + "errors" + "strings" + "sync" + "testing" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// TEAM TRAFFIC WAKES, AS TESTS. Each drives a real agent on a real teams file +// and Traffic log, with the watch's clocks shortened: what is asserted is what +// starts a turn, how often, and what the Traffic says about it. + +// fastTeamWake shortens the watch's two clocks for one test. The watch reads +// them when it starts, so they are set before any agent is made. +func fastTeamWake(t *testing.T) { + t.Helper() + every, settle := teamWatchEvery, teamWakeSettle + teamWatchEvery, teamWakeSettle = 20*time.Millisecond, 300*time.Millisecond + t.Cleanup(func() { teamWatchEvery, teamWakeSettle = every, settle }) +} + +// quietFor lets the watch run for a while so a test can assert nothing more +// happened. +func quietFor() { time.Sleep(15 * teamWatchEvery) } + +// trafficEvents is every event in the fixture's Traffic whose text holds want. +func trafficEvents(t *testing.T, fixture teamFixture, want string) []teams.Entry { + t.Helper() + all, err := teams.ReadTraffic(fixture.profile, fixture.teamID, "", 0) + if err != nil { + t.Fatal(err) + } + var out []teams.Entry + for _, entry := range all { + if entry.Kind == teams.KindEvent && strings.Contains(entry.Text, want) { + out = append(out, entry) + } + } + return out +} + +// waitEvent waits until an event holding want is in the Traffic. +func waitEvent(t *testing.T, fixture teamFixture, want string) teams.Entry { + t.Helper() + deadline := time.Now().Add(5 * time.Second) + for time.Now().Before(deadline) { + if got := trafficEvents(t, fixture, want); len(got) > 0 { + return got[0] + } + time.Sleep(10 * time.Millisecond) + } + t.Fatalf("no event saying %q reached the traffic", want) + return teams.Entry{} +} + +// A DIRECTIVE WAKES AN IDLE MEMBER ONCE, as the manager's line and never the +// person's, and the rail is told. +func TestTeamWakeADirectiveWakesAnIdleMemberOnce(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + completer := oneAnswer(2) + web := teamAgent(t, fixture, fixture.web, completer, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}) + waitRequests(t, completer, 1) + first := userTextIn(completer.request(0)) + if !strings.Contains(first, "◆ directive from manager #1: Fix the header.") { + t.Fatalf("the woken turn did not carry the directive:\n%s", first) + } + if !strings.Contains(first, "the person did not speak") { + t.Errorf("the woken turn does not say who started it:\n%s", first) + } + waitIdle(t, web) + quietFor() + if got := completer.requests(); got != 1 { + t.Fatalf("one directive started %d requests, want 1", got) + } + for _, entry := range web.Transcript() { + if entry.Role == "user" { + t.Fatalf("the woken turn carries words as the person's: %+v", entry) + } + } + woke := waitEvent(t, fixture, "woke @web") + if woke.From != teams.FromManager || woke.State != teams.StateRunning { + t.Errorf("the wake's line is %+v, want from the manager with the member running", woke) + } +} + +// A DIRECTIVE TO SEVERAL WAKES EACH IDLE MEMBER IT NAMES. A send to several is +// one entry carrying their handles, and it is as much a directive to each of +// them as a line to one handle would be, so each is woken, and once. +func TestTeamWakeADirectiveToSeveralWakesEachMemberItNames(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + web, parser := oneAnswer(2), oneAnswer(2) + teamAgent(t, fixture, fixture.web, web, nil) + teamAgent(t, fixture, fixture.parser, parser, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: teams.ToSeveral, Handles: []string{"web", "parser"}, Text: "Fix the header."}) + for name, completer := range map[string]*scriptedCompleter{"web": web, "parser": parser} { + waitRequests(t, completer, 1) + if said := userTextIn(completer.request(0)); !strings.Contains(said, "Fix the header.") { + t.Errorf("@%s was woken without the directive:\n%s", name, said) + } + } + quietFor() + for name, completer := range map[string]*scriptedCompleter{"web": web, "parser": parser} { + if got := completer.requests(); got != 1 { + t.Errorf("one directive to several started %d requests for @%s, want 1", got, name) + } + } +} + +// A NOTE WAKES NOBODY; it is read at the member's next turn. +func TestTeamWakeANoteDoesNotWakeAMember(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + completer := oneAnswer(1) + web := teamAgent(t, fixture, fixture.web, completer, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "The API moved to v2."}) + quietFor() + if got := completer.requests(); got != 0 { + t.Fatalf("a note started %d requests, want none", got) + } + submitAndWait(t, web, "carry on") + if said := userTextIn(completer.request(0)); !strings.Contains(said, "The API moved to v2.") { + t.Fatalf("the note was not read at the next turn:\n%s", said) + } +} + +// A BUSY MEMBER IS NOT STARTED A SECOND TIME. The directive waits for the turn +// in flight, and once that ends it is handed over exactly once. +func TestTeamWakeABusyMemberIsNotStartedTwice(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + release := make(chan struct{}) + completer := &scriptedCompleter{steps: []step{ + func(ctx context.Context, _ []ai.Message) (*ai.Response, error) { + select { + case <-release: + case <-ctx.Done(): + } + return textResponse("done"), nil + }, + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("fixed"), nil }, + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("again"), nil }, + }} + web := teamAgent(t, fixture, fixture.web, completer, nil) + events, err := web.Submit(context.Background(), "work on the footer") + if err != nil { + t.Fatal(err) + } + waitRequests(t, completer, 1) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}) + quietFor() + if got := completer.requests(); got != 1 { + t.Fatalf("a busy member was asked %d times while its turn ran, want 1", got) + } + if got := trafficEvents(t, fixture, "woke @web"); len(got) != 0 { + t.Fatalf("a busy member was woken: %+v", got) + } + close(release) + collect(t, events) + waitRequests(t, completer, 2) + waitIdle(t, web) + quietFor() + if got := completer.requests(); got != 2 { + t.Fatalf("the directive was handed over in %d requests after the turn, want 1", got-1) + } + if said := userTextIn(completer.request(1)); strings.Count(said, "Fix the header.") != 1 { + t.Fatalf("the directive was not handed over once:\n%s", said) + } +} + +// A MANAGER'S WAKE COALESCES: a burst of replies is one turn carrying them all. +func TestTeamWakeTheManagersWakeCoalescesABurst(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + completer := oneAnswer(2) + manager := teamAgent(t, fixture, fixture.manager, completer, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: "web", To: teams.ToManager, State: teams.StateFinished, Text: "finished"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "parser", To: teams.ToManager, Text: "The grammar is done; see grammar.md."}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: "parser", To: teams.ToManager, State: teams.StateFailed, Text: "failed: boom"}) + waitRequests(t, completer, 1) + waitIdle(t, manager) + time.Sleep(2 * teamWakeSettle) + if got := completer.requests(); got != 1 { + t.Fatalf("a burst of three replies started %d turns, want 1", got) + } + said := userTextIn(completer.request(0)) + for _, want := range []string{"@web finished its turn", "from @parser: The grammar is done", "@parser failed: boom", "the person did not speak"} { + if !strings.Contains(said, want) { + t.Errorf("the manager's woken turn lacks %q:\n%s", want, said) + } + } + woke := waitEvent(t, fixture, "woke ◆") + if woke.From != "web" || !strings.Contains(woke.Text, "(with @parser)") { + t.Errorf("the manager's wake line is %+v, want from @web with @parser", woke) + } +} + +// A MEMBER'S EVENTS THAT ASK NOTHING WAKE NOBODY: a stop, a question coming +// down, and the wake lines themselves. +func TestTeamWakeTheManagerSleepsThroughLinesThatAskNothing(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + completer := oneAnswer(1) + teamAgent(t, fixture, fixture.manager, completer, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: "web", To: teams.ToManager, State: teams.StateIdle, Text: "stopped"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: "web", To: teams.ToManager, State: teams.StateRunning, Text: "no longer waiting"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToRoom, Text: "lunch"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: teams.FromManager, To: "web", State: teams.StateRunning, Text: "woke @web"}) + time.Sleep(teamWakeSettle + 15*teamWatchEvery) + if got := completer.requests(); got != 0 { + t.Fatalf("lines that ask nothing of the manager started %d turns", got) + } +} + +// THE WAKE LIMIT HOLDS, and the Traffic says so once. +func TestTeamWakeAConversationIsWokenAtMostTwentyTimesAnHour(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + completer := oneAnswer(1) + web := teamAgent(t, fixture, fixture.web, completer, nil) + now := time.Now() + web.team.mu.Lock() + for i := 0; i < teamWakesPerHour; i++ { + web.team.watch.woken = append(web.team.watch.woken, now.Add(-time.Duration(i)*time.Minute)) + } + web.team.mu.Unlock() + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "And the footer."}) + said := waitEvent(t, fixture, "could not wake @web") + quietFor() + if got := completer.requests(); got != 0 { + t.Fatalf("a conversation past its limit was woken %d times", got) + } + if !strings.Contains(said.Text, "20 times in the last hour") { + t.Errorf("the limit's line does not say the limit: %q", said.Text) + } + if got := trafficEvents(t, fixture, "could not wake @web"); len(got) != 1 { + t.Errorf("the limit was said %d times, want once", len(got)) + } +} + +// THE LOOP BREAKER ASKS THE PERSON rather than wake the manager again, and the +// person speaking resets it. +func TestTeamWakeTheLoopBreakerRaisesItToThePerson(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + completer := oneAnswer(3) + manager := teamAgent(t, fixture, fixture.manager, completer, nil) + manager.team.mu.Lock() + manager.team.watch.rounds = teamLoopRounds + manager.team.watch.heard = manager.team.person.n.Load() + manager.team.mu.Unlock() + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: "web", To: teams.ToManager, State: teams.StateFinished, Text: "finished"}) + asked := waitEvent(t, fixture, "woken me") + if asked.From != teams.FromManager || asked.State != teams.StateAsking { + t.Errorf("the breaker's line is %+v, want an asking event from the manager", asked) + } + quietFor() + if got := completer.requests(); got != 0 { + t.Fatalf("the manager was woken %d times past the loop bound", got) + } + submitAndWait(t, manager, "keep going") + if said := userTextIn(completer.request(0)); !strings.Contains(said, "stopped waking you") { + t.Errorf("the manager was not told why nothing woke it:\n%s", said) + } + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindEvent, From: "parser", To: teams.ToManager, State: teams.StateFinished, Text: "finished"}) + waitRequests(t, completer, 2) +} + +// WITH THE TEAM'S AUTO-WAKE OFF, NOTHING WAKES, and the manager is told so. +func TestTeamWakeAWakeOffTeamWakesNobody(t *testing.T) { + fastTeamWake(t) + fixture := newTeamFixture(t, true) + webAnswers, managerAnswers := oneAnswer(1), oneAnswer(1) + teamAgent(t, fixture, fixture.web, webAnswers, nil) + manager := teamAgent(t, fixture, fixture.manager, managerAnswers, nil) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToManager, Text: "done"}) + time.Sleep(teamWakeSettle + 15*teamWatchEvery) + if webAnswers.requests() != 0 || managerAnswers.requests() != 0 { + t.Fatalf("a team with wake off woke a conversation: web %d, manager %d", webAnswers.requests(), managerAnswers.requests()) + } + submitAndWait(t, manager, "status?") + if role := strings.Join(roleNotes(managerAnswers.request(0)), "\n"); !strings.Contains(role, "auto-wake is off") { + t.Errorf("the manager of a team with wake off was told otherwise:\n%s", role) + } +} + +// THE MANAGER'S ROLE SAYS WHAT WAKES, on a team where it does. +func TestTeamWakeTheManagersRoleSaysDirectivesWakeAndRepliesComeBack(t *testing.T) { + fixture := newWakingTeamFixture(t) + completer := oneAnswer(1) + manager := teamAgent(t, fixture, fixture.manager, completer, nil) + submitAndWait(t, manager, "what's happening?") + role := strings.Join(roleNotes(completer.request(0)), "\n") + for _, want := range []string{"starts an idle member's turn", "a note waits", "come back to you and start your turn"} { + if !strings.Contains(role, want) { + t.Errorf("the manager's role lacks %q:\n%s", want, role) + } + } +} + +// A MEMBER OPENED FOR A DIRECTIVE IS WOKEN BY IT. The engine opens a member +// nobody holds because a directive was just sent to it, and a member that +// never read this team before starts at that directive, not after it. +func TestTeamWakeAMemberOpenedForADirectiveIsWokenByIt(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "old news"}) + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindDirective, From: teams.FromManager, To: "web", Text: "Fix the header."}) + time.Sleep(5 * time.Millisecond) + completer := oneAnswer(1) + teamAgent(t, fixture, fixture.web, completer, nil) + waitRequests(t, completer, 1) + said := userTextIn(completer.request(0)) + if !strings.Contains(said, "Fix the header.") { + t.Fatalf("the member opened for a directive was not handed it:\n%s", said) + } + if strings.Contains(said, "old news") { + t.Errorf("the member was handed traffic from before the directive:\n%s", said) + } +} + +// recordedResume is a stand-in for the engine's door, recording what it was +// asked to open. +type recordedResume struct { + mu sync.Mutex + opened []string + fail error +} + +func (r *recordedResume) open(file, workspace string) error { + r.mu.Lock() + defer r.mu.Unlock() + r.opened = append(r.opened, file+"|"+workspace) + return r.fail +} + +func (r *recordedResume) seen() []string { + r.mu.Lock() + defer r.mu.Unlock() + return append([]string(nil), r.opened...) +} + +func withTeamResume(t *testing.T, open func(file, workspace string) error) { + t.Helper() + SetTeamResume(open) + t.Cleanup(func() { SetTeamResume(nil) }) +} + +func sendDirective(t *testing.T, manager *Agent, to string) string { + t.Helper() + args, _ := json.Marshal(map[string]string{"to": to, "text": "Fix the header.", "kind": "directive"}) + said, failed, err := manager.teamSendTool(context.Background(), args) + if err != nil || failed { + t.Fatalf("team_send refused: %s %v", said, err) + } + return said +} + +// A DIRECTIVE TO A MEMBER NOBODY HOLDS OPENS IT through the engine's door, and +// one somebody holds is left to wake itself. +func TestTeamWakeADirectiveOpensAMemberNobodyHolds(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + recorder := &recordedResume{} + withTeamResume(t, recorder.open) + manager := teamAgent(t, fixture, fixture.manager, oneAnswer(1), nil) + parser := oneAnswer(1) + teamAgent(t, fixture, fixture.parser, parser, nil) + said := sendDirective(t, manager, "web") + if !strings.Contains(said, "starts a turn on it now") || !strings.Contains(said, "wake you") { + t.Errorf("the send does not say what happens next: %s", said) + } + deadline := time.Now().Add(5 * time.Second) + for len(recorder.seen()) == 0 && time.Now().Before(deadline) { + time.Sleep(10 * time.Millisecond) + } + opened := recorder.seen() + if len(opened) != 1 || !strings.HasPrefix(opened[0], fixture.web+"|") { + t.Fatalf("opened %v, want the web member's transcript once", opened) + } + sendDirective(t, manager, "parser") + waitRequests(t, parser, 1) + if got := recorder.seen(); len(got) != 1 { + t.Fatalf("a member that is open was opened again: %v", got) + } +} + +// AND WHERE IT CANNOT BE OPENED, THE TRAFFIC SAYS SO rather than the manager +// being told a wake that never happens. +func TestTeamWakeAMemberThatCannotBeOpenedIsSaidInTheTraffic(t *testing.T) { + fastTeamWake(t) + fixture := newWakingTeamFixture(t) + manager := teamAgent(t, fixture, fixture.manager, oneAnswer(1), nil) + + SetTeamResume(nil) + sendDirective(t, manager, "web") + said := waitEvent(t, fixture, "could not wake @web") + if !strings.Contains(said.Text, "cannot open a conversation headless") { + t.Errorf("the missing road is not named: %q", said.Text) + } + + recorder := &recordedResume{fail: errors.New("the host would not start")} + withTeamResume(t, recorder.open) + sendDirective(t, manager, "web") + deadline := time.Now().Add(5 * time.Second) + for len(trafficEvents(t, fixture, "the host would not start")) == 0 && time.Now().Before(deadline) { + time.Sleep(10 * time.Millisecond) + } + if got := trafficEvents(t, fixture, "the host would not start"); len(got) != 1 { + t.Fatalf("a failed open was said %d times, want once", len(got)) + } +} diff --git a/internal/session/team_wrapup.go b/internal/session/team_wrapup.go new file mode 100644 index 0000000000..4ef73adeeb --- /dev/null +++ b/internal/session/team_wrapup.go @@ -0,0 +1,372 @@ +package session + +// ── WRAP UP FIRST: THE MANAGER'S CLOSING REPORT ───────────────────────────── +// +// The ruling (c-9): a person closing a team with work running picks `Wrap up +// first` by default. The interface appends the one request teams' wrapup.go +// defines ([teams.WrapUpRequest]: a directive from `you` to `manager` whose +// State is [teams.StateWrapUp]) to the team's Traffic, and nothing else: the +// two sides meet only there. +// +// THE MANAGER'S SIDE, here: +// +// - Its delivery hands it the request as an instruction ([wrapUpLine]): +// tell every member to finish and commit (team_send, directive), answer +// what it can of what they ask, start nothing new, then write the closing +// report with `team_close_report` (done, left, where the files are). The +// request wakes an idle manager like a member's reply does. +// - The report is a [teams.PacketClosing] packet to the person with the +// team's spend today, options `Close` and `Keep going`, and a +// recommendation. The team closes only when the person picks `Close` +// ([teams.AcceptClosing], which the interface calls on the click and this +// side calls again on reading the decision; it is idempotent). +// - IT IS BOUNDED, by [wrapUpFor] and by [wrapUpSpendUSD] of the team's +// spend since the request. Past either, with no report, codeaf raises the +// packet itself, marked `wrap-up incomplete`, with `Close now` and `Keep +// going` ([Agent.teamWrapUpDue]). The clock is looked at by the traffic +// watch every tick, running or idle, and costs nothing while no wrap-up is +// in progress. +// +// THE CLOCK IS ON THE TEAM, in teams.json ([teams.Wrap]): the start and the +// bound it was given. A manager that restarts in the middle of one reads it +// back ([Agent.teamWrapUpResume]) and keeps the time that is left. One +// already past its bound raises the incomplete report on that start, once, +// the same way a live clock would have. The person's card still offers +// `Close now` either way (the interface's own road). + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + + "github.com/Agent-Field/codeaf/internal/exec/bare" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// The wrap-up's two bounds. Fifteen minutes is long enough for members to +// finish the piece in hand and commit, and short enough that a person who +// asked to close is not left wondering; two dollars is a few turns of each +// member, which is what finishing costs, and not a second day's work. Vars so +// a test can run a wrap-up out in milliseconds; nothing in the product writes +// them. +var ( + wrapUpFor = 15 * time.Minute + wrapUpSpendUSD float64 = 2 +) + +const teamCloseReportToolName = "team_close_report" + +const teamCloseReportDescription = "Bring the person your team's closing report when you have wrapped up: what was done, what is left, and where the files are. " + + "It goes to the person as a decision with Close and Keep going; the team closes only if they pick Close. Use it when the person asked you to wrap up." + +const teamCloseReportSchema = `{"type":"object","properties":{"done":{"type":"string","description":"What the team finished."},` + + `"left":{"type":"string","description":"What is left, and who had it."},` + + `"files":{"type":"array","items":{"type":"string"},"description":"Where the work is: paths, branches, commits."},` + + teamArgSchema + `},"required":["done"],"additionalProperties":false}` + +// wrapUp is one managed team's wrap-up in progress. +type wrapUp struct { + team string + name string + started time.Time + // bound is how long this wrap-up was given. It is the value of [wrapUpFor] + // when the clock started, kept on the team so a restart does not start + // the limit again. Zero is a clock from before it was stored, and reads + // as [wrapUpFor]. + bound time.Duration + // noted says the start and the bound have been written to the team. + noted bool + // spentAt is the team's spend today when the wrap-up's clock first + // looked, which the spend bound is measured from; measured says it has. + spentAt float64 + measured bool +} + +// wrapUpTools is the manager's report verb. +func (a *Agent) wrapUpTools() []bare.Tool { + return []bare.Tool{ + {Name: teamCloseReportToolName, Description: teamCloseReportDescription, Schema: json.RawMessage(teamCloseReportSchema), Execute: a.teamCloseReportTool}, + } +} + +// teamWrapUpBeginLocked records the wrap-up of role's team, once: a second +// request while one is in progress keeps the first clock. The caller holds +// a.team.mu, so it reads nothing: the spend the bound is measured from is +// taken at the clock's first look ([Agent.teamWrapUpDue]). +func (a *Agent) teamWrapUpBeginLocked(role teamRole, at time.Time) { + if a.team.wraps == nil { + a.team.wraps = map[string]*wrapUp{} + } + if _, going := a.team.wraps[role.id]; going { + return + } + if at.IsZero() { + at = time.Now() + } + a.team.wraps[role.id] = &wrapUp{team: role.id, name: role.name, started: at, bound: wrapUpFor} +} + +// teamWrapUpNote writes every wrap-up this process started and has not yet +// recorded. The caller does not hold a.team.mu: the write takes the file's +// own lock, and holding the seat across it would stall every reader. A second +// start keeps the first clock ([teams.File.SetWrap]). +func (a *Agent) teamWrapUpNote(profile string) { + if profile == "" { + return + } + a.team.mu.Lock() + var pending []wrapUp + for _, w := range a.team.wraps { + if !w.noted { + pending = append(pending, *w) + } + } + a.team.mu.Unlock() + for _, w := range pending { + bound := w.bound + if bound <= 0 { + bound = wrapUpFor + } + if _, _, err := teams.Change(profile, func(f *teams.File) error { + return f.SetWrap(w.team, w.started, bound) + }); err != nil { + continue + } + a.team.mu.Lock() + if held, ok := a.team.wraps[w.team]; ok { + held.noted = true + } + a.team.mu.Unlock() + } +} + +// teamWrapUpResume arms the clock of every team this conversation manages +// that has a wrap-up on disk, then looks at it. A wrap-up still inside its +// bound keeps the start it was given, so the time left is what was left. One +// already past it raises the incomplete report here, on the start, and not +// again: the record is cleared when the report goes out. It is called when +// the session opens ([Agent.watchTeamTraffic]). +func (a *Agent) teamWrapUpResume(profile string, now time.Time) { + if profile == "" { + return + } + a.team.mu.Lock() + roles := a.teamRolesLocked(profile) + file := a.team.file + if a.team.wraps == nil { + a.team.wraps = map[string]*wrapUp{} + } + for _, role := range roles { + if !role.manager || file == nil { + continue + } + t, ok := file.Team(role.id) + if !ok || t.Wrap == nil || t.Closed() { + continue + } + if _, going := a.team.wraps[role.id]; going { + continue + } + a.team.wraps[role.id] = &wrapUp{ + team: role.id, name: role.name, started: t.Wrap.Started, bound: t.Wrap.Bound, noted: true, + } + } + a.team.mu.Unlock() + a.teamWrapUpDue(profile, now) +} + +// clearTeamWrap forgets a wrap-up the clock has finished with. A missing team +// is not an error worth the report's road. +func clearTeamWrap(profile, id string) { + _, _, _ = teams.Change(profile, func(f *teams.File) error { + return f.ClearWrap(id) + }) +} + +// wrapBound is how long w was given. +func wrapBound(w wrapUp) time.Duration { + if w.bound > 0 { + return w.bound + } + return wrapUpFor +} + +// wrapUpLine is the request as the manager is handed it: the person's words, +// and what to do. +func wrapUpLine(role teamRole, entry teams.Entry) string { + return fmt.Sprintf("◆ from the person: %s\n Wrap up %q now: team_send every member a directive to finish the piece in hand, commit its work and report; "+ + "answer what you can of what they ask; start nothing new. Then call team_close_report with what was done, what is left and where the files are. "+ + "You have %s and %s of team spend for this; past either, codeaf sends the person the report as incomplete.", + oneLineTeam(entry.Text), role.name, wrapUpFor.Round(time.Minute), teamMoney(wrapUpSpendUSD)) +} + +// teamWrapUpDue raises the incomplete report for every wrap-up past a bound. +// It is the watch's, every tick, and reads nothing while none is in progress. +func (a *Agent) teamWrapUpDue(profile string, now time.Time) { + a.team.mu.Lock() + if len(a.team.wraps) == 0 { + a.team.mu.Unlock() + return + } + going := make([]wrapUp, 0, len(a.team.wraps)) + for _, w := range a.team.wraps { + going = append(going, *w) + } + a.team.mu.Unlock() + for _, w := range going { + why := "" + spent := a.teamPoolSpend(profile, w.team, teamToday()) + if !w.measured { + a.team.mu.Lock() + if held, ok := a.team.wraps[w.team]; ok { + held.spentAt, held.measured = spent, true + } + a.team.mu.Unlock() + w.spentAt = spent + } + switch { + case now.Sub(w.started) >= wrapBound(w): + why = fmt.Sprintf("the wrap-up ran out of time (%s) before the manager brought its report", wrapBound(w).Round(time.Minute)) + case spent-w.spentAt >= wrapUpSpendUSD: + why = fmt.Sprintf("the wrap-up spent %s, its limit, before the manager brought its report", teamMoney(spent-w.spentAt)) + default: + continue + } + a.team.mu.Lock() + held := a.team.wraps[w.team] + delete(a.team.wraps, w.team) + a.team.mu.Unlock() + if openClosing(profile, w.team) { + // The report is already waiting, so the clock is over. Clearing + // the record is what stops the next start from raising it again. + clearTeamWrap(profile, w.team) + continue + } + if _, err := teams.Raise(profile, closingPacket(w.name, w.team, teams.ClosingReport{ + Done: "not reported: " + why, Left: "unknown: see the team's traffic and each member's conversation", + SpendUSD: roundCents(spent), Incomplete: true, + })); err != nil { + // THE RAISE DID NOT LAND. The clock was taken out before the + // write so a second look during it cannot raise a second report. + // A busy decisions file (ErrBusy after its wait) writes nothing, + // and leaving the clock out would mean this process never tries + // again: only a restart, which reads the disk, would send it. + // Put the same clock back and let the next ordinary look retry. + // A clock begun since the delete is newer and stays. + a.team.mu.Lock() + if held != nil { + if a.team.wraps == nil { + a.team.wraps = map[string]*wrapUp{} + } + if _, ok := a.team.wraps[w.team]; !ok { + a.team.wraps[w.team] = held + } + } + a.team.mu.Unlock() + continue + } + clearTeamWrap(profile, w.team) + } +} + +// openClosing reports whether team already has a closing report waiting. +func openClosing(profile, team string) bool { + waiting, _, err := teams.OpenPackets(profile, teams.Person) + if err != nil { + return false + } + for _, p := range waiting { + if p.Kind == teams.PacketClosing && p.Origin == team { + return true + } + } + return false +} + +// closingPacket is a closing report as the person is asked it. An incomplete +// one offers `Close now` in place of `Close`, and recommends keeping going, +// because nobody has said the work is safe to leave. +func closingPacket(name, team string, report teams.ClosingReport) teams.Packet { + p := teams.Packet{ + Team: teams.Person, Origin: team, Kind: teams.PacketClosing, RaisedBy: teams.FromManager, + Question: fmt.Sprintf("close %s?", name), Report: &report, + } + if report.Incomplete { + p.RaisedBy = teams.FromSystem + p.Question = fmt.Sprintf("close %s? (wrap-up incomplete)", name) + p.Options = []teams.Option{ + {ID: teams.OptionCloseNow, Label: "Close now", Consequence: "every member's turn is stopped and " + name + " closes as it stands"}, + {ID: teams.OptionKeepGoing, Label: "Keep going", Consequence: name + " stays open and its manager carries on"}, + } + p.Recommendation = &teams.Recommendation{Option: teams.OptionKeepGoing, Reason: "the manager has not said the work is safe to leave"} + return p + } + p.Options = []teams.Option{ + {ID: teams.OptionClose, Label: "Close", Consequence: name + " closes; its members, traffic and this report are kept under Closed"}, + {ID: teams.OptionKeepGoing, Label: "Keep going", Consequence: name + " stays open and its manager carries on"}, + } + p.Recommendation = &teams.Recommendation{Option: teams.OptionClose, Reason: "the manager reports the work wrapped up"} + return p +} + +func roundCents(usd float64) float64 { return float64(int64(usd*100+0.5)) / 100 } + +func (a *Agent) teamCloseReportTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Done string `json:"done"` + Left string `json:"left"` + Files []string `json:"files"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + done := strings.TrimSpace(parsed.Done) + if done == "" { + return invalidArgumentsPrefix + "done is empty", true, nil + } + team, _, refusal := a.teamTarget(parsed.Team, true) + if refusal != "" { + return refusal, true, nil + } + profile := a.config.teamProfile() + if openClosing(profile, team.ID) { + return fmt.Sprintf("A closing report for %q is already waiting on the person. Nothing was sent.", team.Name), true, nil + } + var files []string + for _, file := range parsed.Files { + if file = strings.TrimSpace(file); file != "" { + files = append(files, file) + } + } + spent := a.teamPoolSpend(profile, team.ID, teamToday()) + raised, err := teams.Raise(profile, closingPacket(team.Name, team.ID, teams.ClosingReport{ + Done: done, Left: strings.TrimSpace(parsed.Left), Files: files, SpendUSD: roundCents(spent), + })) + if err != nil { + return "The report could not be sent: " + err.Error(), true, nil + } + a.team.mu.Lock() + delete(a.team.wraps, team.ID) + a.team.mu.Unlock() + clearTeamWrap(profile, team.ID) + return fmt.Sprintf("Your closing report went to the person as packet %s. %q closes only if they pick Close; if they pick Keep going you carry on, and you are told either way.", raised.ID, team.Name), false, nil +} + +// closingDecidedLine is a decided closing report as its manager is told it, +// having closed the team when the person accepted it. +func closingDecidedLine(profile string, p teams.Packet) string { + closed, _ := teams.AcceptClosing(profile, p) + switch p.Decision { + case teams.OptionClose, teams.OptionCloseNow: + if closed { + return "◆ the person accepted the closing report: the team is closed. Tell them it is done, and start nothing more in it." + } + return "◆ the person accepted the closing report; the team is closed." + case teams.OptionKeepGoing: + return "◆ the person read the closing report and chose to keep going: the team stays open. Carry on with what is left." + } + return "◆ the person answered the closing report: " + oneLineTeam(p.Decision) +} diff --git a/internal/session/teamcache.go b/internal/session/teamcache.go new file mode 100644 index 0000000000..f4510d95fc --- /dev/null +++ b/internal/session/teamcache.go @@ -0,0 +1,76 @@ +package session + +// WHAT A MANAGER ALREADY KNOWS ABOUT ITS MEMBERS' JOURNALS. +// +// A manager's digest is refreshed beside every turn it takes, and a status is +// asked whenever the model wants one; both read each member's journal to learn +// what it is doing. The read is bounded ([journalTail], 256 KiB from the end of +// each file, and only a line's type, role, time and tool calls are decoded), +// but a team of five idle members would still pay five of those per turn for +// nothing new. So what a journal said is kept against the file's stamp (its +// size and modification time), and a journal whose stamp has not moved costs a +// stat. The clock is applied after the cache ([journalFacts.state]), so a +// member going quiet still reads as idle once [journalStale] passes. + +import ( + "sync" + "time" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// journalCache is the facts last read from each member journal, by path. +type journalCache struct { + mu sync.Mutex + files map[string]cachedJournal +} + +type cachedJournal struct { + at fileStamp + facts journalFacts +} + +// read is the facts for path: the kept ones when its stamp has not moved, +// read again otherwise. A nil cache reads every time. +func (c *journalCache) read(path string) (journalFacts, bool) { + if c == nil { + return readJournalFacts(path) + } + stamp := stampOf(path) + if !stamp.present { + c.forget(path) + return journalFacts{}, false + } + c.mu.Lock() + kept, ok := c.files[path] + c.mu.Unlock() + if ok && kept.at == stamp { + return kept.facts, true + } + facts, ok := readJournalFacts(path) + if !ok { + return journalFacts{}, false + } + c.mu.Lock() + defer c.mu.Unlock() + if c.files == nil { + c.files = map[string]cachedJournal{} + } + c.files[path] = cachedJournal{at: stamp, facts: facts} + return facts, true +} + +func (c *journalCache) forget(path string) { + c.mu.Lock() + defer c.mu.Unlock() + delete(c.files, path) +} + +// stateOf is one member's state and its journal's last instant, off the cache. +func (c *journalCache) stateOf(path string, now time.Time) (teams.MemberState, time.Time, bool) { + facts, ok := c.read(path) + if !ok { + return teams.MemberState{}, time.Time{}, false + } + return facts.state(now), facts.last, true +} diff --git a/internal/session/teamcache_test.go b/internal/session/teamcache_test.go new file mode 100644 index 0000000000..c997ab621b --- /dev/null +++ b/internal/session/teamcache_test.go @@ -0,0 +1,81 @@ +package session + +import ( + "os" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// A JOURNAL WHOSE STAMP HAS NOT MOVED IS NOT READ AGAIN, and one that moved is. +func TestAMembersJournalIsReadOnlyWhenItMoved(t *testing.T) { + fixture := newTeamFixture(t, true) + path := fixture.web + writeJournal(t, path, + sessionEntry{Type: "message", Role: "user", Content: "go"}, + sessionEntry{Type: "pace"}, + ) + info, err := os.Stat(path) + if err != nil { + t.Fatal(err) + } + var cache journalCache + now := time.Now() + if state, _, ok := cache.stateOf(path, now); !ok || state.State != teams.StateIdle { + t.Fatalf("first read %+v", state) + } + + // The same size and the same time: the cache must answer, not the file. + raw, _ := os.ReadFile(path) + swapped := []byte(string(raw)) + copy(swapped[len(swapped)-len(`"pace"`)-40:], []byte("X")) + if err := os.WriteFile(path, swapped, 0o600); err != nil { + t.Fatal(err) + } + if err := os.Chtimes(path, info.ModTime(), info.ModTime()); err != nil { + t.Fatal(err) + } + if state, _, ok := cache.stateOf(path, now); !ok || state.State != teams.StateIdle { + t.Fatalf("an unmoved journal was read again: %+v", state) + } + + // A journal that moved is read again. + writeJournal(t, path, + sessionEntry{Type: "pace"}, + sessionEntry{Type: "message", Role: "user", Content: "next"}, + ) + if state, _, ok := cache.stateOf(path, time.Now()); !ok || state.State != teams.StateRunning { + t.Fatalf("a moved journal was not read again: %+v", state) + } +} + +// THE CURSOR FILE IS WRITTEN WHEN A TEAM IS FIRST MET AND WHEN SOMETHING IS +// DELIVERED, never for lines addressed to somebody else. +func TestTheCursorIsWrittenOnlyWhenItMatters(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.teamBoundary() + path := web.teamCursorFile() + first, err := os.Stat(path) + if err != nil { + t.Fatalf("the first cursor was not written: %v", err) + } + if err := os.Chtimes(path, first.ModTime().Add(-time.Hour), first.ModTime().Add(-time.Hour)); err != nil { + t.Fatal(err) + } + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "parser", Text: "not for web"}) + if news := web.teamBoundary(); news != "" { + t.Fatalf("web was told %q", news) + } + if after, _ := os.Stat(path); !after.ModTime().Equal(first.ModTime().Add(-time.Hour)) { + t.Fatal("the cursor was written for a line addressed to somebody else") + } + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "for web"}) + if news := web.teamBoundary(); news == "" { + t.Fatal("web was not told") + } + if after, _ := os.Stat(path); after.ModTime().Equal(first.ModTime().Add(-time.Hour)) { + t.Fatal("the cursor was not written after a delivery") + } +} diff --git a/internal/session/teamevent.go b/internal/session/teamevent.go new file mode 100644 index 0000000000..fbe8314e5d --- /dev/null +++ b/internal/session/teamevent.go @@ -0,0 +1,402 @@ +package session + +// WHAT A MEMBER TELLS ITS TEAM WITHOUT BEING ASKED: that it finished a turn, +// that a turn failed, and that it is waiting on the person. +// +// These are the three facts the manager and the Traffic rail most need and the +// three a member's words never say, because a member does not narrate its own +// ending. They are [teams.KindEvent] entries in the team's Traffic log, from the +// member's handle to the manager, with [teams.Entry.State] saying what the +// member is now, so a reader colours by a field and not by reading words. +// +// ONE APPEND PER CHANGE OF STATE, NEVER PER STEP. A turn's end is one entry, +// the first question a turn is held on is one entry however many a batch raises +// at once, and the end of that wait is one more. Nothing is written for a step, +// a token or a tool call, and nothing at all is written by a conversation that +// is not a member of a team with a manager: that is decided off an atomic the +// step boundary already keeps current ([Agent.teamRolesLocked]), so a +// conversation in no team pays no disk for any of this. +// +// THE WRITE IS OFF THE PATH. An append takes the log's lock and reads its tail +// for the next id, and neither may stand between a turn and its ending or +// between a question and the person seeing it. So an event is queued here and +// written by one goroutine per burst, in the order it was queued, and +// [Agent.SettleWrites] waits for it the way it waits for every other deferred +// write. +// +// THE PERSON'S WORDS ARE NEVER WRITTEN. An event says what the member is doing +// in the session's own words, and a question's text is the model's or the +// gate's; there is no [teams.KindYou] entry anywhere in this package. + +import ( + "context" + "fmt" + "strconv" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// teamEventText is how many characters of an event's text are written: a +// failure's first line or a question's head, not a report. +const teamEventText = 200 + +// teamStateLook is how much of a team's Traffic a status or a digest reads to +// learn who is asking: the last entries, of which the digest shows the newest +// [teamRecent]. [teams.ReadTraffic] reads the log whole either way, so looking +// further back costs no more disk than showing twenty. +const teamStateLook = teamFirstLook + +// teamEventLane is one conversation's queue of events waiting to be written. +type teamEventLane struct { + // member is whether this conversation is, as of the last time its roles + // were read, a member (not the manager) of a team that has a manager. It is + // the whole gate, read without a lock or a disk. + member atomic.Bool + + mu sync.Mutex + // asking is how many questions holding this conversation's turn are open. + asking int + queue []teamEvent + // done is the running writer's, closed when it has emptied the queue; nil + // when no writer is running. + done chan struct{} +} + +// teamEvent is one event waiting to be written. +type teamEvent struct { + state string + text string + at time.Time +} + +// eventfulRoles reports whether roles make this conversation one whose events +// are written: a member, not the manager, of a team with a manager. +func eventfulRoles(roles []teamRole) bool { + for _, role := range roles { + if role.managed && !role.manager && role.handle != "" { + return true + } + } + return false +} + +// teamEventOwed queues one event, and starts the writer when none is running. +func (a *Agent) teamEventOwed(state, text string) { + if !a.team.events.member.Load() || a.config.teamProfile() == "" { + return + } + lane := &a.team.events + lane.mu.Lock() + defer lane.mu.Unlock() + lane.queue = append(lane.queue, teamEvent{state: state, text: cutRunesTeam(oneLineTeam(text), teamEventText), at: time.Now()}) + if lane.done == nil { + done := make(chan struct{}) + lane.done = done + go a.writeTeamEvents(done) + } +} + +// writeTeamEvents writes the queue in order until it is empty. +func (a *Agent) writeTeamEvents(done chan struct{}) { + defer close(done) + lane := &a.team.events + for { + lane.mu.Lock() + if len(lane.queue) == 0 { + lane.done = nil + lane.mu.Unlock() + return + } + next := lane.queue[0] + lane.queue = lane.queue[1:] + lane.mu.Unlock() + a.writeTeamEvent(next) + } +} + +// writeTeamEvent appends one event to every team this conversation is a +// managed member of. The roles are read again here, off the path: a stat of +// the teams file, and a read only when it moved. A failed append is silence; +// the digest still reads the member's journal. +func (a *Agent) writeTeamEvent(event teamEvent) { + profile := a.config.teamProfile() + if profile == "" { + return + } + for _, role := range a.teamRoles() { + if !role.managed || role.manager || role.handle == "" { + continue + } + // The event answers what the member was last told by its manager, so + // the rail folds it into that thread's reply (internal/teams' thread.go). + err := teams.AppendTraffic(profile, role.id, teams.Entry{ + At: event.at, + Kind: teams.KindEvent, + From: role.handle, + To: teams.ToManager, + Member: role.key, + Text: event.text, + State: event.state, + Answers: a.teamAnswering(role.id), + }) + if err != nil || !role.wakes { + continue + } + switch event.state { + case teams.StateFinished, teams.StateFailed, teams.StateAsking: + // These wake the manager, so a manager nobody has open is opened + // (team_wakewatch.go). + a.rouseManager(profile, role) + } + } +} + +// rouseManager opens the manager of role's team if nothing holds it. +func (a *Agent) rouseManager(profile string, role teamRole) { + a.team.mu.Lock() + file := a.team.file + a.team.mu.Unlock() + if file == nil { + return + } + team, ok := file.Team(role.id) + if !ok { + return + } + if manager, ok := team.Member(team.Manager); ok { + a.teamRouse(profile, team, role.wakes, []teams.Member{manager}, "") + } +} + +// settleTeamEvents waits until every queued event is written. +func (a *Agent) settleTeamEvents() { + lane := &a.team.events + lane.mu.Lock() + done := lane.done + lane.mu.Unlock() + if done != nil { + <-done + } +} + +// ── the three moments ─────────────────────────────────────────────────────── + +// teamTurnEnded is a turn's ending, told once: failed when the turn ended on +// an error, stopped when somebody stopped it, finished otherwise. It is called +// by the turn's own cleanup (agent.go) after the questions the turn raised are +// retired, so a wait the turn ended inside is closed before the ending is said. +func (a *Agent) teamTurnEnded(ctx context.Context, hub *eventHub) { + if !a.team.events.member.Load() { + return + } + a.dropOwedResume() + if err := hub.turnError(); err != nil { + a.teamEventOwed(teams.StateFailed, "failed: "+firstLineTeam(err.Error())) + return + } + if ctx.Err() != nil { + a.teamEventOwed(teams.StateIdle, "stopped") + return + } + a.teamEventOwed(teams.StateFinished, "finished") +} + +// dropOwedResume takes back a "no longer waiting" that has not been written +// yet, because the ending about to be queued says more. +func (a *Agent) dropOwedResume() { + lane := &a.team.events + lane.mu.Lock() + defer lane.mu.Unlock() + kept := lane.queue[:0] + for _, event := range lane.queue { + if event.state != teams.StateRunning { + kept = append(kept, event) + } + } + lane.queue = kept +} + +// teamAsking is a question raised, and the function that says it came down. +// +// ONLY A QUESTION THE TURN IS STOPPED ON COUNTS, because that is what "waiting +// on the person" means: a permission prompt, an `ask`, a proposal the turn +// waits for. The first one up is an event and the last one down is another; +// the ones between are the same state and write nothing. +func (a *Agent) teamAsking(q Question) func() { + if !q.Blocking.Turn || !a.team.events.member.Load() { + return func() {} + } + lane := &a.team.events + lane.mu.Lock() + lane.asking++ + first := lane.asking == 1 + lane.mu.Unlock() + if first { + a.teamEventOwed(teams.StateAsking, askingWords(q)) + } + var once sync.Once + return func() { + once.Do(func() { + lane.mu.Lock() + lane.asking-- + last := lane.asking == 0 + lane.mu.Unlock() + if last { + a.teamEventOwed(teams.StateRunning, "no longer waiting") + } + }) + } +} + +// askingWords is what a waiting event says: the gate's own line for a +// permission prompt ("needs your ok to run bash"), and the question for +// anything else. +func askingWords(q Question) string { + head := strings.TrimSpace(q.Head) + if q.Ask == AskPermission { + return head + } + return "asks: " + head +} + +// turnError is the error a turn ended on, nil for a turn that did not end on +// one. It reads the backlog the hub keeps for the turn, once, at the turn's +// end: an [EventError] is only ever sent as a turn's last word. +func (h *eventHub) turnError() error { + if h == nil { + return nil + } + h.mu.Lock() + defer h.mu.Unlock() + for index := len(h.backlog) - 1; index >= 0; index-- { + if event := h.backlog[index]; event.Kind == EventError { + if event.Err == nil { + return fmt.Errorf("the turn ended on an error") + } + return event.Err + } + } + return nil +} + +// ── reading them back ─────────────────────────────────────────────────────── + +// askingStaleBound is how long an asking event may keep a member asking. A +// permission prompt nobody has answered in half an hour is not still waiting +// in the digest, and a process that died on one leaves the event as its last +// word with the journal unmoved. +const askingStaleBound = 30 * time.Minute + +// askingFromEvents is a member's state with its newest event weighed in. +// +// A PERMISSION PROMPT IS NOT IN THE JOURNAL: the call it is about was written +// before the prompt was raised and its result is written after it is answered, +// so a member held on one reads as running off its journal alone. Its own +// asking event says otherwise, and it holds while the journal has not moved +// since: a journal line written after the event (the call's result, a turn's +// pace line) is the member having moved on, whatever the log says after. +// +// IT GOES STALE TWO WAYS, and then the member reads idle. Nothing holding the +// transcript lock means the process that raised the prompt is gone (the same +// probe a wake uses, [journalHeld]). An event older than [askingStaleBound] +// is over even while a process still holds the lock. +func askingFromEvents(state teams.MemberState, last time.Time, member teams.Member, log []teams.Entry, now time.Time) teams.MemberState { + for index := len(log) - 1; index >= 0; index-- { + entry := log[index] + if entry.Kind != teams.KindEvent || !eventConcerns(entry, member) { + continue + } + if entry.State != teams.StateAsking || entry.At.Before(last) { + return state + } + if askingStale(member, entry, now) { + state.State = teams.StateIdle + state.Question = "" + return state + } + state.State = teams.StateAsking + if state.Question == "" { + state.Question = strings.TrimPrefix(entry.Text, "asks: ") + } + return state + } + return state +} + +// askingStale reports whether an asking event no longer means the member is +// waiting on the person. +func askingStale(member teams.Member, entry teams.Entry, now time.Time) bool { + if !entry.At.IsZero() && now.Sub(entry.At) >= askingStaleBound { + return true + } + return !journalHeld(member.File) +} + +// eventConcerns reports whether an event is about member. +func eventConcerns(entry teams.Entry, member teams.Member) bool { + if entry.Member != "" { + return entry.Member == member.Key + } + return member.Handle != "" && entry.From == member.Handle +} + +// recentOf is the newest [teamRecent] entries of log. +func recentOf(log []teams.Entry) []teams.Entry { + if len(log) > teamRecent { + return log[len(log)-teamRecent:] + } + return log +} + +// ── the brief ─────────────────────────────────────────────────────────────── + +// teamBriefText is how many characters of a brief are delivered. A brief is +// the whole assignment, so it is allowed more than a message. +const teamBriefText = 12000 + +// teamBriefLine is a [teams.KindStart] entry as the member it started is told +// it: the manager's brief, marked as the manager's, on the new conversation's +// first request. Only the member the start names is told, and only a start the +// manager wrote; every other reader is told nothing, because the interface +// performs a start and the manager already knows what it asked for. +func teamBriefLine(role teamRole, entry teams.Entry) string { + if role.manager || role.handle == "" || entry.From != teams.FromManager || entry.To != role.handle { + return "" + } + text := strings.TrimSpace(entry.Text) + if text == "" { + return "" + } + return teamBriefWord + teamNumber(entry) + ": " + indentAfterFirst(cutRunesTeam(text, teamBriefText)) +} + +// teamBriefWord opens the brief's line, beside "◆ from manager" and +// "◆ directive from manager". +const teamBriefWord = "◆ brief from manager" + +// teamCursorBefore is the cursor that reads id itself next: the id one below +// it, zero-padded the way [teams.AppendTraffic] pads. +func teamCursorBefore(id string) string { + n, err := strconv.ParseInt(id, 10, 64) + if err != nil || n <= 1 { + return teamLogStart + } + return fmt.Sprintf("%0*d", len(teamLogStart), n-1) +} + +// firstLineTeam is text's first non-empty line. +func firstLineTeam(text string) string { + for _, line := range strings.Split(text, "\n") { + if line = strings.TrimSpace(line); line != "" { + return line + } + } + return "" +} + +// oneLineTeam is text with its whitespace runs made single spaces. +func oneLineTeam(text string) string { return strings.Join(strings.Fields(text), " ") } diff --git a/internal/session/teamevent_test.go b/internal/session/teamevent_test.go new file mode 100644 index 0000000000..0d6743683f --- /dev/null +++ b/internal/session/teamevent_test.go @@ -0,0 +1,370 @@ +package session + +// THE TEAM'S EVENTS AND THE BRIEF, AS TESTS: what a member says without being +// asked, how a status reads a member held on a prompt, what the person is asked +// when a manager starts a member, and how a started member is handed its brief. + +import ( + "context" + "encoding/json" + "errors" + "os" + "strings" + "testing" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/approval" + "github.com/Agent-Field/codeaf/internal/filelock" + "github.com/Agent-Field/codeaf/internal/teams" +) + +// holdJournal is a process holding a member's transcript lock, the way a live +// session does, for as long as the test runs. +func holdJournal(t *testing.T, path string) { + t.Helper() + file, err := os.Open(path) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { file.Close() }) + if err := filelock.Lock(file, true, true); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = filelock.Unlock(file) }) +} + +// teamEvents is every event in the fixture's log, oldest first. +func teamEvents(t *testing.T, fixture teamFixture) []teams.Entry { + t.Helper() + all, err := teams.ReadTraffic(fixture.profile, fixture.teamID, teamLogStart, 0) + if err != nil { + t.Fatal(err) + } + var events []teams.Entry + for _, entry := range all { + if entry.Kind == teams.KindEvent { + events = append(events, entry) + } + } + return events +} + +func TestAMemberTellsItsManagerHowEachTurnEnded(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.teamBoundary() + + failed := &eventHub{} + failed.send(Event{Kind: EventError, Err: errors.New("provider said no\nand more")}) + web.teamTurnEnded(context.Background(), failed) + stopped, stop := context.WithCancel(context.Background()) + stop() + web.teamTurnEnded(stopped, &eventHub{}) + web.teamTurnEnded(context.Background(), &eventHub{}) + web.settleTeamEvents() + + events := teamEvents(t, fixture) + want := []struct{ state, text string }{ + {teams.StateFailed, "failed: provider said no"}, + {teams.StateIdle, "stopped"}, + {teams.StateFinished, "finished"}, + } + if len(events) != len(want) { + t.Fatalf("%d events written, want %d: %+v", len(events), len(want), events) + } + for index, event := range events { + if event.From != "web" || event.To != teams.ToManager || event.Member != convKeyOf(t, fixture.web) || + event.State != want[index].state || event.Text != want[index].text { + t.Errorf("event %d is %+v, want web -> manager, state %s, text %q", index, event, want[index].state, want[index].text) + } + } +} + +// A WHOLE TURN WRITES ONE EVENT, whatever it did inside. +func TestATurnWritesOneEventAtItsEnd(t *testing.T) { + fixture := newTeamFixture(t, true) + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("done"), nil }, + }} + web := teamAgent(t, fixture, fixture.web, completer, nil) + events, err := web.Submit(context.Background(), "go") + if err != nil { + t.Fatal(err) + } + collect(t, events) + web.settleTeamEvents() + written := teamEvents(t, fixture) + if len(written) != 1 || written[0].State != teams.StateFinished { + t.Fatalf("a turn wrote %+v, want one finished event", written) + } +} + +func TestOnlyAManagedMemberWritesEvents(t *testing.T) { + managed := newTeamFixture(t, true) + manager := teamAgent(t, managed, managed.manager, nil, nil) + manager.teamBoundary() + manager.teamTurnEnded(context.Background(), &eventHub{}) + manager.settleTeamEvents() + if events := teamEvents(t, managed); len(events) != 0 { + t.Fatalf("the manager wrote events about itself: %+v", events) + } + + unmanaged := newTeamFixture(t, false) + web := teamAgent(t, unmanaged, unmanaged.web, nil, nil) + web.teamBoundary() + web.teamTurnEnded(context.Background(), &eventHub{}) + web.settleTeamEvents() + if events := teamEvents(t, unmanaged); len(events) != 0 { + t.Fatalf("a member of a team with no manager wrote events: %+v", events) + } +} + +// ONE EVENT UP AND ONE DOWN, however many questions a batch raises. +func TestAWaitIsOneEventUpAndOneDown(t *testing.T) { + fixture := newTeamFixture(t, true) + web := teamAgent(t, fixture, fixture.web, nil, nil) + web.teamBoundary() + permission := Question{Ask: AskPermission, Head: "needs your ok to run bash", Blocking: Blocking{Turn: true}} + first := web.teamAsking(permission) + second := web.teamAsking(permission) + quiet := web.teamAsking(Question{Ask: AskChoice, Head: "not blocking"}) + quiet() + first() + first() + second() + web.settleTeamEvents() + events := teamEvents(t, fixture) + if len(events) != 2 { + t.Fatalf("%d events, want one asking and one back to work: %+v", len(events), events) + } + if events[0].State != teams.StateAsking || events[0].Text != "needs your ok to run bash" { + t.Errorf("the wait was written as %+v", events[0]) + } + if events[1].State != teams.StateRunning { + t.Errorf("the end of the wait was written as %+v", events[1]) + } + + web.teamAsking(Question{Ask: AskClarification, Head: "Which colour?", Blocking: Blocking{Turn: true}}) + web.settleTeamEvents() + if events := teamEvents(t, fixture); events[len(events)-1].Text != "asks: Which colour?" { + t.Errorf("a question was written as %+v", events[len(events)-1]) + } +} + +// A MEMBER HELD ON A PERMISSION PROMPT READS AS ASKING, and as running again +// once its journal moves past the prompt. +func TestAMemberHeldOnAPromptReadsAsAsking(t *testing.T) { + fixture := newTeamFixture(t, true) + now := time.Now() + callAt := now.Add(-time.Minute) + writeJournal(t, fixture.web, + sessionEntry{Type: "message", Role: "user", Content: "next", Timestamp: callAt.Add(-time.Second).Format(time.RFC3339Nano)}, + sessionEntry{Type: "message", Role: "assistant", Timestamp: callAt.Format(time.RFC3339Nano), + ToolCalls: []ai.ToolCall{{ID: "c1", Type: "function", Function: ai.ToolCallFunction{Name: "bash", Arguments: `{"command":"make"}`}}}}, + ) + holdJournal(t, fixture.web) + appendTraffic(t, fixture, teams.Entry{At: callAt.Add(time.Second), Kind: teams.KindEvent, From: "web", To: teams.ToManager, + Member: convKeyOf(t, fixture.web), Text: "needs your ok to run bash", State: teams.StateAsking}) + file, err := teams.Load(fixture.profile) + if err != nil { + t.Fatal(err) + } + team, _ := file.Team(fixture.teamID) + log, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", teamStateLook) + web := memberStates(team, nil, now, log, nil)[convKeyOf(t, fixture.web)] + if web.State != teams.StateAsking || web.Question != "needs your ok to run bash" { + t.Fatalf("a member held on a prompt reads %+v", web) + } + + writeJournal(t, fixture.web, + sessionEntry{Type: "message", Role: "user", Content: "next", Timestamp: callAt.Add(-time.Second).Format(time.RFC3339Nano)}, + sessionEntry{Type: "message", Role: "assistant", Timestamp: callAt.Format(time.RFC3339Nano), + ToolCalls: []ai.ToolCall{{ID: "c1", Type: "function", Function: ai.ToolCallFunction{Name: "bash", Arguments: `{"command":"make"}`}}}}, + sessionEntry{Type: "message", Role: "tool", ToolCallID: "c1", Content: "ok", Timestamp: callAt.Add(2 * time.Second).Format(time.RFC3339Nano)}, + ) + if web := memberStates(team, nil, now, log, nil)[convKeyOf(t, fixture.web)]; web.State != teams.StateRunning { + t.Fatalf("a member whose prompt was answered reads %+v", web) + } +} + +// A PROCESS THAT DIED ON THE PROMPT IS NOT STILL ASKING. Nothing holds the +// transcript lock, so the asking event is stale and the member reads idle. +func TestADeadMemberWaitingOnAPromptReadsIdle(t *testing.T) { + fixture := newTeamFixture(t, true) + now := time.Now() + callAt := now.Add(-time.Minute) + writeJournal(t, fixture.web, + sessionEntry{Type: "message", Role: "user", Content: "next", Timestamp: callAt.Add(-time.Second).Format(time.RFC3339Nano)}, + sessionEntry{Type: "message", Role: "assistant", Timestamp: callAt.Format(time.RFC3339Nano), + ToolCalls: []ai.ToolCall{{ID: "c1", Type: "function", Function: ai.ToolCallFunction{Name: "bash", Arguments: `{"command":"make"}`}}}}, + ) + appendTraffic(t, fixture, teams.Entry{At: callAt.Add(time.Second), Kind: teams.KindEvent, From: "web", To: teams.ToManager, + Member: convKeyOf(t, fixture.web), Text: "needs your ok to run bash", State: teams.StateAsking}) + file, err := teams.Load(fixture.profile) + if err != nil { + t.Fatal(err) + } + team, _ := file.Team(fixture.teamID) + log, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", teamStateLook) + web := memberStates(team, nil, now, log, nil)[convKeyOf(t, fixture.web)] + if web.State != teams.StateIdle || web.Question != "" { + t.Fatalf("a member whose process died on a prompt reads %+v, want idle", web) + } +} + +// AN ASKING EVENT OLDER THAN THE BOUND IS IDLE EVEN WHILE THE LOCK IS HELD. +func TestAnOldAskingEventReadsIdle(t *testing.T) { + fixture := newTeamFixture(t, true) + now := time.Now() + callAt := now.Add(-31 * time.Minute) + writeJournal(t, fixture.web, + sessionEntry{Type: "message", Role: "user", Content: "next", Timestamp: callAt.Add(-time.Second).Format(time.RFC3339Nano)}, + sessionEntry{Type: "message", Role: "assistant", Timestamp: callAt.Format(time.RFC3339Nano), + ToolCalls: []ai.ToolCall{{ID: "c1", Type: "function", Function: ai.ToolCallFunction{Name: "bash", Arguments: `{"command":"make"}`}}}}, + ) + holdJournal(t, fixture.web) + appendTraffic(t, fixture, teams.Entry{At: callAt.Add(time.Second), Kind: teams.KindEvent, From: "web", To: teams.ToManager, + Member: convKeyOf(t, fixture.web), Text: "needs your ok to run bash", State: teams.StateAsking}) + file, err := teams.Load(fixture.profile) + if err != nil { + t.Fatal(err) + } + team, _ := file.Team(fixture.teamID) + log, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, "", teamStateLook) + web := memberStates(team, nil, now, log, nil)[convKeyOf(t, fixture.web)] + if web.State != teams.StateIdle { + t.Fatalf("an asking event older than the bound reads %+v, want idle", web) + } +} + +// ── the start's card ──────────────────────────────────────────────────────── + +func TestTheStartsCardSaysWhoIsStartedAndWhatItCosts(t *testing.T) { + call := ai.ToolCall{ID: "s1", Type: "function", Function: ai.ToolCallFunction{Name: teamStartToolName, + Arguments: `{"handle":"@Lexer","brief":"Rewrite the lexer so string escapes are handled in one pass\nthen the tests"}`}} + if head := ConsentHead(call.Function.Name, call.Function.Arguments); head != "◆ manager wants to start @lexer" { + t.Errorf("the head is %q", head) + } + if head := ConsentHead(call.Function.Name, argsText(call)); head != "◆ manager wants to start @lexer" { + t.Errorf("the head off the event's args is %q", head) + } + if said := gloss(call); said != "team_start @lexer: Rewrite the lexer so string escapes are handled in one pass" { + t.Errorf("the gloss is %q", said) + } + if reason := consentReason(call, approval.Decision{}); reason != teamStartCost { + t.Errorf("the reason is %q", reason) + } + if rule := consentRule(call, approval.Decision{Rule: "a rule said so"}); rule != "a rule said so" { + t.Errorf("a policy's own words were replaced: %q", rule) + } + bash := ai.ToolCall{Function: ai.ToolCallFunction{Name: "bash", Arguments: `{"command":"ls"}`}} + if head := ConsentHead("bash", bash.Function.Arguments); head != "needs your ok to run bash" { + t.Errorf("an ordinary head changed: %q", head) + } + if reason := consentReason(bash, approval.Decision{}); reason != ConsentFallbackReason { + t.Errorf("an ordinary reason changed: %q", reason) + } + if head := ConsentHead(teamStartToolName, `{"brief":"no handle"}`); head != "needs your ok to run team_start" { + t.Errorf("a start with no handle reads %q", head) + } +} + +func TestAStopWithNoReasonStillCarriesOne(t *testing.T) { + fixture := newTeamFixture(t, true) + manager := teamAgent(t, fixture, fixture.manager, nil, nil) + if text, failed, _ := manager.teamStopTool(context.Background(), json.RawMessage(`{"handle":"web"}`)); failed { + t.Fatal(text) + } + entries, _ := teams.ReadTraffic(fixture.profile, fixture.teamID, teamLogStart, 0) + if len(entries) != 1 || entries[0].Kind != teams.KindStop || strings.TrimSpace(entries[0].Text) == "" { + t.Fatalf("the stop was written as %+v", entries) + } +} + +// ── the brief ─────────────────────────────────────────────────────────────── + +// A STARTED MEMBER IS HANDED ITS BRIEF ON ITS FIRST REQUEST, marked as the +// manager's, recorded as the session's note, and replayed as a line a surface +// can draw as a quoted card. +func TestAStartedMemberIsHandedItsBriefAsTheManagers(t *testing.T) { + fixture := newTeamFixture(t, true) + brief := "Rewrite the lexer.\n\nDone is: the escape tests pass." + appendTraffic(t, fixture, teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: "parser", Text: brief}) + time.Sleep(2 * time.Millisecond) + completer := &scriptedCompleter{steps: []step{ + func(context.Context, []ai.Message) (*ai.Response, error) { return textResponse("starting"), nil }, + }} + parser := teamAgent(t, fixture, fixture.parser, completer, nil) + events, err := parser.Submit(context.Background(), "go") + if err != nil { + t.Fatal(err) + } + collect(t, events) + request := userTextIn(completer.request(0)) + if !strings.Contains(request, teamBriefWord+" #1: Rewrite the lexer.") || !strings.Contains(request, "not the person's words") { + t.Fatalf("the first request did not carry the marked brief:\n%s", request) + } + var asides []DisplayEntry + for _, entry := range parser.Transcript() { + if entry.Role == "user" && strings.Contains(entry.Text, "Rewrite the lexer") { + t.Fatalf("the brief was recorded as the person's words: %+v", entry) + } + if entry.Role == "aside" && entry.Team != nil { + asides = append(asides, entry) + } + } + if len(asides) != 1 || len(asides[0].Team) != 1 { + t.Fatalf("the brief replays as %+v", asides) + } + line := asides[0].Team[0] + if line.Kind != teams.KindStart || line.From != teams.FromManager || line.To != "" || line.Team != "harbor" || line.Text != brief { + t.Fatalf("the brief's line is %+v", line) + } + + web := teamAgent(t, fixture, fixture.web, nil, nil) + if news := web.teamBoundary(); strings.Contains(news, "Rewrite the lexer") { + t.Fatalf("another member was handed the brief: %q", news) + } +} + +// THE PARSE AND THE COMPOSER AGREE on every shape a delivery has. +func TestADeliveryReadsBackLineByLine(t *testing.T) { + member := teamRole{id: "t", name: `the "harbor"`, handle: "web", managed: true} + manager := teamRole{id: "t", name: "harbor", handle: "boss", manager: true, managed: true} + entries := []teams.Entry{ + {Kind: teams.KindStart, From: teams.FromManager, To: "web", Text: "the brief\nsecond line"}, + {Kind: teams.KindNote, From: teams.FromManager, To: "web", Text: "a note: with a colon"}, + {Kind: teams.KindDirective, From: teams.FromManager, To: teams.ToEveryone, Text: "freeze"}, + {Kind: teams.KindNote, From: "parser", To: teams.ToRoom, Text: "tokens ready"}, + } + var lines []string + for _, entry := range entries { + lines = append(lines, teamLine(member, entry)) + } + managerLines := []string{ + teamLine(manager, teams.Entry{Kind: teams.KindNote, From: "web", To: teams.ToManager, Text: "blocked"}), + teamLine(manager, teams.Entry{Kind: teams.KindNote, From: "web", To: "parser", Text: "shape?"}), + } + text := teamNewsGroup(member, lines) + "\n\n" + teamNewsGroup(manager, managerLines) + got := teamNewsLines(text) + want := []TeamLine{ + {Team: `the "harbor"`, From: teams.FromManager, Kind: teams.KindStart, Text: "the brief\nsecond line"}, + {Team: `the "harbor"`, From: teams.FromManager, Kind: teams.KindNote, Text: "a note: with a colon"}, + {Team: `the "harbor"`, From: teams.FromManager, To: teams.ToEveryone, Kind: teams.KindDirective, Text: "freeze"}, + {Team: `the "harbor"`, From: "parser", To: teams.ToRoom, Kind: teams.KindNote, Text: "tokens ready"}, + {Team: "harbor", From: "web", Kind: teams.KindNote, Text: "blocked"}, + {Team: "harbor", From: "web", To: "parser", Kind: teams.KindNote, Text: "shape?"}, + } + if len(got) != len(want) { + t.Fatalf("%d lines read back, want %d:\n%s\n%+v", len(got), len(want), text, got) + } + for index := range want { + if got[index] != want[index] { + t.Errorf("line %d reads %+v, want %+v", index, got[index], want[index]) + } + } + if teamNewsLines("a task landed") != nil { + t.Error("an ordinary aside was read as a delivery") + } +} diff --git a/internal/session/teamname.go b/internal/session/teamname.go new file mode 100644 index 0000000000..3a8c59d050 --- /dev/null +++ b/internal/session/teamname.go @@ -0,0 +1,118 @@ +package session + +import ( + "context" + "errors" + "strings" + "unicode" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/roles" +) + +// A team's name, suggested once. +// +// A person grouping conversations on the conversations view is offered a name +// for the group before they type one. When the conversations share a project +// folder the surface offers the folder's name and never asks; otherwise it asks +// here, once, over the conversations' own titles, and a person who has started +// typing has already answered. +// +// IT IS THE CONVERSATION NAMER'S ERRAND WITH A SMALLER QUESTION. It goes through +// the same door ([Agent.callRoleChecked]) on the same role ([roles.RoleTitle]), +// so it lands on the cheap tier a person has configured for names and is billed +// the same way: against the model that answered, off every turn's clock. It is +// one ask with no ladder of retries of its own, because the caller holds a word +// already and a slow answer is simply not used. + +// teamNameAsk is the instruction, last in the user message for the reason +// titleSystem's comment gives. +const teamNameAsk = "Give these conversations one short shared name: one to three plain lowercase words, no quotes. Answer with the name only." + +// teamNameClip bounds each title handed to the namer, and teamNameTitles how +// many are sent: a name for a group is read off a handful of short titles. +const ( + teamNameClip = 120 + teamNameTitles = 12 +) + +// teamNameWords is the most words a suggested team name keeps. +const teamNameWords = 3 + +// NameTeam asks the naming role for a short name for a group of +// conversations, given their titles. It makes one call, which the caller +// bounds with ctx, and returns the name or an error; an answer that is not a +// name is an error, never a name. +func (a *Agent) NameTeam(ctx context.Context, titles []string) (string, error) { + var lines []string + for _, t := range titles { + if t = strings.TrimSpace(t); t != "" && len(lines) < teamNameTitles { + lines = append(lines, "- "+clip(t, teamNameClip)) + } + } + if len(lines) == 0 { + return "", errInvalidName + } + a.mu.Lock() + model, closed := a.model, a.closed + a.mu.Unlock() + if closed { + return "", errors.New("the conversation is closed") + } + ask := "Conversations:\n" + strings.Join(lines, "\n") + "\n\n" + teamNameAsk + response, named, err := a.callRoleChecked(ctx, roles.RoleTitle, model, + []ai.Message{textMessage("system", titleSystem), textMessage("user", ask)}, + func(response *ai.Response, named string) bool { + if cleanTeamName(response.Text()) != "" { + return true + } + a.addDetachedUsageAs(response, named, 1, auxRoleTitle) + return false + }) + if err != nil { + return "", err + } + if response == nil { + return "", errEmptyAnswer + } + a.addDetachedUsageAs(response, named, 1, auxRoleTitle) + name := cleanTeamName(response.Text()) + if name == "" { + return "", errInvalidName + } + return name, nil +} + +// cleanTeamName is a model's answer as a team name: the first line cleaned as +// a title is ([cleanTitle] refuses an echoed instruction or a sentence about +// the speaker), lowercased, cut to [teamNameWords] words, and with anything but +// letters, digits and inner hyphens taken off each word. It is "" when nothing +// usable is left. +func cleanTeamName(raw string) string { + title := cleanTitle(raw) + if title == "" { + return "" + } + var words []string + for _, w := range strings.Fields(strings.ToLower(title)) { + w = strings.TrimFunc(w, func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsDigit(r) }) + w = strings.Map(func(r rune) rune { + if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '-' { + return r + } + return -1 + }, w) + if w != "" { + words = append(words, w) + } + if len(words) == teamNameWords { + break + } + } + name := strings.Join(words, " ") + // A small model that answers with the instruction has named nothing. + if len(words) >= 2 && strings.Contains(strings.ToLower(teamNameAsk), name) { + return "" + } + return name +} diff --git a/internal/session/teamname_test.go b/internal/session/teamname_test.go new file mode 100644 index 0000000000..a207304326 --- /dev/null +++ b/internal/session/teamname_test.go @@ -0,0 +1,22 @@ +package session + +import "testing" + +// A TEAM NAME IS ONE TO THREE PLAIN WORDS, and an answer that is not a name is +// nothing, so the surface keeps the word it already offered. +func TestCleanTeamName(t *testing.T) { + for raw, want := range map[string]string{ + "harbor": "harbor", + "Parser Port": "parser port", + "\"release prep\".": "release prep", + "**TUI polish work**": "tui polish work", + "the relay audit and its follow-up": "the relay audit", + "port-b fixes": "port-b fixes", + "": "", + "Give these conversations one short shared name": "", + } { + if got := cleanTeamName(raw); got != want { + t.Errorf("cleanTeamName(%q) = %q, want %q", raw, got, want) + } + } +} diff --git a/internal/session/teampropose.go b/internal/session/teampropose.go new file mode 100644 index 0000000000..babfb4a84c --- /dev/null +++ b/internal/session/teampropose.go @@ -0,0 +1,314 @@ +package session + +import ( + "context" + "encoding/json" + "errors" + "strconv" + "strings" + + "github.com/Agent-Field/agentfield/sdk/go/ai" + "github.com/Agent-Field/codeaf/internal/roles" +) + +// Teams suggested for a person's conversations, asked once per press. +// +// The conversations view has an Organize button. The surface groups the +// conversations that share a project folder itself, which is free and exact, +// and asks here once for the groupings a folder cannot see: conversations about +// one topic spread over several folders, or one that belongs in a team the +// person already made. +// +// IT IS NAMETEAM'S ERRAND WITH A LONGER LIST. It goes through the same door +// ([Agent.callRoleChecked]) on the same role ([roles.RoleTitle]), so it lands on +// the cheap tier a person has configured for names, falls through one rung at +// most, and is billed against the model that answered, off every turn's clock. +// +// WHAT COMES BACK IS A PROPOSAL AND IS READ AS ONE. Every conversation and team +// is handed to the model under a short ref (c1, t1) and every ref in the answer +// is looked up again: one it was not given is dropped, a team left with too few +// members is dropped, a name is cleaned as a team name is, and nothing in the +// answer can remove a member or rename a team, because the answer has no field +// that could say so and a new team named like an existing one is read as +// additions to it. The surface shows what is left and applies only what the +// person ticks. + +// TeamProposalConversation is one conversation offered to the model: the key the +// surface knows it by, its title and its project folder. +type TeamProposalConversation struct { + Key string + Title string + Folder string +} + +// TeamProposalTeam is one team the person already has: its id, its name, and +// the keys of its members among the conversations offered. +type TeamProposalTeam struct { + ID string + Name string + Members []string +} + +// TeamProposalInput is everything one ask is about. +type TeamProposalInput struct { + Conversations []TeamProposalConversation + Teams []TeamProposalTeam +} + +// ProposedTeam is a new team the model suggests: its cleaned name, the keys of +// its members, and a few words on why. +type ProposedTeam struct { + Name string + Members []string + Reason string +} + +// ProposedAddition is conversations the model would add to a team that exists, +// by the team's id and the members' keys. +type ProposedAddition struct { + TeamID string + Members []string +} + +// TeamProposal is one validated answer. Model is the model that answered and +// PromptChars the size of what it was asked, so the surface can say about what +// the ask cost. +type TeamProposal struct { + New []ProposedTeam + Additions []ProposedAddition + Model string + PromptChars int +} + +// teamProposeSystem and teamProposeAsk are the instruction. The shape of the +// answer is spelled out in full, since a small model follows an example better +// than a description. +const ( + teamProposeSystem = "You sort a person's coding conversations into teams." + teamProposeAsk = `Suggest teams that group these conversations by shared project or topic, and existing teams that more conversations belong in. A conversation may be in several teams. Only use the refs above. Never rename or remove anything. Suggest nothing you are unsure of; empty lists are fine. +Answer with JSON only, in this shape: +{"new":[{"name":"one to three lowercase words","members":["c1","c2"],"reason":"a few words"}],"add":[{"team":"t1","members":["c3"]}]}` +) + +// The bounds on one ask: how much of each title is sent, how many +// conversations and teams, and how many member titles describe a team. A +// person with more than this many open is organized a screenful at a time. +const ( + teamProposeClip = 80 + teamProposeConvs = 60 + teamProposeTeams = 24 + teamProposeTeamSeen = 8 + teamProposeReason = 48 + teamProposeMaxNew = 8 +) + +// ProposeTeams asks the naming role, once, which teams the conversations in in +// could form and which existing teams more of them belong in. The caller bounds +// it with ctx. An answer that is not the JSON asked for is an error, never an +// empty proposal; an empty proposal is an answer. +func (a *Agent) ProposeTeams(ctx context.Context, in TeamProposalInput) (TeamProposal, error) { + ask, refs := teamProposePrompt(in) + if len(refs.convs) < 2 { + return TeamProposal{}, errors.New("fewer than two conversations to organize") + } + a.mu.Lock() + model, closed := a.model, a.closed + a.mu.Unlock() + if closed { + return TeamProposal{}, errors.New("the conversation is closed") + } + response, named, err := a.callRoleChecked(ctx, roles.RoleTitle, model, + []ai.Message{textMessage("system", teamProposeSystem), textMessage("user", ask)}, + func(response *ai.Response, named string) bool { + if _, ok := parseTeamProposal(response.Text(), in, refs); ok { + return true + } + a.addDetachedUsageAs(response, named, 1, auxRoleTitle) + return false + }) + if err != nil { + return TeamProposal{}, err + } + if response == nil { + return TeamProposal{}, errEmptyAnswer + } + a.addDetachedUsageAs(response, named, 1, auxRoleTitle) + out, ok := parseTeamProposal(response.Text(), in, refs) + if !ok { + return TeamProposal{}, errors.New("the answer was not a proposal") + } + out.Model = named + out.PromptChars = len(teamProposeSystem) + len(ask) + return out, nil +} + +// teamProposeRefs maps the refs one ask used back to what they stand for. +type teamProposeRefs struct { + convs map[string]string // c1 → conversation key + teams map[string]string // t1 → team id +} + +// teamProposePrompt is the user message for in, and the refs it used. +// +// Conversations: +// c1 | cpu profiling of the relay | folder: codeaf +// Existing teams: +// t1 | harbor | relay audit; footprint table +func teamProposePrompt(in TeamProposalInput) (string, teamProposeRefs) { + refs := teamProposeRefs{convs: map[string]string{}, teams: map[string]string{}} + title := map[string]string{} + var b strings.Builder + b.WriteString("Conversations:\n") + for _, c := range in.Conversations { + t := oneLine(c.Title) + if c.Key == "" || t == "" || title[c.Key] != "" || len(refs.convs) >= teamProposeConvs { + continue + } + ref := "c" + strconv.Itoa(len(refs.convs)+1) + refs.convs[ref] = c.Key + title[c.Key] = clip(t, teamProposeClip) + b.WriteString(ref + " | " + title[c.Key]) + if f := oneLine(c.Folder); f != "" { + b.WriteString(" | folder: " + clip(f, teamProposeClip)) + } + b.WriteString("\n") + } + if len(in.Teams) > 0 { + b.WriteString("Existing teams:\n") + } + for _, t := range in.Teams { + name := oneLine(t.Name) + if t.ID == "" || name == "" || len(refs.teams) >= teamProposeTeams { + continue + } + ref := "t" + strconv.Itoa(len(refs.teams)+1) + refs.teams[ref] = t.ID + var seen []string + for _, key := range t.Members { + if s := title[key]; s != "" && len(seen) < teamProposeTeamSeen { + seen = append(seen, s) + } + } + b.WriteString(ref + " | " + clip(name, teamProposeClip) + " | " + strings.Join(seen, "; ") + "\n") + } + b.WriteString("\n" + teamProposeAsk) + return b.String(), refs +} + +// teamProposeWire is the answer's shape as asked for. +type teamProposeWire struct { + New []struct { + Name string `json:"name"` + Members []string `json:"members"` + Reason string `json:"reason"` + } `json:"new"` + Add []struct { + Team string `json:"team"` + Members []string `json:"members"` + } `json:"add"` +} + +// parseTeamProposal reads raw as a proposal about in, whose refs are refs. The +// bool is false when raw holds no JSON object of the asked shape at all. +// +// Validation, in order: every member ref is looked up and one the ask did not +// give is dropped, and so is a second mention of the same one; a new team's +// name is cleaned as [cleanTeamName] cleans one and a team left without a name +// is dropped; a new team named like an existing team, compared without case, +// becomes additions to that team, because a name is not the model's to take; +// two new teams of one name are one; a new team of fewer than two members is no +// team; an addition's members already in the team are dropped, and an +// addition left empty is dropped. +func parseTeamProposal(raw string, in TeamProposalInput, refs teamProposeRefs) (TeamProposal, bool) { + body := strings.TrimSpace(raw) + open, end := strings.IndexByte(body, '{'), strings.LastIndexByte(body, '}') + if open < 0 || end <= open { + return TeamProposal{}, false + } + var wire teamProposeWire + if err := json.Unmarshal([]byte(body[open:end+1]), &wire); err != nil { + return TeamProposal{}, false + } + byID := map[string]TeamProposalTeam{} + byName := map[string]string{} + for _, t := range in.Teams { + byID[t.ID] = t + byName[strings.ToLower(strings.TrimSpace(t.Name))] = t.ID + } + keys := func(members []string) []string { + var out []string + seen := map[string]bool{} + for _, ref := range members { + key, ok := refs.convs[strings.ToLower(strings.TrimSpace(ref))] + if ok && !seen[key] { + seen[key] = true + out = append(out, key) + } + } + return out + } + var out TeamProposal + adds := map[string][]string{} + var addOrder []string + add := func(id string, members []string) { + t := byID[id] + for _, key := range members { + if teamProposeHas(t.Members, key) || teamProposeHas(adds[id], key) { + continue + } + if _, ok := adds[id]; !ok { + addOrder = append(addOrder, id) + } + adds[id] = append(adds[id], key) + } + } + newAt := map[string]int{} + for _, n := range wire.New { + name := cleanTeamName(n.Name) + members := keys(n.Members) + if name == "" || len(members) == 0 { + continue + } + if id, ok := byName[name]; ok { + add(id, members) + continue + } + if i, ok := newAt[name]; ok { + for _, key := range members { + if !teamProposeHas(out.New[i].Members, key) { + out.New[i].Members = append(out.New[i].Members, key) + } + } + continue + } + newAt[name] = len(out.New) + out.New = append(out.New, ProposedTeam{Name: name, Members: members, Reason: clip(oneLine(n.Reason), teamProposeReason)}) + } + kept := out.New[:0] + for _, t := range out.New { + if len(t.Members) >= 2 && len(kept) < teamProposeMaxNew { + kept = append(kept, t) + } + } + out.New = kept + for _, n := range wire.Add { + id, ok := refs.teams[strings.ToLower(strings.TrimSpace(n.Team))] + if !ok { + continue + } + add(id, keys(n.Members)) + } + for _, id := range addOrder { + out.Additions = append(out.Additions, ProposedAddition{TeamID: id, Members: adds[id]}) + } + return out, true +} + +func teamProposeHas(keys []string, key string) bool { + for _, k := range keys { + if k == key { + return true + } + } + return false +} diff --git a/internal/session/teampropose_test.go b/internal/session/teampropose_test.go new file mode 100644 index 0000000000..78e9619aa6 --- /dev/null +++ b/internal/session/teampropose_test.go @@ -0,0 +1,151 @@ +package session + +import ( + "context" + "reflect" + "strings" + "testing" + "time" + + "github.com/Agent-Field/agentfield/sdk/go/ai" +) + +// proposeInput is four conversations and one team, harbor, holding the third. +func proposeInput() TeamProposalInput { + return TeamProposalInput{ + Conversations: []TeamProposalConversation{ + {Key: "k-cpu", Title: "cpu profiling", Folder: "nvda"}, + {Key: "k-deep", Title: "nvda deep dive", Folder: "research"}, + {Key: "k-relay", Title: "relay audit", Folder: "codeaf"}, + {Key: "k-foot", Title: "footprint table", Folder: "codeaf"}, + }, + Teams: []TeamProposalTeam{{ID: "id-harbor", Name: "harbor", Members: []string{"k-relay"}}}, + } +} + +// THE ANSWER IS A PROPOSAL AND IS READ AS ONE: a ref the ask never gave is +// dropped, a ref said twice counts once, a team left with one member is no +// team, and an existing team's members are not offered to it again. +func TestProposeTeamsParsingDropsWhatTheAskNeverGave(t *testing.T) { + in := proposeInput() + _, refs := teamProposePrompt(in) + raw := "```json\n" + `{"new":[ + {"name":"NVDA Research!","members":["c1","c2","c2","c99"],"reason":"both about nvda"}, + {"name":"lonely","members":["c3","c77"]}, + {"name":"","members":["c1","c2"]} + ],"add":[ + {"team":"t1","members":["c3","c4","c4"]}, + {"team":"t9","members":["c1"]} + ]}` + "\n```" + got, ok := parseTeamProposal(raw, in, refs) + if !ok { + t.Fatal("a fenced JSON answer was not read") + } + want := TeamProposal{ + New: []ProposedTeam{{Name: "nvda research", Members: []string{"k-cpu", "k-deep"}, Reason: "both about nvda"}}, + Additions: []ProposedAddition{{TeamID: "id-harbor", Members: []string{"k-foot"}}}, + } + if !reflect.DeepEqual(got, want) { + t.Fatalf("got %+v\nwant %+v", got, want) + } +} + +// A NAME IS NOT THE MODEL'S TO TAKE. A new team named like an existing one is +// additions to it, and an addition that carries a name renames nothing: the +// answer has no field that could. +func TestProposeTeamsParsingIgnoresARenameAttempt(t *testing.T) { + in := proposeInput() + _, refs := teamProposePrompt(in) + raw := `{"new":[{"name":"Harbor","members":["c4","c1"]}], + "add":[{"team":"t1","name":"harbour renamed","members":[]}], + "rename":[{"team":"t1","name":"docks"}],"remove":[{"team":"t1","members":["c3"]}]}` + got, ok := parseTeamProposal(raw, in, refs) + if !ok { + t.Fatal("the answer was not read") + } + if len(got.New) != 0 { + t.Fatalf("a team named like harbor was proposed as new: %+v", got.New) + } + want := []ProposedAddition{{TeamID: "id-harbor", Members: []string{"k-foot", "k-cpu"}}} + if !reflect.DeepEqual(got.Additions, want) { + t.Fatalf("additions %+v, want %+v", got.Additions, want) + } +} + +// TWO NEW TEAMS OF ONE NAME ARE ONE, and prose around the object is ignored; +// an answer with no object at all is not a proposal. +func TestProposeTeamsParsingMergesDuplicatesAndRefusesProse(t *testing.T) { + in := proposeInput() + _, refs := teamProposePrompt(in) + raw := `Here you go: {"new":[{"name":"ops","members":["c1","c3"]},{"name":"OPS","members":["c4","c1"]}]} hope that helps` + got, ok := parseTeamProposal(raw, in, refs) + if !ok || len(got.New) != 1 || !reflect.DeepEqual(got.New[0].Members, []string{"k-cpu", "k-relay", "k-foot"}) { + t.Fatalf("got %+v ok %v", got, ok) + } + if _, ok := parseTeamProposal("I would group the relay ones together.", in, refs); ok { + t.Fatal("prose was read as a proposal") + } + if got, ok := parseTeamProposal(`{"new":[],"add":[]}`, in, refs); !ok || len(got.New)+len(got.Additions) != 0 { + t.Fatalf("an empty proposal is an answer: %+v %v", got, ok) + } +} + +// THE PROMPT CARRIES TITLES, FOLDERS AND TEAMS BY REF, one line each, and a +// title's newlines never break the list. +func TestProposeTeamsPromptShape(t *testing.T) { + in := proposeInput() + in.Conversations[0].Title = "cpu\nprofiling" + ask, refs := teamProposePrompt(in) + for _, want := range []string{"c1 | cpu profiling | folder: nvda\n", "c4 | footprint table | folder: codeaf\n", "t1 | harbor | relay audit\n", teamProposeAsk} { + if !strings.Contains(ask, want) { + t.Fatalf("the prompt lacks %q:\n%s", want, ask) + } + } + if refs.convs["c3"] != "k-relay" || refs.teams["t1"] != "id-harbor" { + t.Fatalf("refs %+v", refs) + } +} + +// ONE CALL ON THE CHEAP TIER, BILLED OFF THE TURN, and the model that answered +// is reported so the surface can price the ask. +func TestProposeTeamsAsksTheNamingRoleOnce(t *testing.T) { + client := &scriptedCompleter{steps: []step{func(context.Context, []ai.Message) (*ai.Response, error) { + return textResponse(`{"new":[{"name":"nvda","members":["c1","c2"],"reason":"one company"}],"add":[]}`), nil + }}} + agent, _ := newTestAgent(t, client, func(c *Config) { c.RolesSource = nameSettings() }) + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + got, err := agent.ProposeTeams(ctx, proposeInput()) + if err != nil { + t.Fatal(err) + } + if len(got.New) != 1 || got.New[0].Name != "nvda" || got.Model != "cheap/model" || got.PromptChars == 0 { + t.Fatalf("got %+v", got) + } + if client.requests() != 1 || client.model(0) != "cheap/model" { + t.Fatalf("%d requests, first on %q", client.requests(), client.model(0)) + } + if usage := agent.Usage(); usage.Calls != 1 || usage.Turns != 0 { + t.Fatalf("usage %+v, want one call charged to no turn", usage) + } +} + +// AN ANSWER THAT IS NOT A PROPOSAL IS AN ERROR after at most one fall-through, +// so the surface falls back to the folders. +func TestProposeTeamsRefusesProseAfterOneFallThrough(t *testing.T) { + answer := func(context.Context, []ai.Message) (*ai.Response, error) { + return textResponse("these look like two projects to me"), nil + } + steps := make([]step, roleFallThroughs+1) + for i := range steps { + steps[i] = answer + } + client := &scriptedCompleter{steps: steps} + agent, _ := newTestAgent(t, client, func(c *Config) { c.RolesSource = nameSettings() }) + if _, err := agent.ProposeTeams(context.Background(), proposeInput()); err == nil { + t.Fatal("prose was taken as a proposal") + } + if n := client.requests(); n > roleFallThroughs+1 { + t.Fatalf("%d requests, want at most %d", n, roleFallThroughs+1) + } +} diff --git a/internal/session/teamshape.go b/internal/session/teamshape.go new file mode 100644 index 0000000000..4b6e733a9a --- /dev/null +++ b/internal/session/teamshape.go @@ -0,0 +1,138 @@ +package session + +// WHAT A SURFACE DRAWS FOR A TEAM DELIVERY. +// +// A delivery ([Agent.teamBoundary]) is journaled as one of the session's own +// notes, so a replayed page gets it as an "aside" ([DisplayEntry]) and never as +// the person's words. A dim one-line aside is right for a task landing and wrong +// for a manager's brief, which is the whole assignment a new member was started +// with and deserves to be read as a quoted card. So the aside carries the lines +// it delivered, taken apart here, next to the composer that put them together +// ([teamLine], [teamNewsGroup]), which is the only code that knows the shape. +// A surface draws [DisplayEntry.Team] when it is there and the aside's text +// when it is not. + +import ( + "strconv" + "strings" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// TeamLine is one line of team traffic as a conversation was handed it. +type TeamLine struct { + // Team is the team's name as the delivery named it. + Team string + // From is "manager", a member's handle (no @), "you" or "system". + From string + // To is where the line was aimed: "room", "everyone", "manager" or a + // member's handle, and "" for the conversation reading it. + To string + // Kind is [teams.KindNote], [teams.KindDirective], or [teams.KindStart] for + // the brief a manager started this conversation with. + Kind string + // Text is the line's words, whole lines kept. + Text string + // Thread is the line's own entry id when the delivery numbered it ("#42", + // which a member is told so its reply can name it), "" when it did not. + Thread string +} + +// teamNewsLead opens every group of a delivery ([teamNewsGroup]). +const teamNewsLead = "Team traffic in " + +// teamNewsLines is a delivery's lines, nil for text that is not one. A note +// that woke a turn opens with a sentence of its own and carries the delivery +// under it (team_wakewatch.go), so a delivery is found at the start of any +// line, not only the first. +func teamNewsLines(text string) []TeamLine { + if !strings.HasPrefix(text, teamNewsLead) && !strings.Contains(text, "\n"+teamNewsLead) { + return nil + } + var ( + out []TeamLine + team string + open bool + ) + for _, line := range strings.Split(text, "\n") { + switch { + case strings.HasPrefix(line, teamNewsLead): + quoted, err := strconv.QuotedPrefix(strings.TrimPrefix(line, teamNewsLead)) + if err != nil { + open = false + continue + } + team, _ = strconv.Unquote(quoted) + open = true + case !open || line == "": + case strings.HasPrefix(line, "("): + // The group's closing sentence, the authority law. + open = false + case strings.HasPrefix(line, " ") && len(out) > 0: + out[len(out)-1].Text += "\n" + strings.TrimPrefix(line, " ") + default: + if parsed, ok := teamLineParts(line); ok { + parsed.Team = team + out = append(out, parsed) + } + } + } + return out +} + +// teamLineParts takes one delivered line apart: who, where, what kind, and +// the words. The head before the first ": " holds no colon, because a handle +// is letters and digits. +func teamLineParts(line string) (TeamLine, bool) { + head, text, ok := strings.Cut(line, ": ") + if !ok { + return TeamLine{}, false + } + parsed := TeamLine{Kind: teams.KindNote, Text: text} + switch { + case strings.HasPrefix(head, teamBriefWord): + parsed.From, parsed.Kind, head = teams.FromManager, teams.KindStart, strings.TrimPrefix(head, teamBriefWord) + case strings.HasPrefix(head, "◆ directive from manager"): + parsed.From, parsed.Kind, head = teams.FromManager, teams.KindDirective, strings.TrimPrefix(head, "◆ directive from manager") + case strings.HasPrefix(head, "◆ from manager"): + parsed.From, head = teams.FromManager, strings.TrimPrefix(head, "◆ from manager") + case strings.HasPrefix(head, "from the person"): + parsed.From, head = teams.FromYou, strings.TrimPrefix(head, "from the person") + case strings.HasPrefix(head, "from codeaf"): + parsed.From, head = teams.FromSystem, strings.TrimPrefix(head, "from codeaf") + case strings.HasPrefix(head, "from @"): + rest := strings.TrimPrefix(head, "from @") + handle, after, _ := strings.Cut(rest, " ") + if handle == "" { + return TeamLine{}, false + } + parsed.From, head = handle, "" + if after != "" { + head = " " + after + } + default: + return TeamLine{}, false + } + // A line delivered to a member ends its head with the line's number. + if at := strings.LastIndex(head, " #"); at >= 0 { + if id, ok := teams.ThreadID(head[at+1:]); ok { + parsed.Thread, head = id, head[:at] + } + } + switch head { + case "": + case " to the room": + parsed.To = teams.ToRoom + case " to everyone": + parsed.To = teams.ToEveryone + case " to the manager": + parsed.To = teams.ToManager + default: + handle, ok := strings.CutPrefix(head, " to @") + if !ok || handle == "" || strings.Contains(handle, " ") { + return TeamLine{}, false + } + parsed.To = handle + } + return parsed, true +} diff --git a/internal/session/teamspend_test.go b/internal/session/teamspend_test.go new file mode 100644 index 0000000000..b1a2cfc560 --- /dev/null +++ b/internal/session/teamspend_test.go @@ -0,0 +1,34 @@ +package session + +import ( + "encoding/json" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/teams" +) + +// TestTeamSpendReadsTheSessionsLedger pins the one join internal/teams makes +// against this package without importing it (it cannot; this package imports +// it): a team's spend is read from the file [UsageLedgerPath] names, by the +// JSON names [UsageLine] writes. Two spellings of one path would be two +// ledgers, and a renamed field would read every team's day as $0. +func TestTeamSpendReadsTheSessionsLedger(t *testing.T) { + if teams.UsageLedgerPath() != UsageLedgerPath() { + t.Fatalf("teams reads %s, the ledger is %s", teams.UsageLedgerPath(), UsageLedgerPath()) + } + raw, err := json.Marshal(UsageLine{At: time.Now(), Day: "2026-09-24", Calls: 1, USD: 1.5, + Session: "0123456789abcdef", Root: "fedcba9876543210"}) + if err != nil { + t.Fatal(err) + } + var fields map[string]json.RawMessage + if err := json.Unmarshal(raw, &fields); err != nil { + t.Fatal(err) + } + for _, name := range []string{"at", "day", "calls", "usd", "session", "root"} { + if _, ok := fields[name]; !ok { + t.Errorf("a usage line has no %q field, which internal/teams' spend.go reads", name) + } + } +} diff --git a/internal/session/title.go b/internal/session/title.go index d278b07d7b..f4b74bf1fb 100644 --- a/internal/session/title.go +++ b/internal/session/title.go @@ -363,6 +363,8 @@ func (a *Agent) publishTitle(ctx context.Context, title conversationTitle) { if !a.setTitleIfUnnamed(title.full) { return } + // The title the handle is read off exists now (handlepick.go). + a.chooseTeamHandlesLater(title.full, nil) event := Event{Kind: EventTitleChanged, Text: title.full} a.mu.Lock() hub := a.hub diff --git a/internal/session/tools_ask.go b/internal/session/tools_ask.go index 3ba6929669..4eaee4b8ef 100644 --- a/internal/session/tools_ask.go +++ b/internal/session/tools_ask.go @@ -198,6 +198,13 @@ func (a *Agent) executeAsk(ctx context.Context, raw json.RawMessage) (string, bo if err := q.Check(a.Decisions()); err != nil { return askRefusedLead + err.Error(), false, nil } + // A TEAM MEMBER'S CLARIFYING QUESTION GOES TO ITS MANAGER FIRST, as a + // decision packet, when its team says questions go up (team_questions.go). + // A conversation in no team pays a stat of the teams file here, and only + // when it asks. + if said, up := a.askUp(q); up { + return said, false, nil + } if !a.config.Interactive && q.Policy.Kind == PolicyAsk { if q.Pick == nil { return "your call: " + strings.TrimSpace(q.Head) + " (nobody to ask)", false, nil diff --git a/internal/session/tools_standing.go b/internal/session/tools_standing.go index f7466060cc..fc91dfe966 100644 --- a/internal/session/tools_standing.go +++ b/internal/session/tools_standing.go @@ -495,8 +495,10 @@ func (a *Agent) standPropose(ctx context.Context, parsed standArguments) (string switch { case answer.Once: // Nothing is created and nothing is scheduled. The person wanted the - // action, not the arrangement, so the model does it here. - return "do it once, now, as an ordinary turn — nothing stands. Nothing was set up.", false, nil + // action, not the arrangement. The result says the next step in so + // many words, because "nothing was set up" sent a model off to read + // this program's source looking for a reminder that was never missing. + return "Do it now as an ordinary step and report what happened. The person chose not to repeat it. Do not set it up again unless they ask. Do not investigate codeaf.", false, nil case !answer.Approved: if correction := strings.TrimSpace(answer.Change); correction != "" { // AND THE CORRECTION MAY BE ABOUT ANY OF IT. The card's one change @@ -1518,7 +1520,7 @@ func (a *Agent) standingAsk(id uint64, notice StandingNotice) Question { Ask: AskChoice, Form: FormCard, Asker: Asker{Kind: AskerModel}, - Head: StandingAskLead + strings.TrimSpace(notice.Item.Words), + Head: StandingHead(notice.Item), Reason: StandingAskReason, Subject: SubjectRef{Kind: SubjectOrder, ID: id, Name: strings.TrimSpace(notice.Item.Words)}, Options: StandingOptions(notice.Item), @@ -1533,18 +1535,14 @@ func (a *Agent) standingAsk(id uint64, notice StandingNotice) Question { // at all. Blocking: Blocking{Turn: true}, Scope: []AnswerScope{ScopeOnce, ScopeAlways}, + // THE CORRECTION IS A SENTENCE, not a key that resolves. The button's + // own hint is what the box is for. + Input: InputShape{Kind: InputText, Prompt: StandingChangeHint(notice.Item)}, } } -// StandingAskLead opens the sentence a standing card asks with, and the -// PERSON'S OWN WORDS close it ([standing.Item.Words]) — the anchor every -// surface leads this item with. It is a constant so the card, the presence file -// and the question object cannot become three accounts of one item. -// -// IT IS EXPORTED BECAUSE THE SURFACE BUILDS THE SAME QUESTION, for -// [TaskProposalLead]'s reason exactly: a window has the notice before the -// questions lane reaches it and raises the question from that, so two builders -// that drifted would put two questions on screen about one proposal. +// StandingAskLead is the old opening, kept so a reader of an older line can +// find what a card used to say. New cards open with [StandingHead]. const StandingAskLead = "wants to keep an eye on: " // StandingAskReason is why the card is up, in the one sentence that is true of diff --git a/internal/session/tools_team.go b/internal/session/tools_team.go new file mode 100644 index 0000000000..ccac96ffb3 --- /dev/null +++ b/internal/session/tools_team.go @@ -0,0 +1,825 @@ +package session + +// The team verbs: a manager running its team, and a member speaking in it. +// +// A team's manager is an ordinary conversation with every ordinary tool under +// the ordinary approval rules (docs/design/conversations-and-teams/DESIGN.md, +// section 5). What makes it a manager is these five verbs and the digest its +// turns carry (team.go); what makes a member able to answer is the sixth. +// +// THEY ARE ONE GROUP, AND THE GROUP IS ARMED, NOT SHELVED. A manager needs its +// verbs on the turn the person asks it to hand something out, so a round trip +// through `load_capability` would be a round trip on every such turn; and a +// conversation that is in no team must not pay a single byte of schema for them. +// So they are built by nobody at construction ([Agent.belt] never sees them) and +// go onto the belt at the boundary that first finds this conversation in a team +// ([Agent.teamBoundary]), through the arming door everything that grows a belt +// goes through. The fixed prefix is unchanged for everybody else, which is what +// prefixbudget_test.go holds. +// +// SIX TOOLS AND NOT ONE WITH ACTIONS, for the reason the settings pair is two: +// THE APPROVAL GATE KEYS ON THE TOOL NAME. Reading a member's page and starting a +// new conversation that spends money are two different acts, and a person must +// be able to allow one and be asked about the other. So the reads, the messages +// and the stop sit on the builtin floor (cmd/codeaf's v3BuiltinApprovals) and +// `team_start` is left to the blanket mode, which asks. +// +// THE CHANNEL IS THE TRAFFIC LOG AND NOTHING ELSE. Every write here is one +// [teams.AppendTraffic]: a message is a note or a directive, a stop is a +// [teams.KindStop] entry the interface performs as the person's own Stop, and a +// start is a [teams.KindStart] entry the interface performs by opening the new +// conversation, and the new conversation reads its brief off that same entry +// (teamevent.go's [teamBriefLine]), marked as the manager's and never the person's. None of these verbs reaches into another +// conversation directly, which is what lets the other conversation be in +// another window, on another build, or closed. +// +// A MANAGER MAY NOT ANSWER A MEMBER'S PERMISSION PROMPT, and there is no verb +// here that could. That is the person's safety gate; the brief says so. + +import ( + "context" + "encoding/json" + "fmt" + "slices" + "strconv" + "strings" + "time" + + "github.com/Agent-Field/codeaf/internal/exec/bare" + "github.com/Agent-Field/codeaf/internal/teams" +) + +const ( + teamStatusToolName = "team_status" + teamReadToolName = "team_read" + teamSendToolName = "team_send" + teamStopToolName = "team_stop" + teamStartToolName = "team_start" + teamPostToolName = "team_post" +) + +// teamGroup is the group's word, and teamToolNames is the whole group, manager +// verbs first. They are listed once so the gates that ask "is this a team verb" +// (the approval floor, the family table, the manual gate) read one list. +const teamGroup = "team" + +var teamToolNames = []string{ + teamStatusToolName, teamReadToolName, teamSendToolName, teamStopToolName, teamStartToolName, + teamDecideToolName, teamEscalateToolName, teamCloseReportToolName, + teamPostToolName, teamRaiseToolName, +} + +// The optional `team` argument every verb takes. It is needed only by a +// conversation in more than one team of that kind, and a call that leaves it +// out there is answered with the names to choose from. +const teamArgSchema = `"team":{"type":"string","description":"Team name or id. Needed only when you are in more than one."}` + +const teamStatusDescription = "Your team as it stands: every member's handle, title and state (running, asking, idle, failed), " + + "the question a member is waiting on, the files each has touched, and the recent traffic. States are read from each member's saved conversation. " + + "Use it before handing out work and when the person asks how the team is doing." + +const teamStatusSchema = `{"type":"object","properties":{` + teamArgSchema + `},"additionalProperties":false}` + +const teamReadDescription = "Read the end of one member's conversation: the last messages the person, the member and its tools exchanged, bounded. " + + "Use it to check a member's progress or what it reported. It is a read; it changes nothing and the member is not told." + +var teamReadSchema = `{"type":"object","properties":{"handle":{"type":"string","description":"The member's handle, like web or @web."},` + + `"messages":{"type":"integer","description":"How many of the last messages. Default ` + strconv.Itoa(teamReadDefault) + `, maximum ` + strconv.Itoa(teamReadMax) + `."},` + + teamArgSchema + `},"required":["handle"],"additionalProperties":false}` + +const teamSendDescription = "Send a message to one member, to several (one message with every handle in to), or to everyone in the team. It arrives at the start of the member's next step, marked as from the manager, never as the person. " + + "kind note is information and waits for the member's next turn; kind directive is an instruction the member should follow unless the person said otherwise in its own conversation, and it starts an idle member's turn. " + + "A member busy in a long tool call reads it when that returns; use team_stop to end its turn first." + +const teamSendSchema = `{"type":"object","properties":{"to":{"type":"string","description":"A member's handle, several separated by spaces, or everyone."},` + + `"text":{"type":"string","description":"The message."},` + + `"kind":{"type":"string","enum":["note","directive"],"description":"Default note."},` + + teamArgSchema + `},"required":["to","text"],"additionalProperties":false}` + +const teamStopDescription = "Stop one member's current turn, the way the person's own Stop does: the turn ends, nothing is deleted, and its background tasks and jobs keep running. " + + "It is logged in the team's traffic. Use it for a member going the wrong way, then team_send what to do instead." + +const teamStopSchema = `{"type":"object","properties":{"handle":{"type":"string","description":"The member's handle."},` + + `"reason":{"type":"string","description":"One line, shown in the traffic."},` + + teamArgSchema + `},"required":["handle"],"additionalProperties":false}` + +const teamStartDescription = "Start a new member conversation in this team with a handle and a brief. The person is asked first. " + + "The new conversation opens in the team's folder and its first message is your brief, marked as from the manager. " + + "Write the brief as a complete assignment: the goal, what done looks like, and which files are its to touch. " + + "kind team starts a sub-team instead: a new team under yours (name) whose manager is the new conversation, with its share of your pool; members you name move into it. " + + "Its manager reports to you and takes your orders; its members are its manager's to direct, not yours." + +const teamStartSchema = `{"type":"object","properties":{"handle":{"type":"string","description":"2 to 12 lowercase letters or digits, unique in the team. For kind team, the new team's manager."},` + + `"brief":{"type":"string","description":"The whole assignment, as its first message."},` + + `"kind":{"type":"string","enum":["member","team"],"description":"Default member."},` + + `"name":{"type":"string","description":"kind team: the new team's name."},` + + `"members":{"type":"array","items":{"type":"string"},"description":"kind team: handles of your members to move into it."},` + + teamArgSchema + `},"required":["handle","brief"],"additionalProperties":false}` + +const teamPostDescription = "Post a message in your team: to the room (every member and the manager), to one member by handle, or to the manager. " + + "It arrives at the start of their next step, marked as from you; a post to the manager starts its turn if it is idle. Use it to report progress or a finding, to ask a teammate, or to say you are blocked. " + + "A post to the manager answers the last message the manager sent you; to answer another, give its number as thread." + +const teamPostSchema = `{"type":"object","properties":{"to":{"type":"string","description":"room, manager, or a member's handle."},` + + `"text":{"type":"string","description":"The message."},` + + `"thread":{"type":"string","description":"The #number of the team message this answers, like #42. Optional."},` + + teamArgSchema + `},"required":["to","text"],"additionalProperties":false}` + +// team_read's bounds. +const ( + teamReadDefault = 12 + teamReadMax = 40 + // teamReadBytes is the most a read hands back, whatever it was asked for. + teamReadBytes = 12 << 10 + // teamReadLine is the most of any one message a read shows. + teamReadLine = 1200 +) + +// teamStatusBudget is the character budget of a status answer: roomier than +// the digest a turn carries, because it was asked for. +const teamStatusBudget = 6000 + +// managerTools are the manager's five verbs. +func (a *Agent) managerTools() []bare.Tool { + return []bare.Tool{ + {Name: teamStatusToolName, Description: teamStatusDescription, Schema: json.RawMessage(teamStatusSchema), Execute: a.teamStatusTool}, + {Name: teamReadToolName, Description: teamReadDescription, Schema: json.RawMessage(teamReadSchema), Execute: a.teamReadTool}, + {Name: teamSendToolName, Description: teamSendDescription, Schema: json.RawMessage(teamSendSchema), Execute: a.teamSendTool}, + {Name: teamStopToolName, Description: teamStopDescription, Schema: json.RawMessage(teamStopSchema), Execute: a.teamStopTool}, + {Name: teamStartToolName, Description: teamStartDescription, Schema: json.RawMessage(teamStartSchema), Execute: a.teamStartTool}, + } +} + +// memberTools is a member's one verb. +func (a *Agent) memberTools() []bare.Tool { + return []bare.Tool{ + {Name: teamPostToolName, Description: teamPostDescription, Schema: json.RawMessage(teamPostSchema), Execute: a.teamPostTool}, + } +} + +// teamTarget is the team a verb acts on, read fresh from the file, and the +// refusal to hand the model when there is none. +// +// IT IS ASKED ON EVERY CALL, never remembered from the boundary that armed the +// verb: a conversation removed as manager a minute ago keeps the verb on its +// belt (team.go states why), and this is where it is told it no longer runs +// that team. +func (a *Agent) teamTarget(want string, manager bool) (teams.Team, teamRole, string) { + profile := a.config.teamProfile() + if profile == "" { + return teams.Team{}, teamRole{}, "This conversation is not in a team." + } + file, err := teams.Load(profile) + if err != nil { + return teams.Team{}, teamRole{}, "The teams file could not be read: " + err.Error() + } + a.team.mu.Lock() + keys := append([]string(nil), a.teamKeysLocked()...) + a.team.mu.Unlock() + defaults := a.teamDefaults(profile) + var fits []teamRole + for _, role := range rolesFor(file, keys, defaults) { + if manager && role.manager || !manager && !role.manager && role.managed { + fits = append(fits, role) + } + } + if len(fits) == 0 { + if manager { + return teams.Team{}, teamRole{}, "This conversation is not the manager of any team now, so it cannot run one. Nothing was done." + } + return teams.Team{}, teamRole{}, "This conversation is not a member of a team with a manager now. Nothing was done." + } + want = strings.TrimSpace(want) + if want != "" { + var chosen []teamRole + for _, role := range fits { + if role.id == want || strings.EqualFold(role.name, want) { + chosen = append(chosen, role) + } + } + if len(chosen) != 1 { + return teams.Team{}, teamRole{}, fmt.Sprintf("There is no one team called %q here. Yours are: %s.", want, strings.Join(sortedTeamNames(fits), ", ")) + } + fits = chosen + } + if len(fits) > 1 { + return teams.Team{}, teamRole{}, "You are in more than one team: " + strings.Join(sortedTeamNames(fits), ", ") + ". Say which with team." + } + team, _ := file.Team(fits[0].id) + if manager { + team = managedView(file, team) + } + return team, fits[0], "" +} + +// teamMemberByHandle is the member a handle names, forgiving a leading @. +func teamMemberByHandle(team teams.Team, handle string) (teams.Member, bool) { + return team.ByHandle(strings.TrimPrefix(strings.ToLower(strings.TrimSpace(handle)), "@")) +} + +// teamHandles is the team's handles, for a refusal that lists them. +func teamHandles(team teams.Team, except string) string { + var handles []string + for _, member := range team.Members { + if member.Handle != "" && member.Key != except { + handles = append(handles, "@"+member.Handle) + } + } + if len(handles) == 0 { + return "none yet" + } + return strings.Join(handles, ", ") +} + +// ── team_status ───────────────────────────────────────────────────────────── + +func (a *Agent) teamStatusTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + team, _, refusal := a.teamTarget(parsed.Team, true) + if refusal != "" { + return refusal, true, nil + } + profile := a.config.teamProfile() + a.team.mu.Lock() + keys := append([]string(nil), a.teamKeysLocked()...) + a.team.mu.Unlock() + log, _ := teams.ReadTraffic(profile, team.ID, "", teamStateLook) + file, _, _, _ := a.teamSnapshot(profile) + states := memberStates(team, keys, time.Now(), log, &a.team.journals) + markShared(file, team, states) + return teams.Digest(team, states, recentOf(log), teamStatusBudget) + waitingOn(profile, team), false, nil +} + +// markShared marks each member of team that reports to another team's +// manager with that team's name ([teams.MemberState].ReportsTo), so the +// digest draws it `reports to dock` and, while it runs, `busy for dock`. +func markShared(file *teams.File, team teams.Team, states map[string]teams.MemberState) { + if file == nil { + return + } + for _, member := range team.Members { + if member.Key == team.Manager { + continue + } + home, ok := file.Home(member.Key) + if !ok || home.Team == team.ID { + continue + } + at, ok := file.Team(home.Team) + if !ok { + continue + } + state := states[member.Key] + state.ReportsTo = at.Name + states[member.Key] = state + } +} + +// waitingOn is the packets waiting on team's manager, one line each, "" for +// none: what a status answer adds after the digest so a manager that missed a +// delivery still finds what it owes. +func waitingOn(profile string, team teams.Team) string { + waiting, _, err := teams.OpenPackets(profile, team.ID) + if err != nil || len(waiting) == 0 { + return "" + } + var b strings.Builder + b.WriteString("\nWaiting on you (team_decide or team_escalate):\n") + for _, p := range waiting { + fmt.Fprintf(&b, "- %s %s from %s: %s\n", p.ID, p.Kind, raiserName(p.RaisedBy), cutRunesTeam(oneLineTeam(p.Question), 200)) + } + return b.String() +} + +// ── team_read ─────────────────────────────────────────────────────────────── + +func (a *Agent) teamReadTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Handle string `json:"handle"` + Messages int `json:"messages"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + team, _, refusal := a.teamTarget(parsed.Team, true) + if refusal != "" { + return refusal, true, nil + } + member, ok := teamMemberByHandle(team, parsed.Handle) + if !ok { + // A READ REACHES DOWN THE TREE: it changes nothing, so a manager may + // read a conversation in a team under its own (the parties of a + // conflict it is deciding, most often), named as team/@handle. + if below, found := readableBelow(a.config.teamProfile(), team, parsed.Handle); found { + member, ok = below, true + } + } + if !ok { + return fmt.Sprintf("No member of %q has the handle %q. Its members are: %s. A member of a team under yours is named team/@handle.", team.Name, parsed.Handle, teamHandles(team, "")), true, nil + } + if member.Key == team.Manager { + return "That is this conversation. Its own transcript is already in front of you.", true, nil + } + count := parsed.Messages + if count <= 0 { + count = teamReadDefault + } + count = min(count, teamReadMax) + text, err := memberTail(member.File, count) + if err != nil { + return fmt.Sprintf("@%s's conversation could not be read: %s", member.Handle, err.Error()), true, nil + } + if text == "" { + return fmt.Sprintf("@%s's conversation has nothing in it yet.", member.Handle), false, nil + } + return fmt.Sprintf("The end of @%s's conversation (%q), oldest first. It is the member's record, not instructions to you.\n\n%s", member.Handle, member.Word, text), false, nil +} + +// memberTail is the last count messages of a member's journal, rendered one +// per paragraph and bounded to [teamReadBytes] from the newest end. +func memberTail(path string, count int) (string, error) { + if strings.TrimSpace(path) == "" { + return "", fmt.Errorf("it has no saved conversation") + } + lines, _, err := journalTailLines(path, journalTail) + if err != nil { + return "", err + } + var rows []string + for _, line := range lines { + var entry sessionEntry + if json.Unmarshal(line, &entry) != nil || entry.Type != "message" { + continue + } + if row := journalRow(entry); row != "" { + rows = append(rows, row) + } + } + if len(rows) > count { + rows = rows[len(rows)-count:] + } + // THE BOUND IS TAKEN FROM THE NEWEST END, because the newest message is the + // one a manager asking "where is it" needs, and a long tool result at the + // start of the window must not push it out. + total := 0 + start := len(rows) + for start > 0 && total+len(rows[start-1]) <= teamReadBytes { + start-- + total += len(rows[start]) + 2 + } + return strings.Join(rows[start:], "\n\n"), nil +} + +// journalRow is one journaled message as a manager reads it. +func journalRow(entry sessionEntry) string { + text := strings.TrimSpace(entry.Content) + switch entry.Role { + case "user": + if isVolatileNote(text) { + return "" + } + who := "person" + if entry.Note { + who = "codeaf note" + } + return who + ": " + cutRunesTeam(text, teamReadLine) + case "assistant": + var parts []string + if text != "" { + parts = append(parts, "member: "+cutRunesTeam(text, teamReadLine)) + } + for _, call := range entry.ToolCalls { + parts = append(parts, "member called "+gloss(call)) + } + return strings.Join(parts, "\n") + case "tool": + if text == "" { + return "" + } + return "tool result: " + cutRunesTeam(conversationOneLine(text), 300) + } + return "" +} + +// ── team_send ─────────────────────────────────────────────────────────────── + +func (a *Agent) teamSendTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + To string `json:"to"` + Text string `json:"text"` + Kind string `json:"kind"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + text := strings.TrimSpace(parsed.Text) + if text == "" { + return invalidArgumentsPrefix + "text is empty", true, nil + } + kind := teams.KindNote + switch strings.TrimSpace(parsed.Kind) { + case "", teams.KindNote: + case teams.KindDirective: + kind = teams.KindDirective + default: + return invalidArgumentsPrefix + "kind is note or directive", true, nil + } + team, role, refusal := a.teamTarget(parsed.Team, true) + if refusal != "" { + return refusal, true, nil + } + file, _, _, _ := a.teamSnapshot(a.config.teamProfile()) + entry, refusal := teamSendAddress(file, team, parsed.To, kind) + if refusal != "" { + return refusal, true, nil + } + // A DIRECTIVE TO EVERYONE REACHES THE ONES WHO REPORT HERE. A shared + // member is left out and named, and the rest are sent it as one message to + // several, so no line in the log says `everyone` about a directive some + // were not sent, and the replies still thread under one number. + var shared []string + if entry.To == teams.ToEveryone && kind == teams.KindDirective { + var own []teams.Member + own, shared = splitByHome(file, team) + if len(shared) > 0 { + if len(own) == 0 { + return fmt.Sprintf("Every member of %q reports to another team's manager (%s), so none may be directed by you. Send them a note instead.", team.Name, strings.Join(shared, ", ")), true, nil + } + entry = teamEntryFor(own) + } + } + entry.Kind, entry.From, entry.Text = kind, teams.FromManager, text + id, err := teams.AppendTrafficID(a.config.teamProfile(), team.ID, entry) + if err != nil { + return "The message could not be written to the team's traffic: " + err.Error(), true, nil + } + // THE ANSWER CARRIES THE MESSAGE'S NUMBER. The members are told it too, and + // their replies name it, which is what threads them under it on the rail + // and under this call in the manager's own conversation. + who := "@" + strings.Join(entry.Recipients(), ", @") + " (" + teams.ThreadNumber(id) + ")" + if entry.To == teams.ToEveryone { + who = "everyone in " + strconv.Quote(team.Name) + " (" + teams.ThreadNumber(id) + ")" + } + if kind == teams.KindDirective { + // A DIRECTIVE WAKES, and a member nobody has open is opened so it can + // (team_wakewatch.go). The answer says what will happen and no more: + // whether the wake ran is the Traffic's to say, where the person reads it. + a.teamRouse(a.config.teamProfile(), team, role.wakes, teamSendTargets(team, entry), id) + if len(shared) > 0 { + return fmt.Sprintf("Sent a directive to %d member(s) of %q who report to you: %s. Not sent to %s: they report to another team's manager; send them a note.", + len(entry.Recipients()), team.Name, who, strings.Join(shared, ", ")), false, nil + } + if !role.wakes { + return fmt.Sprintf("Sent a directive to %s. This team's auto-wake is off, so a member that is idle reads it when its conversation next runs; a busy one at its next step.", who), false, nil + } + return fmt.Sprintf("Sent a directive to %s. A member that is idle starts a turn on it now, and a busy one reads it at its next step. "+ + "Their replies and their finishing wake you when they arrive, so there is no need to wait or poll; the traffic shows each wake.", who), false, nil + } + return fmt.Sprintf("Sent a note to %s. It arrives at the start of their next step; a note wakes nobody, so a member that is idle reads it when its conversation next runs.", who), false, nil +} + +// teamSendAddress is where a manager's `to` sends a message: everyone, one +// member, or several named members as ONE entry (internal/teams' thread.go), +// and the refusal to hand back when a handle names nobody, names a member of +// a team below (whose manager is the one to ask), or names a link a directive +// may not reach. +func teamSendAddress(file *teams.File, team teams.Team, to, kind string) (teams.Entry, string) { + words := strings.FieldsFunc(strings.ToLower(to), func(r rune) bool { return r == ' ' || r == ',' || r == ';' }) + var members []teams.Member + for _, word := range words { + word = strings.TrimPrefix(word, "@") + if word == "" { + continue + } + if word == teams.ToEveryone { + return teams.Entry{To: teams.ToEveryone}, "" + } + member, ok := teamMemberByHandle(team, word) + if !ok || member.Key == team.Manager { + if pointer := subTeamPointer(file, team, word, "a message"); pointer != "" && !ok { + return teams.Entry{}, pointer + } + return teams.Entry{}, fmt.Sprintf("No member of %q has the handle %q. Send to one or more of %s, or to everyone.", team.Name, word, teamHandles(team, team.Manager)) + } + if where := reportsElsewhere(file, team, member); where != "" && kind == teams.KindDirective { + return teams.Entry{}, linkRefusal(member, where, "a directive") + } + if !slices.ContainsFunc(members, func(m teams.Member) bool { return m.Handle == member.Handle }) { + members = append(members, member) + } + } + if len(members) == 0 { + return teams.Entry{}, fmt.Sprintf("Say who the message is for: one or more of %s, or everyone.", teamHandles(team, team.Manager)) + } + return teamEntryFor(members), "" +} + +// teamEntryFor addresses an entry to members: the one by handle, or several +// as one entry that lists them. +func teamEntryFor(members []teams.Member) teams.Entry { + if len(members) == 1 { + return teams.Entry{To: members[0].Handle, Member: members[0].Key} + } + handles := make([]string, 0, len(members)) + for _, member := range members { + handles = append(handles, member.Handle) + } + return teams.Entry{To: teams.ToSeveral, Handles: handles} +} + +// reportsElsewhere is the name of the team member reports to when that is +// not team, "" when it reports here (or to nobody). +func reportsElsewhere(file *teams.File, team teams.Team, member teams.Member) string { + if file == nil { + return "" + } + home, ok := file.Home(member.Key) + if !ok || home.Team == team.ID { + return "" + } + if at, ok := file.Team(home.Team); ok { + return at.Name + } + return "" +} + +// splitByHome is team's members but its manager: those who report here, and +// the handles of those who report elsewhere. +func splitByHome(file *teams.File, team teams.Team) ([]teams.Member, []string) { + var own []teams.Member + var shared []string + for _, member := range team.Members { + if member.Key == team.Manager { + continue + } + if reportsElsewhere(file, team, member) != "" { + shared = append(shared, "@"+member.Handle) + continue + } + own = append(own, member) + } + return own, shared +} + +// linkRefusal is the honest sentence a link's directive or stop is refused +// with: whose the member is, and what the manager may still do. +func linkRefusal(member teams.Member, where, what string) string { + return fmt.Sprintf("@%s reports to the manager of %q, not to you: here you are a link, who may read it (team_read) and send it a note, but not %s. "+ + "Nothing was sent. Send it a note (kind note), or raise it with its manager.", member.Handle, where, what) +} + +// teamSendTargets is who a manager's message is addressed to: the members it +// names, or every member but the manager. +func teamSendTargets(team teams.Team, entry teams.Entry) []teams.Member { + var out []teams.Member + for _, member := range team.Members { + if member.Key != team.Manager && entry.Addressed(member.Handle) { + out = append(out, member) + } + } + return out +} + +// ── team_stop ─────────────────────────────────────────────────────────────── + +func (a *Agent) teamStopTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Handle string `json:"handle"` + Reason string `json:"reason"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + team, _, refusal := a.teamTarget(parsed.Team, true) + if refusal != "" { + return refusal, true, nil + } + file, _, _, _ := a.teamSnapshot(a.config.teamProfile()) + member, ok := teamMemberByHandle(team, parsed.Handle) + if !ok || member.Key == team.Manager { + if pointer := subTeamPointer(file, team, parsed.Handle, "a stop"); pointer != "" && !ok { + return pointer, true, nil + } + return fmt.Sprintf("No member of %q has the handle %q. Its members are: %s.", team.Name, parsed.Handle, teamHandles(team, team.Manager)), true, nil + } + if where := reportsElsewhere(file, team, member); where != "" { + return linkRefusal(member, where, "a stop"), true, nil + } + reason := strings.TrimSpace(parsed.Reason) + if reason == "" { + reason = "stopped by the manager" + } + entry := teams.Entry{Kind: teams.KindStop, From: teams.FromManager, To: member.Handle, Member: member.Key, Text: reason} + if err := teams.AppendTraffic(a.config.teamProfile(), team.ID, entry); err != nil { + return "The stop could not be written to the team's traffic: " + err.Error(), true, nil + } + return fmt.Sprintf("Asked to stop @%s's current turn. The window holding it ends the turn the way the person's Stop does; if no window has it open, there is no turn running to stop.", member.Handle), false, nil +} + +// ── team_start ────────────────────────────────────────────────────────────── + +func (a *Agent) teamStartTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + Handle string `json:"handle"` + Brief string `json:"brief"` + Kind string `json:"kind"` + Name string `json:"name"` + Members []string `json:"members"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + switch strings.TrimSpace(parsed.Kind) { + case "", "member", "team": + default: + return invalidArgumentsPrefix + "kind is member or team", true, nil + } + brief := strings.TrimSpace(parsed.Brief) + if brief == "" { + return invalidArgumentsPrefix + "brief is empty", true, nil + } + handle := strings.TrimPrefix(strings.ToLower(strings.TrimSpace(parsed.Handle)), "@") + if err := teams.ValidHandle(handle); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + team, role, refusal := a.teamTarget(parsed.Team, true) + if refusal != "" { + return refusal, true, nil + } + if strings.TrimSpace(parsed.Kind) == "team" { + said, failed := a.teamStartSubTeam(team, role, handle, brief, parsed.Name, parsed.Members) + return said, failed, nil + } + if strings.TrimSpace(parsed.Name) != "" || len(parsed.Members) > 0 { + return invalidArgumentsPrefix + "name and members are for kind team", true, nil + } + if reason := a.teamCapHold(a.config.teamProfile(), []teamRole{role}); reason != "" { + return "No new member starts: " + reason + ".", true, nil + } + if _, taken := team.ByHandle(handle); taken { + return fmt.Sprintf("@%s is already a member of %q. Pick another handle, or team_send it the work.", handle, team.Name), true, nil + } + entry := teams.Entry{Kind: teams.KindStart, From: teams.FromManager, To: handle, Text: brief} + if err := teams.AppendTraffic(a.config.teamProfile(), team.ID, entry); err != nil { + return "The start could not be written to the team's traffic: " + err.Error(), true, nil + } + return fmt.Sprintf("Asked for a new member @%s in %q. The conversations view opens it in the team's folder, and it is handed your brief, marked as from you, on its first request; "+ + "it shows in team_status once it has joined. Anything you team_send it before then is waiting for it.", handle, team.Name), false, nil +} + +// teamStartCost is the clause a start's permission card carries under the +// brief: what saying yes buys. A start is the one team verb that spends money +// the person has not already agreed to spend, and a card that said only "it +// will not run this without your word" would not say what the word is for. +const teamStartCost = "a new conversation; it spends until it stops" + +// teamStartArgs is a start's handle and brief out of its arguments, the handle +// the way the verb reads it (no @, lower case). Both are "" when they do not +// parse. +func teamStartArgs(arguments string) (handle, brief string) { + var parsed struct { + Handle string `json:"handle"` + Brief string `json:"brief"` + Kind string `json:"kind"` + Name string `json:"name"` + } + if json.Unmarshal([]byte(arguments), &parsed) != nil { + return "", "" + } + // A SUB-TEAM'S CARD SAYS SO: what the person is agreeing to is a new team + // as well as a new conversation. + if strings.TrimSpace(parsed.Kind) == "team" { + if name := strings.Join(strings.Fields(parsed.Name), " "); name != "" { + parsed.Brief = "a new team " + strconv.Quote(name) + " under yours, managed by it. " + parsed.Brief + } + } + handle = strings.TrimPrefix(strings.ToLower(strings.TrimSpace(parsed.Handle)), "@") + if teams.ValidHandle(handle) != nil { + handle = "" + } + return handle, strings.TrimSpace(parsed.Brief) +} + +// teamStartGloss is a start's row and the body of its card: the handle with +// its @, and the brief's first line, "team_start @lexer: Rewrite the lexer…". +// The card's own line says who wants it ([ConsentHead]); this says what for. +func teamStartGloss(arguments string) string { + handle, brief := teamStartArgs(arguments) + if handle == "" { + return "" + } + said := teamStartToolName + " @" + handle + if line := firstLine(brief); strings.TrimSpace(line) != "" { + said += ": " + strings.TrimSpace(line) + } + return clip(said, hintLimit) +} + +// ── team_post ─────────────────────────────────────────────────────────────── + +func (a *Agent) teamPostTool(ctx context.Context, args json.RawMessage) (string, bool, error) { + var parsed struct { + To string `json:"to"` + Text string `json:"text"` + Thread string `json:"thread"` + Team string `json:"team"` + } + if err := decodeToolArguments(args, &parsed); err != nil { + return invalidArgumentsPrefix + err.Error(), true, nil + } + text := strings.TrimSpace(parsed.Text) + if text == "" { + return invalidArgumentsPrefix + "text is empty", true, nil + } + thread := "" + if strings.TrimSpace(parsed.Thread) != "" { + id, ok := teams.ThreadID(parsed.Thread) + if !ok { + return invalidArgumentsPrefix + "thread is a message's number, like #42", true, nil + } + thread = id + } + team, role, refusal := a.teamTarget(parsed.Team, false) + if refusal != "" { + return refusal, true, nil + } + if role.handle == "" { + return "You have no handle in " + strconv.Quote(team.Name) + " yet, so nobody could tell who posted. It is given once this conversation has a title.", true, nil + } + entry := teams.Entry{Kind: teams.KindNote, From: role.handle, Text: text} + to := strings.TrimPrefix(strings.ToLower(strings.TrimSpace(parsed.To)), "@") + switch to { + case teams.ToRoom, "", teams.ToEveryone: + entry.To = teams.ToRoom + case teams.ToManager: + entry.To = teams.ToManager + default: + member, ok := teamMemberByHandle(team, to) + if !ok || member.Handle == role.handle { + return fmt.Sprintf("No teammate in %q has the handle %q. Post to room, manager, or one of %s.", team.Name, parsed.To, teamHandles(team, team.Manager)), true, nil + } + if member.Key == team.Manager { + entry.To = teams.ToManager + } else { + entry.To, entry.Member = member.Handle, member.Key + } + } + // A REPLY TO THE MANAGER ANSWERS WHAT THE MANAGER LAST SAID TO IT, unless + // it named another line; a post to the room or a teammate answers only what + // it names (internal/teams' thread.go). + if thread == "" && entry.To == teams.ToManager { + thread = a.teamAnswering(team.ID) + } + if entry.To == teams.ToManager && role.boss != "" && role.boss != team.ID { + // A SUB-TEAM WITH NO MANAGER OF ITS OWN POSTS TO THE ONE ABOVE: the + // line goes to that team's log, where its manager reads it, saying + // which team it came from. What it answers is what that manager last + // said to it, in that log. + if strings.TrimSpace(parsed.Thread) == "" { + thread = a.teamAnswering(role.boss) + } + entry.Answers = thread + return a.teamPostUp(team, role, entry) + } + entry.Answers = thread + // THE POST'S OWN NUMBER IS IN ITS ANSWER, ` as #N`, so the surface can find + // this call in the member's transcript when somebody asks to be taken to + // the message (tui3's teamjump.go). + own, err := teams.AppendTrafficID(a.config.teamProfile(), team.ID, entry) + if err != nil { + return "The post could not be written to the team's traffic: " + err.Error(), true, nil + } + where := "the room" + switch entry.To { + case teams.ToManager: + where = "the manager" + case teams.ToRoom: + default: + where = "@" + entry.To + } + if entry.To == teams.ToManager { + // A REPLY TO THE MANAGER WAKES IT, so a manager nobody has open is + // opened (team_wakewatch.go). + if manager, ok := team.Member(team.Manager); ok { + a.teamRouse(a.config.teamProfile(), team, role.wakes, []teams.Member{manager}, "") + } + } + answered := "" + if thread != "" { + answered = ", answering " + teams.ThreadNumber(thread) + } + as := "" + if own != "" { + as = " as " + teams.ThreadNumber(own) + } + return "Posted to " + where + " in " + strconv.Quote(team.Name) + as + answered + ". It arrives at the start of their next step.", false, nil +} diff --git a/internal/session/wakecause.go b/internal/session/wakecause.go index 2cb39ac064..bb1e2c11e8 100644 --- a/internal/session/wakecause.go +++ b/internal/session/wakecause.go @@ -146,7 +146,9 @@ func (a *Agent) oweLocked(ask owedAsk) { // forgetOwedLocked clears the previous turn's owed asks and the results they // arrived with. Called once, where a turn opens. -func (a *Agent) forgetOwedLocked() { a.owedAsks, a.landingOutcomes, a.turnResults = nil, nil, nil } +func (a *Agent) forgetOwedLocked() { + a.owedAsks, a.landingOutcomes, a.turnResults, a.personCardAnswers = nil, nil, nil, nil +} // turnAsk is the ask this turn's endings are read against. // diff --git a/internal/session/world.go b/internal/session/world.go index 1928ff0e20..5c51274c85 100644 --- a/internal/session/world.go +++ b/internal/session/world.go @@ -434,6 +434,39 @@ func ReadWorld(root string) World { // ReadHome is every project under this machine's state root. func ReadHome() World { return ReadWorld(PlacesRoot()) } +// ReadRows is the rows of the named conversations and of nothing else, keyed by +// each transcript's cleaned path: one [readSessionRow] per name, read exactly as +// the walk reads that folder. +// +// IT IS FOR A SURFACE THAT KNOWS WHICH CONVERSATIONS IT DRAWS. The teams page +// draws its members, twenty-five on a big machine, and it used to walk every +// session under the root on its opening and on every beat to find them: a stat, +// a meta.json, a presence file and a lock taken and let go for each of hundreds +// of folders, to keep a handful. A name that is not a session folder's journal, +// or whose folder is not a conversation somebody has had, is simply absent. +// +// THE TASK ROLL-UP IS NOT READ. The index is the bucket's ([TaskIndexPath]'s +// law) and nothing that asks for rows by name draws it, so [SessionRow.Tasks] +// is the zero roll-up here, as are the project fields. +func ReadRows(transcripts []string) map[string]SessionRow { + now := time.Now() + rows := make(map[string]SessionRow, len(transcripts)) + for _, name := range transcripts { + transcript := filepath.Clean(strings.TrimSpace(name)) + if transcript == "." || filepath.Base(transcript) != placeTranscript { + continue + } + if _, done := rows[transcript]; done { + continue + } + dir := filepath.Dir(transcript) + if row, ok := readSessionRow(dir, filepath.Base(dir), now); ok { + rows[transcript] = row + } + } + return rows +} + // Adopt puts the conversation a window is sitting in into the world when the // walk did not find it, and reports whether it had to. // diff --git a/internal/session/world_test.go b/internal/session/world_test.go index d94086949a..78e2f2b148 100644 --- a/internal/session/world_test.go +++ b/internal/session/world_test.go @@ -1,6 +1,11 @@ package session -import "testing" +import ( + "os" + "path/filepath" + "testing" + "time" +) // A ROLLUP'S NEWEST MOMENT IS A LANDING MOMENT. Live rows contribute to the // running and incomplete counts exactly as the conversation's presence says, @@ -22,3 +27,58 @@ func TestARollupOfOnlyRunningRowsHasNoNewestMoment(t *testing.T) { t.Fatalf("the rollup counts running/incomplete as %d/%d, want 1/1", got.Running, got.Incomplete) } } + +// ROWS BY NAME ARE THE WALK'S ROWS FOR THOSE NAMES AND NOTHING ELSE. Each named +// conversation reads as [ReadWorld] reads it; a folder nobody spoke in, a name +// that is not a session's journal and a folder that is not there are absent; +// and the conversation beside them that nobody named is never read. +func TestReadRowsReadsTheNamedConversationsAlone(t *testing.T) { + root := t.TempDir() + bucket := filepath.Join(root, "-work-alpha") + spoke := time.Now().Add(-time.Hour).Truncate(time.Second) + folder := func(id string, spoken bool) string { + dir := filepath.Join(bucket, id) + if err := os.MkdirAll(dir, 0o700); err != nil { + t.Fatal(err) + } + transcript := filepath.Join(dir, placeTranscript) + if err := os.WriteFile(transcript, []byte("{}\n"), 0o600); err != nil { + t.Fatal(err) + } + meta := Meta{ID: id, Title: "t " + id, Workspace: "/work/alpha", Created: spoke} + if spoken { + meta.LastUserAt = spoke + } + if err := SaveMeta(dir, meta); err != nil { + t.Fatal(err) + } + return transcript + } + named := folder("aaaa000000000001", true) + other := folder("aaaa000000000002", true) + empty := folder("aaaa000000000003", false) + gone := filepath.Join(bucket, "aaaa000000000004", placeTranscript) + + rows := ReadRows([]string{named, " " + named + " ", empty, gone, filepath.Join(bucket, "notes.txt")}) + if len(rows) != 1 { + t.Fatalf("read %d rows, want the one named conversation: %+v", len(rows), rows) + } + got, ok := rows[named] + if !ok { + t.Fatalf("the named conversation is not keyed by its transcript: %+v", rows) + } + var want SessionRow + for _, p := range ReadWorld(root).Projects { + for _, r := range p.Sessions { + if r.Transcript == named { + want = r + } + } + } + if got.ID != want.ID || got.Title != want.Title || !got.At.Equal(want.At) || got.Open != want.Open || got.Live != want.Live || got.Dir != want.Dir { + t.Fatalf("the row by name differs from the walk's:\n got %+v\nwant %+v", got, want) + } + if _, read := rows[other]; read { + t.Fatal("a conversation nobody named was read") + } +} diff --git a/internal/standing/standing.go b/internal/standing/standing.go index 2617e60c0c..02292e71f1 100644 --- a/internal/standing/standing.go +++ b/internal/standing/standing.go @@ -77,6 +77,7 @@ import ( "strconv" "strings" "time" + "unicode/utf8" ) // Schema is the document version every [Item] carries. Bump it when a field @@ -140,8 +141,8 @@ const ( // WhenProbe fires when a probe's output, judged by the sentinel against // the person's words, says yes. Anything the belt can do is a probe. WhenProbe WhenKind = "probe" - // WhenHold never wakes. A rule — "always use tabs here", "never touch the - // public API" — has no moment, no rhythm and no probe: its whole work is + // WhenHold never wakes. A rule, "always use tabs here", "never touch the + // public API", has no moment, no rhythm and no probe: its whole work is // done at birth, riding into the world of every conversation and task it // reaches (docs/STANDING-ORDERS.md, the birth seam). The pass walks past // it; it cannot fire, so it cannot spend, so it alone needs no rails and @@ -149,6 +150,59 @@ const ( WhenHold WhenKind = "hold" ) +// CardKind is what a proposal card calls this item. It is derived from the +// when, because that is the fact a person can check: a moment is a reminder, +// a rhythm is a repeating check, a condition is a watch, and a hold is a rule. +type CardKind string + +const ( + // CardReminder is one moment. Doing it now is not a smaller version of it. + CardReminder CardKind = "reminder" + // CardCheck repeats on a cadence. + CardCheck CardKind = "check" + // CardWatch waits on a condition or an event. + CardWatch CardKind = "watch" + // CardRule is kept, and never wakes. + CardRule CardKind = "rule" +) + +// CardKindOf reports which card this item is. A when this build does not know +// is read as a watch: it is something to look for, and the card says so. +func (it Item) CardKindOf() CardKind { + switch it.When.Kind { + case WhenAt: + return CardReminder + case WhenEvery: + return CardCheck + case WhenHold: + return CardRule + default: + return CardWatch + } +} + +// shortWordsRunes is how much of a cadence a button may carry. Past it the +// label eats the row and the other answers disappear. +const shortWordsRunes = 32 + +// ShortWords is the cadence a button can carry. A long sentence is cut at a +// word, because a label that fills the row leaves no room for the other answers. +func (w When) ShortWords() string { + words := strings.TrimSpace(w.Words) + if words == "" || utf8.RuneCountInString(words) <= shortWordsRunes { + return words + } + runes := []rune(words) + cut := shortWordsRunes + for cut > 0 && runes[cut-1] != ' ' { + cut-- + } + if cut == 0 { + cut = shortWordsRunes + } + return strings.TrimSpace(string(runes[:cut])) + "..." +} + // When is what wakes an item. Exactly the fields its Kind names are read; the // rest are left empty and never consulted. Words are always kept: they are the // person's own cadence or condition, and every surface speaks them back rather diff --git a/internal/teams/decision.go b/internal/teams/decision.go new file mode 100644 index 0000000000..7b58ced36f --- /dev/null +++ b/internal/teams/decision.go @@ -0,0 +1,1024 @@ +package teams + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "fmt" + "hash/fnv" + "io" + "os" + "path/filepath" + "sort" + "strconv" + "strings" + "sync" + "time" + + "github.com/Agent-Field/codeaf/internal/config" +) + +// ── DECISION PACKETS ──────────────────────────────────────────────────────── +// +// Every decision that has to be made above the conversation that met it (a +// conflict between parties, a question a manager escalates, a judgement call, +// a cap reached, a closing report) travels as a SELF-CONTAINED PACKET (ruling +// c-7): the question, the parties and what each of them said, the options each +// with what happens if it is chosen, and a recommendation with its reason. The +// same packet is answered by a manager or by the person, so either can decide +// it without reading a transcript. +// +// WHERE IT LIVES. A packet is written in the file of the team it was raised +// from (Origin), <profile>/teams/<origin>/decisions.jsonl, and never moves: +// escalating it changes who decides (Team) and adds a hop to its trail, and +// the line that says so is appended to the same file. So a packet has one home +// and one id for its life, and a sub-team's closed view can list everything +// its members raised. +// +// THE FILE IS EVENTS, FOLDED BY ID. One JSON object per line, only ever +// appended to: a `raise` carrying the whole packet, then `decide` or +// `escalate` lines naming it by id. Reading folds them in file order into the +// packet as it stands now. Nothing is rewritten, so a reader never sees a +// half-written packet and a writer never loses another's line. +// +// EVERY WRITE IS UNDER THE FILE'S LOCK and re-reads the fold under it, so two +// deciders cannot both decide one packet: the second is [ErrDecided]. A cap +// raise is the same shape: under that lock the writer looks for a packet +// already raised for the same pool, local day and ceiling, and a second +// raiser, including one in another process, writes nothing and is handed the +// packet that is already there. A later day, or the same day at a higher +// ceiling, is a different crossing and a new packet. +// +// READS ARE STAT-FIRST AND INCREMENTAL, for traffic.go's reason: the teams +// page asks about open packets on its clock. A file whose stamp has not moved +// is answered from memory, and one that grew is read from the byte where the +// last read stopped, never from the top. The scan across teams is one +// directory listing and a stat per team. +// +// THE FILE ROTATES LIKE TRAFFIC, and keeps every packet still waiting. Past +// [decisionsRotateBytes] the file is renamed to decisions.1.jsonl (replacing +// the one before) and the new file opens with one `carry` line per packet +// still waiting, the packet whole as it stands (its trail, its escalated +// state). A reader folds the rotated file and then the current one, and a +// carry replaces what the rotated file said of that id, so a waiting packet +// is never lost to a rotation and a decided one stays readable for one +// rotation more, which is long enough for its raiser to be handed the answer. +// +// EVERY CHANGE IS ALSO A LINE OF TRAFFIC, a [KindPacket] entry in the log of +// the team that raised it, of every team that was asked to decide it, and of +// every party's team, so the interface tailing a team's Traffic learns of a +// packet without polling this file, and a session delivering Traffic hands it +// to the manager and tells the parties. +// +// A CONFLICT'S RULING IS A DIRECTIVE TO EVERY PARTY (ruling c-6). Whoever +// decides a [PacketConflict] (the lowest common manager with [Decide], a +// manager above it after an escalation, or the person on the teams page, here +// or over --host through the engine's own [Decide]), the store appends one +// [KindDirective] to each party's team log, addressed to its handle and +// carrying the packet's id ([Entry.Packet]). So the ruling reaches every party +// by the road a directive always takes and wakes it, and it is in every +// involved team's Traffic, whoever made it. And a party never decides its +// own case: a manager who is one of the parties is not the decider even when +// the packet waits on its team ([ErrNotDecider]); the person still may. + +// Packet kinds. +const ( + PacketQuestion = "question" // a question nobody below could answer + PacketConflict = "conflict" // parties disagree; raised by team_raise + PacketCap = "cap" // a team reached its daily cap + PacketJudgement = "judgement" // a call a manager will not make alone + PacketClosing = "closing" // a manager's closing report before a close +) + +var packetKinds = map[string]bool{ + PacketQuestion: true, PacketConflict: true, PacketCap: true, PacketJudgement: true, PacketClosing: true, +} + +// Packet states. Escalated is still waiting: it is waiting at Team, which is +// no longer where it was raised. +const ( + PacketOpen = "open" + PacketDecided = "decided" + PacketEscalated = "escalated" +) + +// Person is the decider that is not a team: the person. It is the Team of a +// packet waiting on them, the by of a decision they made, and a scope. +const Person = "you" + +// ScopeAll is every packet still waiting, whoever decides it. +const ScopeAll = "" + +// The option ids of a closing packet and a cap packet, which the interface +// and the session both act on. +const ( + OptionClose = "close" // close the team + OptionCloseNow = "close-now" // close although the wrap-up did not finish + OptionKeepGoing = "keep-going" // do not close + OptionRaiseCap = "raise" // raise the cap (the option says to what) + OptionStopToday = "stop" // stop the team until tomorrow +) + +// Party is one side of a packet: a conversation, its handle and team, and the +// context it gave in its own words. +type Party struct { + Key string `json:"key"` + Handle string `json:"handle,omitempty"` + Team string `json:"team,omitempty"` + Context string `json:"context,omitempty"` +} + +// Option is one answer and what happens if it is chosen. +type Option struct { + ID string `json:"id"` + Label string `json:"label"` + Consequence string `json:"consequence"` +} + +// Recommendation is the option the raiser would choose, and why. +type Recommendation struct { + Option string `json:"option"` + Reason string `json:"reason"` +} + +// Hop is one escalation: from the decider it left to the one it went to. +type Hop struct { + From string `json:"from"` + To string `json:"to"` + By string `json:"by"` + Reason string `json:"reason,omitempty"` + At time.Time `json:"at"` +} + +// CapFacts is what a [PacketCap] packet says about the pool: whose cap it is +// (Team, the pool's owner), the local day, the cap reached, what the pool had +// spent when it was raised, and the figure the `raise` option raises it to +// for the rest of that day. The session reads RaiseTo back when the person +// picks `raise`, so the amount on the button is the amount that holds. +type CapFacts struct { + Team string `json:"team"` + Day string `json:"day"` + CapUSD float64 `json:"cap_usd"` + SpentUSD float64 `json:"spent_usd"` + RaiseTo float64 `json:"raise_to"` +} + +// ClosingReport is what a [PacketClosing] packet says about the team: what +// was done, what is left, where the files are and what it spent. Incomplete +// says the wrap-up ran out of time or money before it finished. +type ClosingReport struct { + Done string `json:"done"` + Left string `json:"left,omitempty"` + Files []string `json:"files,omitempty"` + SpendUSD float64 `json:"spend_usd,omitempty"` + Incomplete bool `json:"incomplete,omitempty"` +} + +// Packet is one decision, as it stands. +type Packet struct { + // ID is minted by [Raise]. + ID string `json:"id"` + // Team is who decides it now: a team id, whose manager decides, or + // [Person]. + Team string `json:"team"` + // Origin is the team it was raised from, whose file holds it. + Origin string `json:"origin"` + // Kind is one of the Packet kinds. + Kind string `json:"kind"` + // RaisedBy is the raiser's handle, or [FromManager] or [Person]. + RaisedBy string `json:"raised_by"` + // Parties are the sides, each with its own context. A question or a + // judgement may have one. + Parties []Party `json:"parties,omitempty"` + Question string `json:"question"` + Options []Option `json:"options,omitempty"` + // Recommendation is optional; when there is one it names an option. + Recommendation *Recommendation `json:"recommendation,omitempty"` + // Report is a closing packet's report, and nil on every other kind. + Report *ClosingReport `json:"report,omitempty"` + // Cap is a cap packet's facts, and nil on every other kind. + Cap *CapFacts `json:"cap,omitempty"` + // State is one of the Packet states. + State string `json:"state"` + // DecidedBy is the deciding manager's handle, or [Person]. + DecidedBy string `json:"decided_by,omitempty"` + // Decision is the chosen option's id, or the person's own words when none + // fitted. + Decision string `json:"decision,omitempty"` + // Reason is the decider's reason, or the last escalation's. + Reason string `json:"reason,omitempty"` + // Trail is every escalation, oldest first. + Trail []Hop `json:"trail,omitempty"` + // Raised is when it was raised, At when it last changed. + Raised time.Time `json:"raised"` + At time.Time `json:"at"` +} + +// Waiting reports whether the packet still needs a decision. +func (p Packet) Waiting() bool { return p.State == PacketOpen || p.State == PacketEscalated } + +// Option is the option with id. +func (p Packet) Option(id string) (Option, bool) { + for _, o := range p.Options { + if o.ID == id { + return o, true + } + } + return Option{}, false +} + +// Errors a packet write can answer. +var ( + ErrDecided = errors.New("teams: that packet was already decided") + ErrNoPacket = errors.New("teams: no such packet") + ErrNotDecider = errors.New("teams: only the manager it waits on, or you, can decide or escalate it") + ErrSideways = errors.New("teams: a packet goes up the tree or to you, never sideways or down") + // errCapAlready is a cap raise whose crossing is already in the file. The + // packet on the event has been replaced with the one that was there, and + // nothing was written. It stays inside this package: [Raise] answers that + // packet and no error. + errCapAlready = errors.New("teams: that cap crossing was already raised") +) + +// decisionEvent is one line of a packet file. +type decisionEvent struct { + Op string `json:"op"` + At time.Time `json:"at"` + Packet *Packet `json:"packet,omitempty"` + ID string `json:"id,omitempty"` + By string `json:"by,omitempty"` + Decision string `json:"decision,omitempty"` + To string `json:"to,omitempty"` + Reason string `json:"reason,omitempty"` +} + +const ( + opRaise = "raise" + opDecide = "decide" + opEscalate = "escalate" + // opCarry is a waiting packet written again, whole, at the head of a + // rotated file. It replaces what an older line said of that id. + opCarry = "carry" +) + +// decisionsRotateBytes is the size past which a packet file starts a new one. +// A packet is a few hundred bytes to a few kilobytes, so a megabyte is +// hundreds of decisions; a var so a test can rotate in a few lines. +var decisionsRotateBytes int64 = 1 << 20 + +func decisionsRotated(path string) string { + return strings.TrimSuffix(path, ".jsonl") + ".1.jsonl" +} + +// DecisionsPath is team teamID's packet file. +func DecisionsPath(profileDir, teamID string) string { + return config.ProfilePath(profileDir, filepath.Join("teams", teamID, "decisions.jsonl")) +} + +// ── WRITING ───────────────────────────────────────────────────────────────── + +// Raise records p as a new packet and answers it as written: with an id, open, +// raised now. p.Team is who decides (a team id or [Person]; the caller finds +// it, with [File.LCA] for parties or [File.Home] for a question), and +// p.Origin the team it is raised from, which must be p.Team or a team under +// it; an empty Origin is p.Team. An option with no id is given its place +// ("1", "2", ...). The kind, the question, the raiser, and a label and a +// consequence on every option are required; a question may have no options +// (the answer is words), every other kind must have one. +// +// A CAP PACKET IS RAISED ONCE PER CROSSING. The crossing is the pool, the +// local day and the ceiling ([capCrossing]). The check and the append happen +// under the decisions file's lock, so two processes that meet the same +// crossing write one line: the second is handed the packet already there, and +// no second line of Traffic is written. Any other kind is a new packet every +// time it is raised. +func Raise(profileDir string, p Packet) (Packet, error) { + if !packetKinds[p.Kind] { + return Packet{}, fmt.Errorf("teams: %q is not a packet kind", p.Kind) + } + if strings.TrimSpace(p.Question) == "" || strings.TrimSpace(p.RaisedBy) == "" { + return Packet{}, errors.New("teams: a packet needs a question and who raised it") + } + if len(p.Options) == 0 && p.Kind != PacketQuestion { + return Packet{}, errors.New("teams: a packet needs its options, each with what happens") + } + p.Options = append([]Option(nil), p.Options...) + seen := map[string]bool{} + for i := range p.Options { + o := &p.Options[i] + if o.ID == "" { + o.ID = strconv.Itoa(i + 1) + } + if seen[o.ID] || strings.TrimSpace(o.Label) == "" || strings.TrimSpace(o.Consequence) == "" { + return Packet{}, errors.New("teams: every option needs its own id, a label and what happens if it is chosen") + } + seen[o.ID] = true + } + if r := p.Recommendation; r != nil && (!seen[r.Option] || strings.TrimSpace(r.Reason) == "") { + return Packet{}, errors.New("teams: a recommendation names one of the options and says why") + } + if p.Origin == "" { + p.Origin = p.Team + } + if err := safeTeamID(p.Origin); err != nil || p.Origin == Person { + return Packet{}, errors.New("teams: a packet is raised from a team") + } + f, err := Load(profileDir) + if err != nil { + return Packet{}, err + } + if _, ok := f.Team(p.Origin); !ok { + return Packet{}, fmt.Errorf("no team %s", p.Origin) + } + if p.Team != Person { + decider, ok := f.Team(p.Team) + if !ok || decider.Closed() { + return Packet{}, fmt.Errorf("teams: %q is not an open team to decide it", p.Team) + } + if p.Team != p.Origin && !isAncestor(f, p.Team, p.Origin) { + return Packet{}, ErrSideways + } + } + now := time.Now() + p.ID, p.State, p.Raised, p.At = "p"+NewID(), PacketOpen, now, now + p.DecidedBy, p.Decision, p.Reason, p.Trail = "", "", "", nil + err = appendDecision(profileDir, p.Origin, &decisionEvent{Op: opRaise, At: now, Packet: &p}, nil) + if errors.Is(err, errCapAlready) { + return p, nil + } + if err != nil { + return Packet{}, err + } + logPacket(profileDir, f, p, involved(p, p.Origin, p.Team), + fmt.Sprintf("%s raised a %s: %s", p.RaisedBy, p.Kind, p.Question)) + return p, nil +} + +// Decide records by's decision on packet id: an option's id, or the person's +// own words. by is the handle of the manager of the team the packet waits on, +// or [Person], who may decide any packet. A packet already decided is +// [ErrDecided], and nothing is written. +func Decide(profileDir, id, by, decision, reason string) (Packet, error) { + if strings.TrimSpace(decision) == "" { + return Packet{}, errors.New("teams: a decision needs an answer") + } + var out Packet + f, err := Load(profileDir) + if err != nil { + return Packet{}, err + } + origin, err := packetOrigin(profileDir, id) + if err != nil { + return Packet{}, err + } + now := time.Now() + e := decisionEvent{Op: opDecide, At: now, ID: id, Decision: decision, Reason: reason} + err = appendDecision(profileDir, origin, &e, func(p Packet) error { + if !p.Waiting() { + return ErrDecided + } + who, ok := mayDecide(f, p, by) + if !ok { + return ErrNotDecider + } + out, e.By = p, who + return nil + }) + if err != nil { + return Packet{}, err + } + out = foldDecide(out, e) + word := decision + if o, ok := out.Option(decision); ok { + word = o.Label + } + // A QUESTION'S ANSWER READS AS ONE on the rail: `answered @web: JSON`, + // which the interface draws after the decider's mark. + said := fmt.Sprintf("%s decided: %s", e.By, word) + if out.Kind == PacketQuestion { + said = fmt.Sprintf("answered %s: %s", raiserWord(out.RaisedBy), word) + } + logPacket(profileDir, f, out, involved(out, out.Origin, out.Team), said) + if out.Kind == PacketConflict { + rule(profileDir, f, out) + } + return out, nil +} + +// Escalate sends packet id up: to an open team above the one it waits on, or +// to [Person]. by is as for [Decide]. Down, sideways or to a closed team is +// [ErrSideways]; a decided packet is [ErrDecided]. +func Escalate(profileDir, id, by, to, reason string) (Packet, error) { + var out Packet + f, err := Load(profileDir) + if err != nil { + return Packet{}, err + } + origin, err := packetOrigin(profileDir, id) + if err != nil { + return Packet{}, err + } + now := time.Now() + from := "" + e := decisionEvent{Op: opEscalate, At: now, ID: id, To: to, Reason: reason} + err = appendDecision(profileDir, origin, &e, func(p Packet) error { + if !p.Waiting() { + return ErrDecided + } + who, ok := mayDecide(f, p, by) + if !ok { + return ErrNotDecider + } + e.By = who + if p.Team == Person { + return ErrSideways + } + if to != Person { + t, ok := f.Team(to) + if !ok || t.Closed() || !isAncestor(f, to, p.Team) { + return ErrSideways + } + } + out, from = p, p.Team + return nil + }) + if err != nil { + return Packet{}, err + } + out = foldEscalate(out, e) + where := "you" + if t, ok := f.Team(to); ok { + where = "◆ " + t.Name + } + logPacket(profileDir, f, out, involved(out, out.Origin, from, to), fmt.Sprintf("%s sent it up to %s: %s", e.By, where, reason)) + return out, nil +} + +// raiserWord is how a raiser is named in a Traffic line: @handle for a +// member, the word itself for manager, you or system. +func raiserWord(by string) string { + switch by { + case FromManager, FromSystem, Person: + return by + } + return "@" + strings.TrimPrefix(by, "@") +} + +// mayDecide reports whether by may decide or escalate p, and the name it is +// recorded under: [Person], or the handle of the manager p waits on, which +// by may give as its handle or as [FromManager]. +func mayDecide(f *File, p Packet, by string) (string, bool) { + if by == Person { + return Person, true + } + t, ok := f.Team(p.Team) + if !ok || t.Closed() || t.Manager == "" || by == "" { + return "", false + } + m, ok := t.Member(t.Manager) + if !ok || (m.Handle != by && by != FromManager) { + return "", false + } + for _, party := range p.Parties { + if party.Key != "" && party.Key == t.Manager { + return "", false + } + } + if m.Handle != "" { + return m.Handle, true + } + return FromManager, true +} + +// involved is teams followed by every party's team: the logs a packet line +// goes to. +func involved(p Packet, teams ...string) []string { + for _, party := range p.Parties { + teams = append(teams, party.Team) + } + return teams +} + +// rule appends a decided conflict's ruling to every party's team log, as a +// directive to that party. A party with no team or a team no longer in the +// file is skipped; a log that cannot be written costs that line and never the +// decision, which is written already. +func rule(profileDir string, f *File, p Packet) { + from, by := FromManager, "◆ @"+p.DecidedBy + switch p.DecidedBy { + case Person: + from, by = FromYou, "the person" + case FromManager, "": + by = "the manager" + } + if t, ok := f.Team(p.Team); ok && p.DecidedBy != Person { + by += fmt.Sprintf(" (manager of %q)", t.Name) + } + word := p.Decision + if o, ok := p.Option(p.Decision); ok { + word = o.Label + ": " + o.Consequence + } + text := fmt.Sprintf("ruling on the conflict %s, by %s: %s", p.ID, by, word) + if r := strings.TrimSpace(p.Reason); r != "" { + text += ". Because: " + r + } + text += ". The conflict was: " + p.Question + for _, party := range p.Parties { + if party.Team == "" { + continue + } + if _, ok := f.Team(party.Team); !ok { + continue + } + to := party.Handle + if to == "" { + to = ToRoom + } + _ = AppendTraffic(profileDir, party.Team, Entry{Kind: KindDirective, From: from, To: to, Member: party.Key, + Text: text, Packet: p.ID, State: PacketDecided}) + } +} + +// IsRuling reports whether e is a conflict's ruling ([rule]): a directive +// that carries its packet's id. A session delivers it to the party it names +// whoever wrote it, and it wakes that party. +func IsRuling(e Entry) bool { return e.Kind == KindDirective && e.Packet != "" } + +// isAncestor reports whether team above is an ancestor of team id. +func isAncestor(f *File, above, id string) bool { + for _, a := range f.Ancestors(id) { + if a.ID == above { + return true + } + } + return false +} + +// packetOrigin is the team whose file holds packet id. +func packetOrigin(profileDir, id string) (string, error) { + all, err := allPackets(profileDir) + if err != nil { + return "", err + } + for _, p := range all { + if p.ID == id { + return p.Origin, nil + } + } + return "", ErrNoPacket +} + +// capCrossing is the identity of one cap ask: the pool, the local day, and the +// ceiling that was crossed. What had been spent, and the figure a raise would +// lift the ceiling to, are facts of that ask and not part of its identity, so +// two processes that meet the same ceiling write one packet. An empty key is +// a packet this rule does not apply to. +func capCrossing(p *Packet) (string, bool) { + if p == nil || p.Kind != PacketCap || p.Cap == nil || p.Cap.Team == "" || p.Cap.Day == "" { + return "", false + } + return p.Cap.Team + "\x00" + p.Cap.Day + "\x00" + strconv.FormatFloat(p.Cap.CapUSD, 'f', -1, 64), true +} + +// capAlready is the packet already raised for p's crossing, read from path +// under the decisions file's lock. The caller holds that lock. +func capAlready(path string, p *Packet) (Packet, bool) { + key, ok := capCrossing(p) + if !ok { + return Packet{}, false + } + folded, err := packetCache.read(path) + if err != nil { + return Packet{}, false + } + for _, have := range folded.list() { + if got, ok := capCrossing(&have); ok && got == key { + return have, true + } + } + return Packet{}, false +} + +// appendDecision appends e to team teamID's packet file under its lock. check, +// when given, is handed the packet e names as it stands under the lock, may +// fill in e, and an error from it writes nothing. +func appendDecision(profileDir, teamID string, e *decisionEvent, check func(Packet) error) error { + if err := safeTeamID(teamID); err != nil { + return err + } + path := DecisionsPath(profileDir, teamID) + return lockedAt(strings.TrimSuffix(path, ".jsonl")+".lock", lockWait, func() error { + // A CAP CROSSING IS ONE LINE. The fold is read under this lock, after + // any other raiser has either written or not, so the second process + // sees the first's packet and leaves the file alone. + if e.Op == opRaise && e.Packet != nil { + if existing, ok := capAlready(path, e.Packet); ok { + *e.Packet = existing + return errCapAlready + } + } + if check != nil { + packets, err := packetCache.read(path) + if err != nil { + return err + } + p, ok := packets.byID[e.ID] + if !ok { + return ErrNoPacket + } + if err := check(p); err != nil { + return err + } + } + line, err := json.Marshal(e) + if err != nil { + return err + } + if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { + return err + } + if info, err := os.Stat(path); err == nil && info.Size() > 0 && info.Size()+int64(len(line))+1 > decisionsRotateBytes { + if err := rotateDecisions(path); err != nil { + return err + } + } + before := modTime(path) + file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600) + if err != nil { + return err + } + if _, err := file.Write(append(line, '\n')); err != nil { + _ = file.Close() + return err + } + if err := file.Close(); err != nil { + return err + } + advance(path, before) + return nil + }) +} + +// rotateDecisions starts a new packet file at path, under its lock: the fold +// as it stands is taken, the file is renamed over the rotated one, and the new +// file is written (temporary file and rename) with a carry line for every +// packet still waiting, so nothing waiting lives only in the rotated file. +func rotateDecisions(path string) error { + now, err := packetCache.read(path) + if err != nil { + return err + } + var carry bytes.Buffer + for _, p := range now.list() { + if !p.Waiting() { + continue + } + p := p + line, err := json.Marshal(decisionEvent{Op: opCarry, At: p.At, Packet: &p}) + if err != nil { + return err + } + carry.Write(line) + carry.WriteByte('\n') + } + if err := os.Rename(path, decisionsRotated(path)); err != nil { + return err + } + if carry.Len() == 0 { + return nil + } + temp, err := os.CreateTemp(filepath.Dir(path), ".decisions-*") + if err != nil { + return err + } + name := temp.Name() + if _, err := temp.Write(carry.Bytes()); err != nil { + _ = temp.Close() + _ = os.Remove(name) + return err + } + if err := temp.Close(); err != nil { + _ = os.Remove(name) + return err + } + return os.Rename(name, path) +} + +// logPacket appends a [KindPacket] line to the Traffic of each distinct team +// in teams that is a team (not [Person], not ""). A log that cannot be written +// costs the line and never the packet, which is written already. +func logPacket(profileDir string, f *File, p Packet, teams []string, text string) { + seen := map[string]bool{} + for _, id := range teams { + if id == "" || id == Person || seen[id] { + continue + } + seen[id] = true + if _, ok := f.Team(id); !ok { + continue + } + _ = AppendTraffic(profileDir, id, Entry{Kind: KindPacket, From: FromSystem, To: ToManager, + Text: text, Packet: p.ID, State: p.State}) + } +} + +// ── READING ───────────────────────────────────────────────────────────────── + +// OpenPackets is every packet waiting on scope (a team id, [Person], or +// [ScopeAll] for every waiting packet), oldest first, and the stamp of the +// packet files it was read from: equal stamps are the same answer, so a +// reader can hand the stamp back and be told nothing moved ([PacketsStamp]). +func OpenPackets(profileDir, scope string) ([]Packet, string, error) { + stamp := PacketsStamp(profileDir) + all, err := allPackets(profileDir) + if err != nil { + return nil, stamp, err + } + var out []Packet + for _, p := range all { + if p.Waiting() && (scope == ScopeAll || p.Team == scope) { + out = append(out, p) + } + } + return out, stamp, nil +} + +// Packets is every packet raised from team teamID, decided or not, oldest +// first: a team's history, and its closing reports. +func Packets(profileDir, teamID string) ([]Packet, error) { + if err := safeTeamID(teamID); err != nil { + return nil, err + } + got, err := packetCache.read(DecisionsPath(profileDir, teamID)) + if err != nil { + return nil, err + } + return got.list(), nil +} + +// PacketByID is packet id as it stands. +func PacketByID(profileDir, id string) (Packet, error) { + all, err := allPackets(profileDir) + if err != nil { + return Packet{}, err + } + for _, p := range all { + if p.ID == id { + return p, nil + } + } + return Packet{}, ErrNoPacket +} + +// PacketsStamp is one stamp over every team's packet file: one directory +// listing and a stat per team. It moves when any packet file is written, +// made or removed. +func PacketsStamp(profileDir string) string { + files := packetFiles(profileDir) + if len(files) == 0 { + return MissingStamp + } + h := fnv.New64a() + for _, path := range files { + _, _ = io.WriteString(h, path) + _, _ = io.WriteString(h, "=") + _, _ = io.WriteString(h, stampOf(path)) + _, _ = io.WriteString(h, "\n") + } + return strconv.FormatUint(h.Sum64(), 36) + "." + strconv.Itoa(len(files)) +} + +// packetFiles is every team directory's packet file that exists, sorted. +func packetFiles(profileDir string) []string { + root := config.ProfilePath(profileDir, "teams") + entries, err := os.ReadDir(root) + if err != nil { + return nil + } + var out []string + for _, e := range entries { + if !e.IsDir() || safeTeamID(e.Name()) != nil { + continue + } + path := filepath.Join(root, e.Name(), "decisions.jsonl") + if _, err := os.Stat(path); err == nil { + out = append(out, path) + } + } + sort.Strings(out) + return out +} + +// allPackets is every packet in every team's file, oldest raised first. +func allPackets(profileDir string) ([]Packet, error) { + var out []Packet + for _, path := range packetFiles(profileDir) { + got, err := packetCache.read(path) + if err != nil { + return nil, err + } + out = append(out, got.list()...) + } + sort.SliceStable(out, func(i, j int) bool { return out[i].Raised.Before(out[j].Raised) }) + return out, nil +} + +// ── THE FOLD, AND ITS MEMORY ──────────────────────────────────────────────── + +// folded is one packet file as read so far: the rotated file whole (as it +// was at rotated), then the current file up to offset. +type folded struct { + stamp string + rotated string + offset int64 + order []string + byID map[string]Packet +} + +func (f *folded) list() []Packet { + out := make([]Packet, 0, len(f.order)) + for _, id := range f.order { + out = append(out, clonePacket(f.byID[id])) + } + return out +} + +// apply folds one event in. +func (f *folded) apply(e decisionEvent) { + switch e.Op { + case opRaise: + if e.Packet == nil || e.Packet.ID == "" { + return + } + if _, dup := f.byID[e.Packet.ID]; dup { + return + } + f.order = append(f.order, e.Packet.ID) + f.byID[e.Packet.ID] = clonePacket(*e.Packet) + case opCarry: + if e.Packet == nil || e.Packet.ID == "" { + return + } + if _, known := f.byID[e.Packet.ID]; !known { + f.order = append(f.order, e.Packet.ID) + } + f.byID[e.Packet.ID] = clonePacket(*e.Packet) + case opDecide: + if p, ok := f.byID[e.ID]; ok && p.Waiting() { + f.byID[e.ID] = foldDecide(p, e) + } + case opEscalate: + if p, ok := f.byID[e.ID]; ok && p.Waiting() { + f.byID[e.ID] = foldEscalate(p, e) + } + } +} + +func foldDecide(p Packet, e decisionEvent) Packet { + p.State, p.DecidedBy, p.Decision, p.Reason, p.At = PacketDecided, e.By, e.Decision, e.Reason, e.At + return p +} + +func foldEscalate(p Packet, e decisionEvent) Packet { + p.Trail = append(append([]Hop(nil), p.Trail...), Hop{From: p.Team, To: e.To, By: e.By, Reason: e.Reason, At: e.At}) + p.State, p.Team, p.Reason, p.At = PacketEscalated, e.To, e.Reason, e.At + return p +} + +func clonePacket(p Packet) Packet { + p.Parties = append([]Party(nil), p.Parties...) + p.Options = append([]Option(nil), p.Options...) + p.Trail = append([]Hop(nil), p.Trail...) + if p.Recommendation != nil { + r := *p.Recommendation + p.Recommendation = &r + } + if p.Report != nil { + r := *p.Report + r.Files = append([]string(nil), r.Files...) + p.Report = &r + } + if p.Cap != nil { + c := *p.Cap + p.Cap = &c + } + return p +} + +// packetMemory is every packet file read so far, by path, shared by every +// caller in the process (the engine answers several windows from it). +type packetMemory struct { + mu sync.Mutex + files map[string]*folded + // reads counts the bytes read, for a test to see a quiet file costs none. + reads int64 +} + +var packetCache packetMemory + +// forgetPackets drops what is remembered of profileDir's files, after a +// delete removed some. +func forgetPackets(profileDir string) { + prefix := config.ProfilePath(profileDir, "teams") + string(filepath.Separator) + packetCache.mu.Lock() + defer packetCache.mu.Unlock() + for path := range packetCache.files { + if strings.HasPrefix(path, prefix) { + delete(packetCache.files, path) + } + } +} + +// read is the file at path folded: from memory when its stamp has not moved, +// from where the last read stopped when it grew, and from the top when it is +// new to this process or shrank. The answer is a copy. +func (m *packetMemory) read(path string) (*folded, error) { + m.mu.Lock() + defer m.mu.Unlock() + if m.files == nil { + m.files = map[string]*folded{} + } + stamp := stampOf(path) + rotated := stampOf(decisionsRotated(path)) + f := m.files[path] + if f != nil && f.stamp == stamp && f.rotated == rotated { + return f.copy(), nil + } + if stamp == MissingStamp && rotated == MissingStamp { + delete(m.files, path) + return &folded{byID: map[string]Packet{}}, nil + } + size := int64(0) + if stamp != MissingStamp { + info, err := os.Stat(path) + if err != nil { + return nil, err + } + size = info.Size() + } + // FROM THE TOP when this process has not read it, when it shrank, or when + // the rotated file moved (a rotation happened): the rotated file whole, + // then the current one. + if f == nil || size < f.offset || f.rotated != rotated { + f = &folded{byID: map[string]Packet{}} + if rotated != MissingStamp { + if _, err := m.foldFrom(decisionsRotated(path), 0, f); err != nil && !os.IsNotExist(err) { + return nil, err + } + } + f.offset = 0 + } + if stamp != MissingStamp { + end, err := m.foldFrom(path, f.offset, f) + if err != nil && !os.IsNotExist(err) { + return nil, err + } + f.offset = end + } + // A line still being written has no newline yet; it is read next time, + // from the offset that stops before it. + f.stamp, f.rotated = stamp, rotated + m.files[path] = f + return f.copy(), nil +} + +// foldFrom folds the complete lines of the file at path from offset into f, +// and answers the offset after the last complete line. +func (m *packetMemory) foldFrom(path string, offset int64, f *folded) (int64, error) { + file, err := os.Open(path) + if err != nil { + return offset, err + } + defer file.Close() + if _, err := file.Seek(offset, io.SeekStart); err != nil { + return offset, err + } + r := bufio.NewReader(file) + for { + line, err := r.ReadBytes('\n') + if len(line) > 0 && line[len(line)-1] == '\n' { + m.reads += int64(len(line)) + offset += int64(len(line)) + var e decisionEvent + if json.Unmarshal(bytes.TrimSpace(line), &e) == nil { + f.apply(e) + } + } + if err == io.EOF { + return offset, nil + } + if err != nil { + return offset, err + } + } +} + +func (f *folded) copy() *folded { + out := &folded{stamp: f.stamp, rotated: f.rotated, offset: f.offset, order: append([]string(nil), f.order...), + byID: make(map[string]Packet, len(f.byID))} + for id, p := range f.byID { + out.byID[id] = p + } + return out +} diff --git a/internal/teams/decision_test.go b/internal/teams/decision_test.go new file mode 100644 index 0000000000..b05518111b --- /dev/null +++ b/internal/teams/decision_test.go @@ -0,0 +1,278 @@ +package teams + +import ( + "errors" + "os" + "strings" + "sync" + "testing" +) + +// packetTeams is harbor (managed by @boss) > dock (managed by @lead), both +// with members, saved in a fresh profile. +func packetTeams(t *testing.T) string { + t.Helper() + dir := t.TempDir() + teams := []Team{ + {ID: "aaaaaaaaaaaa", Name: "harbor", Manager: "hm", + Members: []Member{{Key: "hm", Handle: "boss"}, {Key: "dm", Handle: "lead"}}}, + {ID: "bbbbbbbbbbbb", Name: "dock", Parent: "aaaaaaaaaaaa", Manager: "dm", + Members: []Member{{Key: "dm", Handle: "lead"}, {Key: "w1", Handle: "web"}, {Key: "w2", Handle: "api"}}}, + } + must(t, Save(dir, teams)) + return dir +} + +func conflict() Packet { + return Packet{ + Team: "bbbbbbbbbbbb", Kind: PacketConflict, RaisedBy: "web", + Parties: []Party{ + {Key: "w1", Handle: "web", Team: "bbbbbbbbbbbb", Context: "the form posts JSON"}, + {Key: "w2", Handle: "api", Team: "bbbbbbbbbbbb", Context: "the endpoint takes form data"}, + }, + Question: "which shape does the signup form send?", + Options: []Option{ + {Label: "JSON", Consequence: "@api changes the handler; the form stays"}, + {Label: "form data", Consequence: "@web rewrites the submit; the handler stays"}, + }, + Recommendation: &Recommendation{Option: "1", Reason: "the other endpoints all take JSON"}, + } +} + +// A PACKET IS RAISED, DECIDED ONCE, AND READ BACK FOLDED. The raise mints the +// id and numbers the options; the open list for dock holds it; a decision by +// dock's manager closes it; a second decision is refused and writes nothing; +// and the file is events, not a rewritten record. +func TestAPacketIsRaisedDecidedOnceAndFolded(t *testing.T) { + dir := packetTeams(t) + p, err := Raise(dir, conflict()) + if err != nil { + t.Fatal(err) + } + if !strings.HasPrefix(p.ID, "p") || p.State != PacketOpen || p.Origin != "bbbbbbbbbbbb" || p.Options[1].ID != "2" { + t.Fatalf("raised %+v", p) + } + open, stamp, err := OpenPackets(dir, "bbbbbbbbbbbb") + if err != nil || len(open) != 1 || open[0].ID != p.ID || stamp == MissingStamp { + t.Fatalf("open for dock: %+v %q %v", open, stamp, err) + } + if mine, _, _ := OpenPackets(dir, Person); len(mine) != 0 { + t.Fatal("a packet for dock's manager waits on the person") + } + if _, err := Decide(dir, p.ID, "web", "1", "mine"); !errors.Is(err, ErrNotDecider) { + t.Fatalf("a member decided: %v", err) + } + got, err := Decide(dir, p.ID, FromManager, "1", "matches the rest") + if err != nil || got.State != PacketDecided || got.DecidedBy != "lead" || got.Decision != "1" { + t.Fatalf("decided %+v, %v", got, err) + } + if _, err := Decide(dir, p.ID, Person, "2", "late"); !errors.Is(err, ErrDecided) { + t.Fatalf("a second decision: %v", err) + } + back, err := PacketByID(dir, p.ID) + if err != nil || back.Decision != "1" || back.Reason != "matches the rest" { + t.Fatalf("read back %+v, %v", back, err) + } + if open, next, _ := OpenPackets(dir, "bbbbbbbbbbbb"); len(open) != 0 || next == stamp { + t.Fatalf("a decided packet is still open (%d) or the stamp did not move", len(open)) + } + raw, _ := os.ReadFile(DecisionsPath(dir, "bbbbbbbbbbbb")) + if lines := strings.Count(string(raw), "\n"); lines != 2 { + t.Fatalf("the file has %d lines, want a raise and a decide:\n%s", lines, raw) + } + // And every change is a line of Traffic, and a conflict's ruling is a + // directive to each of its parties (both in dock here). + entries, _ := ReadTraffic(dir, "bbbbbbbbbbbb", "", 0) + if len(entries) != 4 || entries[0].Kind != KindPacket || entries[1].State != PacketDecided || entries[1].Packet != p.ID || + !IsRuling(entries[2]) || entries[2].To != "web" || !IsRuling(entries[3]) || entries[3].To != "api" { + t.Fatalf("traffic %+v", entries) + } +} + +// ESCALATION GOES UP OR TO THE PERSON, NEVER SIDEWAYS, AND KEEPS ITS TRAIL. +func TestAPacketEscalatesUpAndToThePersonOnly(t *testing.T) { + dir := packetTeams(t) + p, err := Raise(dir, conflict()) + must(t, err) + if _, err := Escalate(dir, p.ID, "lead", "bbbbbbbbbbbb", "self"); !errors.Is(err, ErrSideways) { + t.Fatalf("escalated to itself: %v", err) + } + up, err := Escalate(dir, p.ID, "lead", "aaaaaaaaaaaa", "it touches billing too") + if err != nil || up.State != PacketEscalated || up.Team != "aaaaaaaaaaaa" || len(up.Trail) != 1 || + up.Trail[0].From != "bbbbbbbbbbbb" || up.Trail[0].By != "lead" { + t.Fatalf("escalated %+v, %v", up, err) + } + if open, _, _ := OpenPackets(dir, "aaaaaaaaaaaa"); len(open) != 1 { + t.Fatal("harbor's manager does not see the escalated packet") + } + if _, err := Decide(dir, p.ID, "lead", "1", ""); !errors.Is(err, ErrNotDecider) { + t.Fatalf("the manager it left decided it: %v", err) + } + mine, err := Escalate(dir, p.ID, "boss", Person, "a judgement call") + if err != nil || mine.Team != Person || len(mine.Trail) != 2 { + t.Fatalf("to the person: %+v %v", mine, err) + } + if _, err := Escalate(dir, p.ID, Person, "aaaaaaaaaaaa", "back down"); !errors.Is(err, ErrSideways) { + t.Fatalf("a packet at the person went back down: %v", err) + } + if all, _, _ := OpenPackets(dir, ScopeAll); len(all) != 1 { + t.Fatal("the all scope lost it") + } + done, err := Decide(dir, p.ID, Person, "keep both, add a shim", "neither side should move today") + if err != nil || done.DecidedBy != Person || done.Decision != "keep both, add a shim" { + t.Fatalf("the person's own words: %+v %v", done, err) + } + // The escalated packet is logged in every team it passed through. + if e, _ := ReadTraffic(dir, "aaaaaaaaaaaa", "", 0); len(e) < 2 { + t.Fatalf("harbor's traffic has %d packet lines", len(e)) + } +} + +// A PACKET IS COMPLETE OR REFUSED: every option says what happens, a +// recommendation names an option and a reason, it is raised from the deciding +// team or below it, and a question may have no options. +func TestARaiseRefusesAnIncompletePacket(t *testing.T) { + dir := packetTeams(t) + for name, bad := range map[string]func(*Packet){ + "no kind": func(p *Packet) { p.Kind = "gossip" }, + "no question": func(p *Packet) { p.Question = " " }, + "no raiser": func(p *Packet) { p.RaisedBy = "" }, + "no options": func(p *Packet) { p.Options = nil }, + "no consequence": func(p *Packet) { p.Options[0].Consequence = "" }, + "unknown recommendation": func(p *Packet) { p.Recommendation.Option = "9" }, + "no reason": func(p *Packet) { p.Recommendation.Reason = "" }, + "raised from above": func(p *Packet) { p.Origin = "aaaaaaaaaaaa" }, + "decider unknown": func(p *Packet) { p.Team = "eeeeeeeeeeee"; p.Origin = "bbbbbbbbbbbb" }, + } { + p := conflict() + p.Options = append([]Option(nil), p.Options...) + r := *p.Recommendation + p.Recommendation = &r + bad(&p) + if _, err := Raise(dir, p); err == nil { + t.Errorf("%s: raised", name) + } + } + q := Packet{Team: Person, Origin: "aaaaaaaaaaaa", Kind: PacketQuestion, RaisedBy: "boss", + Question: "ship on Friday or Monday?"} + if _, err := Raise(dir, q); err != nil { + t.Fatalf("a bare question to the person: %v", err) + } + if mine, _, _ := OpenPackets(dir, Person); len(mine) != 1 { + t.Fatal("the person's inbox is empty") + } +} + +// A CLOSING PACKET CARRIES ITS REPORT and the close options by their ids. +func TestAClosingPacketCarriesItsReport(t *testing.T) { + dir := packetTeams(t) + p, err := Raise(dir, Packet{Team: Person, Origin: "bbbbbbbbbbbb", Kind: PacketClosing, RaisedBy: "lead", + Question: "close dock?", + Report: &ClosingReport{Done: "signup ships", Left: "the shim", Files: []string{"web/signup.ts"}, SpendUSD: 3.2}, + Options: []Option{ + {ID: OptionClose, Label: "Close", Consequence: "dock moves to Closed; members stop"}, + {ID: OptionKeepGoing, Label: "Keep going", Consequence: "nothing changes"}, + }, + Recommendation: &Recommendation{Option: OptionClose, Reason: "the work is merged"}}) + must(t, err) + got, _ := Packets(dir, "bbbbbbbbbbbb") + if len(got) != 1 || got[0].Report == nil || got[0].Report.Files[0] != "web/signup.ts" || got[0].ID != p.ID { + t.Fatalf("the report did not survive: %+v", got) + } +} + +// A QUIET PACKET FILE COSTS A STAT, AND A GROWN ONE IS READ FROM WHERE THE +// LAST READ STOPPED. +func TestPacketReadsAreIncremental(t *testing.T) { + dir := packetTeams(t) + _, err := Raise(dir, conflict()) + must(t, err) + _, _, _ = OpenPackets(dir, ScopeAll) + before := packetCache.bytes() + _, _, _ = OpenPackets(dir, ScopeAll) + if packetCache.bytes() != before { + t.Fatal("a quiet file was read again") + } + size := fileSize(t, DecisionsPath(dir, "bbbbbbbbbbbb")) + _, err = Raise(dir, conflict()) + must(t, err) + _, _, _ = OpenPackets(dir, ScopeAll) + grew := fileSize(t, DecisionsPath(dir, "bbbbbbbbbbbb")) - size + if got := packetCache.bytes() - before; got != grew { + t.Fatalf("a grown file read %d bytes, want the %d appended", got, grew) + } +} + +// capAsk is one crossing: dock's pool, one local day, one ceiling. +func capAsk(day string, ceiling float64) Packet { + return Packet{ + Team: Person, Origin: "bbbbbbbbbbbb", Kind: PacketCap, RaisedBy: FromSystem, + Question: "dock reached its cap today", + Options: []Option{ + {ID: OptionRaiseCap, Label: "Raise", Consequence: "dock goes on today"}, + {ID: OptionStopToday, Label: "Stop for today", Consequence: "nothing new starts until tomorrow"}, + }, + Cap: &CapFacts{Team: "bbbbbbbbbbbb", Day: day, CapUSD: ceiling, SpentUSD: ceiling + 0.2, RaiseTo: ceiling * 2}, + } +} + +// TWO RAISERS OF ONE CROSSING WRITE ONE PACKET. Each goroutine is its own +// raiser on the same directory, the way two processes are: they share no +// packet in memory, only the file, and the second must find the first's line +// under the file lock and write nothing. A later day is a different crossing +// and writes a second packet, and so is the same day at a higher ceiling. +func TestACapCrossingIsRaisedOnceAcrossRaisers(t *testing.T) { + dir := packetTeams(t) + var wg sync.WaitGroup + got := make([]Packet, 2) + errs := make([]error, 2) + for i := 0; i < 2; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + got[i], errs[i] = Raise(dir, capAsk("2026-09-24", 5)) + }(i) + } + wg.Wait() + for i, err := range errs { + if err != nil { + t.Fatalf("raiser %d: %v", i, err) + } + } + if got[0].ID == "" || got[0].ID != got[1].ID { + t.Fatalf("two raisers wrote two packets: %s and %s", got[0].ID, got[1].ID) + } + list, err := Packets(dir, "bbbbbbbbbbbb") + if err != nil || len(list) != 1 || list[0].Kind != PacketCap || list[0].ID != got[0].ID { + t.Fatalf("the file holds %+v (%v)", list, err) + } + raw, _ := os.ReadFile(DecisionsPath(dir, "bbbbbbbbbbbb")) + if lines := strings.Count(string(raw), "\n"); lines != 1 { + t.Fatalf("the file has %d lines, want one raise:\n%s", lines, raw) + } + next, err := Raise(dir, capAsk("2026-09-25", 5)) + if err != nil || next.ID == got[0].ID { + t.Fatalf("a later day: %+v %v", next, err) + } + higher, err := Raise(dir, capAsk("2026-09-24", 10)) + if err != nil || higher.ID == got[0].ID || higher.ID == next.ID { + t.Fatalf("a higher ceiling: %+v %v", higher, err) + } + list, err = Packets(dir, "bbbbbbbbbbbb") + if err != nil || len(list) != 3 { + t.Fatalf("three crossings, got %+v (%v)", list, err) + } +} + +func (m *packetMemory) bytes() int64 { + m.mu.Lock() + defer m.mu.Unlock() + return m.reads +} + +func fileSize(t *testing.T, path string) int64 { + t.Helper() + info, err := os.Stat(path) + must(t, err) + return info.Size() +} diff --git a/internal/teams/delegation_test.go b/internal/teams/delegation_test.go new file mode 100644 index 0000000000..e07fb091e5 --- /dev/null +++ b/internal/teams/delegation_test.go @@ -0,0 +1,514 @@ +package teams + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +func ptrF(v float64) *float64 { return &v } +func ptrI(v int) *int { return &v } +func ptrB(v bool) *bool { return &v } + +// tree is harbor > dock > pier, and a separate top-level team yard. +func tree() *File { + return &File{Version: Version, Teams: []Team{ + {ID: "aaaaaaaaaaaa", Name: "harbor", Members: []Member{{Key: "hm", Word: "harbor boss"}}}, + {ID: "bbbbbbbbbbbb", Name: "dock", Parent: "aaaaaaaaaaaa"}, + {ID: "cccccccccccc", Name: "pier", Parent: "bbbbbbbbbbbb"}, + {ID: "dddddddddddd", Name: "yard"}, + }} +} + +var defaults = Defaults{QuestionsUp: true, CapUSDDay: 5, DepthLimit: 3, SubShare: 0.5} + +// AN UNSET VALUE IS INHERITED, AND THE RESOLVER SAYS FROM WHERE. pier sets +// nothing: questions come from Settings, the cap from harbor two levels up, +// the share from dock one level up; its own depth override is its own. +func TestEffectiveWalksTheChainAndNamesEachOrigin(t *testing.T) { + f := tree() + must(t, f.SetSettings("aaaaaaaaaaaa", func(s *Settings) { s.CapUSDDay = ptrF(10) })) + must(t, f.SetSettings("bbbbbbbbbbbb", func(s *Settings) { s.SubShare = ptrF(0.25) })) + must(t, f.SetSettings("cccccccccccc", func(s *Settings) { s.DepthLimit = ptrI(4) })) + + e := f.Effective("cccccccccccc", defaults) + if !e.QuestionsUp || e.QuestionsUpFrom.Kind != OriginSettings || e.QuestionsUpFrom.Words() != "from Settings" { + t.Fatalf("questions: %+v", e) + } + if e.CapUSDDay != 10 || e.CapFrom.Kind != OriginAncestor || e.CapFrom.Team != "aaaaaaaaaaaa" || e.CapFrom.Words() != "from harbor" { + t.Fatalf("cap: %v %+v", e.CapUSDDay, e.CapFrom) + } + if e.SubShare != 0.25 || e.SubShareFrom.Name != "dock" { + t.Fatalf("share: %v %+v", e.SubShare, e.SubShareFrom) + } + if e.DepthLimit != 4 || e.DepthFrom.Kind != OriginTeam || e.DepthFrom.Inherited() || e.DepthFrom.Words() != "" { + t.Fatalf("depth: %v %+v", e.DepthLimit, e.DepthFrom) + } + // Reset is a nil: pier's depth falls back to Settings. + must(t, f.SetSettings("cccccccccccc", func(s *Settings) { s.DepthLimit = nil })) + if e := f.Effective("cccccccccccc", defaults); e.DepthLimit != 3 || e.DepthFrom.Kind != OriginSettings { + t.Fatalf("a reset override: %+v", e) + } + // An explicit 0 cap is an override (no cap), not an absence. + must(t, f.SetSettings("bbbbbbbbbbbb", func(s *Settings) { s.CapUSDDay = ptrF(0) })) + if e := f.Effective("cccccccccccc", defaults); e.CapUSDDay != 0 || e.CapFrom.Name != "dock" { + t.Fatalf("a zero cap override: %+v", e) + } + // An unknown team is the defaults throughout. + if e := f.Effective("nothere", defaults); e.CapUSDDay != 5 || e.CapFrom.Kind != OriginSettings { + t.Fatalf("an unknown team: %+v", e) + } +} + +// AN OVERRIDE OUTSIDE ITS BAND IS REFUSED, AND ONE IN A HAND-EDITED FILE IS +// DROPPED ON LOAD, reading as inherit. +func TestOverridesAreKeptInTheirBands(t *testing.T) { + f := tree() + for _, bad := range []func(*Settings){ + func(s *Settings) { s.CapUSDDay = ptrF(-1) }, + func(s *Settings) { s.DepthLimit = ptrI(0) }, + func(s *Settings) { s.SubShare = ptrF(1.5) }, + func(s *Settings) { s.SubShare = ptrF(0) }, + } { + if err := f.SetSettings("aaaaaaaaaaaa", bad); err != ErrSetting { + t.Fatalf("an out-of-band override was taken: %v", err) + } + } + if !f.Teams[0].Settings.Empty() { + t.Fatal("a refused override changed the team") + } + dir := t.TempDir() + raw := `{"version":2,"teams":[{"id":"aaaaaaaaaaaa","name":"harbor","parent":"","members":[],"manager":"",` + + `"made":"2026-09-24T00:00:00Z","cap_usd_day":-3,"depth_limit":2,"questions_up":false}]}` + writeRaw(t, dir, raw) + got, err := Load(dir) + if err != nil { + t.Fatal(err) + } + s := got.Teams[0].Settings + if s.CapUSDDay != nil || s.DepthLimit == nil || *s.DepthLimit != 2 || s.QuestionsUp == nil || *s.QuestionsUp { + t.Fatalf("the file's overrides read as %+v", s) + } +} + +// THE OVERRIDES ARE WRITTEN FLAT ON THE TEAM, only when set, and survive a +// round trip; a team with none is written as before. +func TestOverridesAreStoredFlatAndOnlyWhenSet(t *testing.T) { + plain, _ := json.Marshal(Team{ID: "aaaaaaaaaaaa", Name: "harbor"}) + for _, k := range []string{"questions_up", "cap_usd_day", "depth_limit", "sub_share", "state", "closed_at"} { + if strings.Contains(string(plain), k) { + t.Fatalf("a team with no overrides wrote %s: %s", k, plain) + } + } + team := Team{ID: "aaaaaaaaaaaa", Name: "harbor", Settings: Settings{CapUSDDay: ptrF(0), QuestionsUp: ptrB(false)}} + raw, _ := json.Marshal(team) + if !strings.Contains(string(raw), `"cap_usd_day":0`) || !strings.Contains(string(raw), `"questions_up":false`) { + t.Fatalf("the overrides are not flat on the team: %s", raw) + } + var back Team + must(t, json.Unmarshal(raw, &back)) + if back.Settings.CapUSDDay == nil || *back.Settings.CapUSDDay != 0 || *back.Settings.QuestionsUp { + t.Fatalf("the round trip lost an override: %+v", back.Settings) + } + if len(back.extra) != 0 { + t.Fatalf("an override was kept as an unknown field: %v", back.extra) + } +} + +// DEPTH AND THE SHARE A NEW SUB-TEAM IS MADE WITH. +func TestNestingDepthAndTheSubTeamsShare(t *testing.T) { + f := tree() + if f.Depth("aaaaaaaaaaaa") != 1 || f.Depth("cccccccccccc") != 3 || f.Depth("nothere") != 0 { + t.Fatal("depths are wrong") + } + if !f.CanNest("bbbbbbbbbbbb", defaults) || f.CanNest("cccccccccccc", defaults) { + t.Fatal("a limit of 3 allows a third level and not a fourth") + } + if got := f.SubTeamCap("aaaaaaaaaaaa", defaults); got != 2.5 { + t.Fatalf("half of $5 is %v", got) + } + if got := f.SubTeamCap("aaaaaaaaaaaa", Defaults{DepthLimit: 3, SubShare: 0.5}); got != 0 { + t.Fatalf("a parent with no cap gave its sub-team %v", got) + } +} + +// managed is harbor managed by hm, dock unmanaged under it, yard managed by ym. +func managed() *File { + f := tree() + f.Teams[0].Manager = "hm" + f.Teams[3].Members = []Member{{Key: "ym"}} + f.Teams[3].Manager = "ym" + return f +} + +// THE HOME IS PICKED IN THE RULING'S ORDER. A conversation only in unmanaged +// dock reports to harbor above it; one in managed yard directly and in dock +// reports to yard (nearest); the manager of harbor reports to nobody, and +// the manager of a sub-team reports one level up. +func TestHomeIsPickedNearestThenStartedThenFirst(t *testing.T) { + f := managed() + f.Teams[1].Members = []Member{{Key: "k1"}, {Key: "k2"}} + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "k2"}) + tidy(f.Teams) + + if h, ok := f.Home("k1"); !ok || h.Team != "aaaaaaaaaaaa" || h.Via != "bbbbbbbbbbbb" || h.Distance != 1 { + t.Fatalf("k1 in unmanaged dock reports to %+v %v", h, ok) + } + if h, _ := f.Home("k2"); h.Team != "dddddddddddd" || h.Distance != 0 { + t.Fatalf("k2 reports to %+v, want yard (its own team managed beats one a level up)", h) + } + if links := f.Links("k2"); len(links) != 1 || links[0].Team != "aaaaaaaaaaaa" { + t.Fatalf("k2's links are %+v", links) + } + if _, ok := f.Home("hm"); ok { + t.Fatal("the top manager reports to somebody") + } + // dock gets a manager of its own: it reports one level up, to harbor. + f.Teams[1].Members = append(f.Teams[1].Members, Member{Key: "dm"}) + f.Teams[1].Manager = "dm" + tidy(f.Teams) + if h, _ := f.Home("dm"); h.Team != "aaaaaaaaaaaa" { + t.Fatalf("a sub-team's manager reports to %+v", h) + } + // k1's home is still its dock membership, whose nearest manager is now + // dock's own: giving a team a manager is the person's act, and it is what + // the manager is for (see home.go). + if h, _ := f.Home("k1"); h.Team != "bbbbbbbbbbbb" || h.Via != "bbbbbbbbbbbb" { + t.Fatalf("k1 in newly managed dock reports to %+v", h) + } + + // Two managed teams at the same distance: the started one wins over file order. + g := managed() + g.Teams[0].Members = append(g.Teams[0].Members, Member{Key: "k3"}) + g.Teams[3].Members = append(g.Teams[3].Members, Member{Key: "k3", Started: true}) + tidy(g.Teams) + if h, _ := g.Home("k3"); h.Team != "dddddddddddd" { + t.Fatalf("the started membership lost: %+v", h) + } + // Without the start, the first in the file. + g.Teams[3].Members[1].Started = false + for i := range g.Teams { + for j := range g.Teams[i].Members { + g.Teams[i].Members[j].Home = false + } + } + tidy(g.Teams) + if h, _ := g.Home("k3"); h.Team != "aaaaaaaaaaaa" { + t.Fatalf("the first in the file lost: %+v", h) + } +} + +// A HOME NEVER CHANGES BY ITSELF, MOVES WHEN IT IS NO LONGER ONE, AND SETHOME +// MOVES IT ON PURPOSE. +func TestHomeIsStableUntilItStopsBeingOne(t *testing.T) { + f := managed() + f.Teams[0].Members = append(f.Teams[0].Members, Member{Key: "k"}) + tidy(f.Teams) + if h, _ := f.Home("k"); h.Team != "aaaaaaaaaaaa" { + t.Fatalf("home %+v", h) + } + // k joins yard, which is just as near: harbor stays. + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "k", Started: true}) + if tidy(f.Teams) { + t.Fatal("a nearer or started membership moved a valid home") + } + if h, _ := f.Home("k"); h.Team != "aaaaaaaaaaaa" { + t.Fatalf("home moved to %+v", h) + } + // The person moves it. + must(t, f.SetHome("k", "dddddddddddd")) + if h, _ := f.Home("k"); h.Team != "dddddddddddd" { + t.Fatalf("SetHome left %+v", h) + } + flags := 0 + for _, tm := range f.Teams { + if m, ok := tm.Member("k"); ok && m.Home { + flags++ + } + } + if flags != 1 { + t.Fatalf("k carries %d home flags", flags) + } + // SetHome refuses a team with nothing above it. + f.Teams[1].Members = []Member{{Key: "k"}} + f.Teams[0].Manager = "" + if err := f.SetHome("k", "bbbbbbbbbbbb"); err != ErrNoManagerAbove { + t.Fatalf("SetHome on an unmanaged chain: %v", err) + } + // yard's manager cleared: the home is gone and nothing else is above k. + must(t, f.ClearManager("dddddddddddd")) + tidy(f.Teams) + if _, ok := f.Home("k"); ok { + t.Fatal("k still reports somewhere with no managers left") + } + for _, tm := range f.Teams { + if m, ok := tm.Member("k"); ok && m.Home { + t.Fatal("a flag was left with nothing above it") + } + } +} + +// THE HOME FLAG SURVIVES A SAVE AND A LOAD, and a load of a file with none +// gives every conversation with a manager one. +func TestHomesAreStoredAndRepairedOnLoad(t *testing.T) { + dir := t.TempDir() + f := managed() + f.Teams[0].Members = append(f.Teams[0].Members, Member{Key: "k"}) + raw, _ := json.Marshal(disk{Version: Version, Teams: f.Teams}) + writeRaw(t, dir, string(raw)) + got, err := Load(dir) + if err != nil { + t.Fatal(err) + } + if h, ok := got.Home("k"); !ok || h.Team != "aaaaaaaaaaaa" { + t.Fatalf("a load gave k %+v %v", h, ok) + } + again, _ := Load(dir) + if m, _ := again.Teams[0].Member("k"); !m.Home { + t.Fatal("the repair was not written back") + } +} + +// THE LCA OF 1..N PARTIES, WITH UNMANAGED GAPS. Parties in pier and dock +// (neither managed) meet at harbor; a party in yard shares no team with +// harbor's, so the person decides; a party that manages the meeting team is +// passed over for the next one up. +func TestLCAForOneToNPartiesAcrossUnmanagedGaps(t *testing.T) { + f := managed() + f.Teams[1].Members = []Member{{Key: "d1"}} + f.Teams[2].Members = []Member{{Key: "p1"}, {Key: "p2"}} + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "y1"}) + + if lca, ok := f.LCA("p1"); !ok || lca.Name != "harbor" { + t.Fatalf("one party: %v %v", lca.Name, ok) + } + if lca, ok := f.LCA("p1", "p2"); !ok || lca.Name != "harbor" { + t.Fatalf("two in unmanaged pier: %v %v", lca.Name, ok) + } + if lca, ok := f.LCA("p1", "d1", "p2"); !ok || lca.Name != "harbor" { + t.Fatalf("three across pier and dock: %v %v", lca.Name, ok) + } + if _, ok := f.LCA("p1", "y1"); ok { + t.Fatal("parties in two trees found a common manager") + } + // Manage pier: the two in pier meet there, pier and dock still at harbor. + f.Teams[2].Members = append(f.Teams[2].Members, Member{Key: "pm"}) + f.Teams[2].Manager = "pm" + if lca, _ := f.LCA("p1", "p2"); lca.Name != "pier" { + t.Fatalf("two in managed pier meet at %v", lca.Name) + } + if lca, _ := f.LCA("p1", "d1"); lca.Name != "harbor" { + t.Fatalf("pier and dock meet at %v", lca.Name) + } + // The pier manager as a party: pier is passed over. + if lca, _ := f.LCA("pm", "p1"); lca.Name != "harbor" { + t.Fatalf("a manager judged its own case at %v", lca.Name) + } + // A conversation in both yard and pier: yard is shared with y1. + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "p1"}) + if lca, _ := f.LCA("p1", "y1"); lca.Name != "yard" { + t.Fatalf("a shared membership meets at %v", lca.Name) + } + if _, ok := f.LCA(); ok { + t.Fatal("no parties found a decider") + } +} + +// CLOSING CASCADES DOWN, TAKES THE TEAM OUT OF EVERY WALK, AND REOPEN BRINGS +// BACK EXACTLY WHAT IT CLOSED. +func TestCloseCascadesAndReopenUndoesOnlyItsOwn(t *testing.T) { + f := managed() + f.Teams[1].Members = []Member{{Key: "k"}} + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "k"}) + must(t, f.SetSettings("aaaaaaaaaaaa", func(s *Settings) { s.CapUSDDay = ptrF(10) })) + tidy(f.Teams) + if h, _ := f.Home("k"); h.Team != "dddddddddddd" { + t.Fatalf("home before %+v", h) + } + // pier closed on its own first. + at := time.Date(2026, 9, 24, 10, 0, 0, 0, time.UTC) + must(t, f.Close("cccccccccccc", at, "")) + must(t, f.Close("aaaaaaaaaaaa", at.Add(time.Hour), "p123")) + for _, id := range []string{"aaaaaaaaaaaa", "bbbbbbbbbbbb", "cccccccccccc"} { + if tm, _ := f.Team(id); !tm.Closed() { + t.Fatalf("%s is open after its ancestor closed", id) + } + } + if tm, _ := f.Team("cccccccccccc"); tm.ClosedWith != "cccccccccccc" || !tm.ClosedAt.Equal(at) { + t.Fatalf("pier's own close was overwritten: %+v", tm) + } + if tm, _ := f.Team("aaaaaaaaaaaa"); tm.Report != "p123" { + t.Fatal("the report pointer was not kept") + } + if len(f.Open()) != 1 || len(f.ClosedTeams()) != 3 || f.ClosedTeams()[0].ID != "aaaaaaaaaaaa" { + t.Fatal("open and closed lists are wrong") + } + // Out of every walk. + if lca, ok := f.LCA("hm"); ok { + t.Fatalf("a closed team decided: %v", lca.Name) + } + if e := f.Effective("bbbbbbbbbbbb", defaults); e.CapFrom.Kind != OriginClosed || e.CapUSDDay != 0 { + t.Fatalf("a closed team has a cap: %+v", e) + } + if f.CanNest("bbbbbbbbbbbb", defaults) { + t.Fatal("a sub-team can be made under a closed team") + } + // k's home was yard all along; with dock closed nothing changes, and a + // conversation only in harbor's tree now reports nowhere. + tidy(f.Teams) + if h, _ := f.Home("k"); h.Team != "dddddddddddd" { + t.Fatalf("home after %+v", h) + } + // A sub-team under a closed parent cannot reopen alone. + if err := f.Reopen("bbbbbbbbbbbb"); err != ErrParentClosed { + t.Fatalf("reopening under a closed parent: %v", err) + } + must(t, f.Reopen("aaaaaaaaaaaa")) + if tm, _ := f.Team("bbbbbbbbbbbb"); tm.Closed() { + t.Fatal("dock, closed by harbor's close, stayed closed") + } + if tm, _ := f.Team("cccccccccccc"); !tm.Closed() { + t.Fatal("pier, closed on its own, was reopened with harbor") + } +} + +// A CLOSED TEAM ROUND-TRIPS, AND A CONVERSATION WHOSE HOME CLOSES IS GIVEN THE +// NEXT ONE ON THE SAME WRITE. +func TestClosingMovesHomesOnTheSameWrite(t *testing.T) { + dir := t.TempDir() + f := managed() + f.Teams[0].Members = append(f.Teams[0].Members, Member{Key: "k"}) + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "k"}) + must(t, Save(dir, f.Teams)) + g, _ := Load(dir) + if h, _ := g.Home("k"); h.Team != "aaaaaaaaaaaa" { + t.Fatalf("home %+v", h) + } + must(t, Update(dir, func(f *File) error { return f.Close("aaaaaaaaaaaa", time.Time{}, "") })) + g, _ = Load(dir) + if h, _ := g.Home("k"); h.Team != "dddddddddddd" { + t.Fatalf("after the close k reports to %+v", h) + } + tm, _ := g.Team("aaaaaaaaaaaa") + if !tm.Closed() || tm.ClosedAt.IsZero() { + t.Fatalf("the close did not survive the file: %+v", tm) + } +} + +// DELETE IS ONLY FROM CLOSED, AND TAKES THE TEAM'S FILES WITH IT. +func TestDeleteOnlyAClosedTeamAndItsFiles(t *testing.T) { + dir := t.TempDir() + f := managed() + must(t, Save(dir, f.Teams)) + must(t, AppendTraffic(dir, "bbbbbbbbbbbb", Entry{Kind: KindNote, From: FromManager, To: ToEveryone, Text: "x"})) + if _, err := Delete(dir, "aaaaaaaaaaaa"); err != ErrOpen { + t.Fatalf("an open team was deleted: %v", err) + } + must(t, Update(dir, func(f *File) error { return f.Close("aaaaaaaaaaaa", time.Time{}, "") })) + gone, err := Delete(dir, "aaaaaaaaaaaa") + if err != nil || len(gone) != 3 { + t.Fatalf("delete: %v %v", gone, err) + } + g, _ := Load(dir) + if len(g.Teams) != 1 || g.Teams[0].Name != "yard" { + t.Fatalf("left %+v", g.Teams) + } + if entries, _ := ReadTraffic(dir, "bbbbbbbbbbbb", "", 0); len(entries) != 0 { + t.Fatal("a deleted team's traffic is still there") + } +} + +func must(t *testing.T, err error) { + t.Helper() + if err != nil { + t.Fatal(err) + } +} + +// writeRaw puts raw on disk as dir's teams file, exactly. +func writeRaw(t *testing.T, dir, raw string) { + t.Helper() + must(t, os.MkdirAll(dir, 0o700)) + must(t, os.WriteFile(Path(dir), []byte(raw), 0o600)) +} + +// THE GLOBAL MANAGER IS THE MANAGER OF A REAL ROOT, AND EVERY RULE HOLDS +// WITHOUT A SPECIAL CASE. Making the root moves every top-level team under it; +// parties in two trees then meet at the root instead of the person; a +// top-level manager reports to it; its override is inherited as `from All +// teams`; it is not a level; a team made later at the top lands under it; it +// cannot be closed; and dissolving it puts the tree back. +func TestTheRootHoldsEveryTeamAndIsNotALevel(t *testing.T) { + f := managed() + f.Teams[1].Members = []Member{{Key: "d1"}} + f.Teams[3].Members = append(f.Teams[3].Members, Member{Key: "y1"}) + if _, ok := f.LCA("d1", "y1"); ok { + t.Fatal("two trees met before there was a root") + } + root := f.MakeRoot(time.Time{}) + must(t, f.AddMember(root, Member{Key: "gm"})) + must(t, f.SetManager(root, "gm")) + must(t, f.SetSettings(root, func(s *Settings) { s.CapUSDDay = ptrF(20) })) + tidy(f.Teams) + if lca, ok := f.LCA("d1", "y1"); !ok || lca.ID != root { + t.Fatalf("two trees meet at %v %v, want the root", lca.Name, ok) + } + if h, _ := f.Home("hm"); h.Team != root { + t.Fatalf("harbor's manager reports to %+v, want the root", h) + } + if e := f.Effective("cccccccccccc", defaults); e.CapUSDDay != 20 || e.CapFrom.Words() != "from All teams" { + t.Fatalf("the root's cap: %+v", e) + } + if f.Depth(root) != 0 || f.Depth("aaaaaaaaaaaa") != 1 || f.Depth("cccccccccccc") != 3 { + t.Fatal("the root counted as a level") + } + f.Teams = append(f.Teams, Team{ID: "eeeeeeeeeeee", Name: "late"}) + tidy(f.Teams) + if late, _ := f.Team("eeeeeeeeeeee"); late.Parent != root { + t.Fatal("a team made later at the top did not land under the root") + } + if err := f.Close(root, time.Time{}, ""); err != ErrRoot { + t.Fatalf("the root closed: %v", err) + } + if err := f.SetParent(root, "aaaaaaaaaaaa"); err != ErrRoot { + t.Fatalf("the root moved under a team: %v", err) + } + f.DissolveRoot() + if _, ok := f.Root(); ok { + t.Fatal("the root survived its dissolving") + } + if tm, _ := f.Team("aaaaaaaaaaaa"); tm.Parent != "" { + t.Fatal("harbor was not put back at the top") + } +} + +// ORGANIZE'S QUIET TEAMS: a team nobody touched in the window and with no +// packet waiting is proposed; one with a recent Traffic line, a recently +// written member, or a waiting packet is not; neither is a closed team. +func TestQuietTeamsAreProposedAndBusyOnesAreNot(t *testing.T) { + dir := t.TempDir() + old := time.Now().Add(-30 * 24 * time.Hour) + fresh := filepath.Join(dir, "fresh.jsonl") + must(t, os.WriteFile(fresh, []byte("x"), 0o600)) + stale := filepath.Join(dir, "stale.jsonl") + must(t, os.WriteFile(stale, []byte("x"), 0o600)) + must(t, os.Chtimes(stale, old, old)) + must(t, Save(dir, []Team{ + {ID: "aaaaaaaaaaaa", Name: "quiet", Made: old, Members: []Member{{Key: stale}}}, + {ID: "bbbbbbbbbbbb", Name: "talking", Made: old}, + {ID: "cccccccccccc", Name: "writing", Made: old, Members: []Member{{Key: fresh}}}, + {ID: "dddddddddddd", Name: "asked", Made: old, Manager: "m", Members: []Member{{Key: "m", Handle: "boss"}}}, + {ID: "eeeeeeeeeeee", Name: "closed", Made: old, State: TeamClosed, ClosedAt: old}, + })) + must(t, AppendTraffic(dir, "bbbbbbbbbbbb", Entry{Kind: KindNote, From: FromManager, To: ToEveryone, Text: "hi"})) + _, err := Raise(dir, Packet{Team: Person, Origin: "dddddddddddd", Kind: PacketQuestion, RaisedBy: "boss", Question: "?"}) + must(t, err) + f, _ := Load(dir) + quiet, err := Quiet(dir, f, time.Now(), QuietAfter) + if err != nil || len(quiet) != 1 || quiet[0] != "aaaaaaaaaaaa" { + t.Fatalf("quiet teams %v, %v", quiet, err) + } +} diff --git a/internal/teams/digest.go b/internal/teams/digest.go new file mode 100644 index 0000000000..6c658b0a58 --- /dev/null +++ b/internal/teams/digest.go @@ -0,0 +1,194 @@ +package teams + +import ( + "fmt" + "strconv" + "strings" + "time" + "unicode/utf8" +) + +// The digest is what a team's manager is told about its team at the top of a +// turn: who is in it, what each member is doing, and the last few lines of +// Traffic. It is plain text cut to a character budget, and it is built only +// from what the caller hands in, so the same inputs always give the same text. + +// Member states a caller reports in [MemberState]. +const ( + StateRunning = "running" + StateIdle = "idle" + StateAsking = "asking" + StateFinished = "finished" + StateFailed = "failed" +) + +// MemberState is what the caller knows about one member right now. Every +// field may be left empty. +type MemberState struct { + // State is one of the State constants. + State string + // SinceActive is how long ago the member last did anything; 0 is not + // known. + SinceActive time.Duration + // Question is the question the member is waiting on a person for, if any. + Question string + // Files are the files the member has touched. + Files []string + // ReportsTo is the name of the team whose manager this member reports to + // when that is not this team (home.go): a shared member, which this + // team's manager may read and send a note to, and not direct. A shared + // member that is running is drawn busy for that team. + ReportsTo string +} + +// Digest limits. +const ( + digestTraffic = 20 // the most Traffic lines shown + digestFiles = 5 // the most files named per member + digestQuestion = 160 // characters of a waiting question + digestText = 200 // characters of one Traffic line's text +) + +// Digest is the text block for team's manager. states is keyed by conversation +// key; recent is Traffic, oldest first, of which the newest lines that fit are +// shown. The members always come before any Traffic line; Traffic is cut from +// the oldest end first, and a digest whose members alone do not fit is cut at +// the budget with a closing "…". A budget of 0 or less is no limit. +func Digest(team Team, states map[string]MemberState, recent []Entry, budget int) string { + var head strings.Builder + manager := "no manager" + if m, ok := team.Member(team.Manager); ok { + manager = "manager " + address(m) + } + fmt.Fprintf(&head, "Team %q: %d members, %s.\n", team.Name, len(team.Members), manager) + for _, m := range team.Members { + head.WriteString(memberLine(m, states[m.Key], m.Key == team.Manager)) + head.WriteByte('\n') + } + text := head.String() + if budget > 0 && utf8.RuneCountInString(text) > budget { + return cutRunes(text, budget) + } + + if len(recent) > digestTraffic { + recent = recent[len(recent)-digestTraffic:] + } + const title = "Recent traffic:\n" + left := budget - utf8.RuneCountInString(text) - utf8.RuneCountInString(title) + var lines []string + for i := len(recent) - 1; i >= 0; i-- { + line := trafficLine(recent[i]) + "\n" + n := utf8.RuneCountInString(line) + if budget > 0 && n > left { + break + } + left -= n + lines = append(lines, line) + } + if len(lines) == 0 { + return text + } + var b strings.Builder + b.WriteString(text) + b.WriteString(title) + for i := len(lines) - 1; i >= 0; i-- { + b.WriteString(lines[i]) + } + return b.String() +} + +// address is how a member is named in the digest: @handle, or its key while +// it has no handle. +func address(m Member) string { + if m.Handle != "" { + return "@" + m.Handle + } + return "[" + m.Key + "]" +} + +func memberLine(m Member, s MemberState, manager bool) string { + var b strings.Builder + b.WriteString("- " + address(m)) + if manager { + b.WriteString(" (manager)") + } + if title := oneLine(m.Word); title != "" { + fmt.Fprintf(&b, " %q", title) + } + state := s.State + if state == "" { + state = "unknown" + } + if s.ReportsTo != "" && state == StateRunning { + state = "busy for " + s.ReportsTo + } + b.WriteString(": " + state) + if s.ReportsTo != "" { + b.WriteString(", reports to " + s.ReportsTo) + } + if s.SinceActive > 0 { + b.WriteString(", active " + ago(s.SinceActive)) + } + if q := oneLine(s.Question); q != "" { + fmt.Fprintf(&b, ". Asking: %q", cutRunes(q, digestQuestion)) + } + if len(s.Files) > 0 { + shown := s.Files + if len(shown) > digestFiles { + shown = shown[:digestFiles] + } + b.WriteString(". Files: " + strings.Join(shown, ", ")) + if more := len(s.Files) - len(shown); more > 0 { + b.WriteString(" +" + strconv.Itoa(more) + " more") + } + } + return b.String() +} + +func trafficLine(e Entry) string { + to := e.To + if e.To == ToSeveral { + to = strings.Join(e.Handles, ",") + } + line := fmt.Sprintf("- %s %s %s -> %s: %s", e.At.Format("15:04"), e.Kind, e.From, to, + cutRunes(oneLine(e.Text), digestText)) + if len(e.Files) > 0 { + line += " [" + strings.Join(e.Files, ", ") + "]" + } + return line +} + +// ago is a duration as a COARSE age: "within the hour", "2h ago", "3d ago". +// +// IT MOVES AT MOST ONCE AN HOUR, and that is the point. The digest rides a +// manager's turn as a note that lands again only when its text moves, and a +// note that lands again is a message the manager's transcript carries for the +// rest of its life (session's landNoteLocked: an append, never a rewrite, for +// the prompt cache). An age counted in minutes moved the text every minute, +// so a manager asked twice in five minutes paid for its whole team twice with +// nothing changed. Nobody running a team needs to know "3m" from "7m". +func ago(d time.Duration) string { + switch { + case d < time.Hour: + return "within the hour" + case d < 48*time.Hour: + return strconv.Itoa(int(d/time.Hour)) + "h ago" + } + return strconv.Itoa(int(d/(24*time.Hour))) + "d ago" +} + +// oneLine is s with its whitespace runs, newlines included, made single +// spaces. +func oneLine(s string) string { return strings.Join(strings.Fields(s), " ") } + +// cutRunes is s cut to n characters, the last of them "…" when it was cut. +func cutRunes(s string, n int) string { + if utf8.RuneCountInString(s) <= n { + return s + } + if n <= 0 { + return "" + } + r := []rune(s) + return string(r[:n-1]) + "…" +} diff --git a/internal/teams/digest_test.go b/internal/teams/digest_test.go new file mode 100644 index 0000000000..37b3e884c7 --- /dev/null +++ b/internal/teams/digest_test.go @@ -0,0 +1,84 @@ +package teams + +import ( + "fmt" + "strings" + "testing" + "time" + "unicode/utf8" +) + +func digestTeam() Team { + return Team{ID: "t1", Name: "harbor", Manager: "m", Members: []Member{ + {Key: "m", Word: "Harbor manager", Handle: "lead"}, + {Key: "a", Word: "Fix the login bug", Handle: "fix-login"}, + {Key: "b", Word: "Write the docs", Handle: "docs"}, + {Key: "c"}, + }} +} + +func trafficFixture(n int) []Entry { + var out []Entry + at := time.Date(2026, 9, 24, 9, 0, 0, 0, time.UTC) + for i := 1; i <= n; i++ { + out = append(out, Entry{ID: fmt.Sprintf("%012d", i), At: at.Add(time.Duration(i) * time.Minute), + Kind: KindNote, From: "fix-login", To: ToManager, Text: fmt.Sprintf("line %d", i)}) + } + return out +} + +func TestDigestContent(t *testing.T) { + states := map[string]MemberState{ + "a": {State: StateAsking, SinceActive: 3 * time.Minute, Question: "Which\ndatabase?", + Files: []string{"a.go", "b.go", "c.go", "d.go", "e.go", "f.go", "g.go"}}, + "b": {State: StateFinished, SinceActive: 26 * time.Hour}, + } + recent := trafficFixture(3) + recent[2].Files = []string{"auth/login.go"} + got := Digest(digestTeam(), states, recent, 0) + for _, want := range []string{ + `Team "harbor": 4 members, manager @lead.`, + `- @lead (manager) "Harbor manager": unknown`, + `- @fix-login "Fix the login bug": asking, active within the hour. Asking: "Which database?". Files: a.go, b.go, c.go, d.go, e.go +2 more`, + `- @docs "Write the docs": finished, active 26h ago`, + `- [c]: unknown`, + "Recent traffic:\n- 09:01 note fix-login -> manager: line 1\n", + `- 09:03 note fix-login -> manager: line 3 [auth/login.go]`, + } { + if !strings.Contains(got, want) { + t.Fatalf("the digest lacks %q:\n%s", want, got) + } + } + // The same inputs give the same text. + if again := Digest(digestTeam(), states, recent, 0); again != got { + t.Fatal("the digest is not deterministic") + } +} + +// THE BUDGET CUTS TRAFFIC FROM THE OLDEST END, and never the members, until +// the members alone do not fit. +func TestDigestBudget(t *testing.T) { + team := digestTeam() + full := Digest(team, nil, trafficFixture(40), 0) + if strings.Contains(full, "manager: line 20\n") || !strings.Contains(full, "manager: line 21\n") || !strings.Contains(full, "manager: line 40\n") { + t.Fatalf("more than the last twenty lines were shown:\n%s", full) + } + members := Digest(team, nil, nil, 0) + budget := utf8.RuneCountInString(members) + 200 + cut := Digest(team, nil, trafficFixture(40), budget) + if n := utf8.RuneCountInString(cut); n > budget { + t.Fatalf("%d characters over a budget of %d", n, budget) + } + if !strings.HasPrefix(cut, members) || !strings.Contains(cut, "line 40\n") || strings.Contains(cut, "line 21\n") { + t.Fatalf("the cut kept the wrong lines:\n%s", cut) + } + // Too small for the members: cut at the budget, marked. + tiny := Digest(team, nil, trafficFixture(3), 30) + if utf8.RuneCountInString(tiny) != 30 || !strings.HasSuffix(tiny, "…") { + t.Fatalf("a tiny budget gave %q", tiny) + } + // Exactly the members: no traffic heading hanging on its own. + if exact := Digest(team, nil, trafficFixture(3), utf8.RuneCountInString(members)); exact != members { + t.Fatalf("a members-only budget gave:\n%s", exact) + } +} diff --git a/internal/teams/doc.go b/internal/teams/doc.go new file mode 100644 index 0000000000..5cb1938166 --- /dev/null +++ b/internal/teams/doc.go @@ -0,0 +1,38 @@ +// Package teams is the one store for teams: named sets of conversations, the +// file they live in, each member's short handle, a team's manager and the +// Traffic log a team's members and manager write to. The conversations view +// (internal/tui3) and the team tools a model calls (internal/session) both read +// and write through it, so the two never keep two accounts of one team. +// +// THE MODEL. A team has a random id minted once, a name the person gave it, at +// most one parent team, an ordered list of members and at most one manager. A +// member is a conversation, known by its conversation key, with enough beside +// the key (its file, workspace and title) to open it again. A conversation may +// be in any number of teams. Everything that names a team names it by id, +// never by its place in the list or by its name. +// +// THE LAWS. +// +// - The file is <profile>/teams.json, resolved with [config.ProfilePath], so +// an empty profile directory is the ordinary launch and means this +// process's own profile, never "no profile". It is never config.json. +// - A missing file is no teams and no error. A file that is there but +// unreadable is an error, and nothing here overwrites it: [SetAside] moves +// it out of the way when the caller decides to start again. +// - Every field a later build wrote survives a load and a save. +// - A chain of parents never loops, and a parent always exists. +// - A handle is lowercase, 2 to 12 characters, unique within its team, +// derived from the member's title once and never changed automatically. +// - The manager is always a member. Removing it from the team clears it. +// - Every write is a read-modify-write under an exclusive file lock +// ([Update]), so two processes writing the same file never lose each +// other's change. Reading takes no lock and never waits. +// - The Traffic log is append-only JSON lines, one file per team, rotated +// once past a few megabytes. +// +// WHAT THIS PACKAGE DOES NOT KNOW. It imports neither the interface nor the +// session. A team's colour is kept here as data (a hue angle and a tier) with +// the pure arithmetic that spaces colours apart; which hues a palette reserves +// for meaning is the caller's to say. The live state of a member (running, +// asking, finished) is the caller's too, handed to [Digest] as [MemberState]. +package teams diff --git a/internal/teams/handle.go b/internal/teams/handle.go new file mode 100644 index 0000000000..992366a75e --- /dev/null +++ b/internal/teams/handle.go @@ -0,0 +1,317 @@ +package teams + +import ( + "errors" + "fmt" + "strconv" + "strings" +) + +// A handle is how a member is named inside its team, in the Traffic log and to +// the team tools: ONE lowercase word that names what the conversation is about +// (@security, @milestones, @gravity), short enough to type and stable enough to +// refer back to. +// +// IT IS CHOSEN TWICE, ONCE AT ONCE AND ONCE WELL. The word list here +// ([DeriveHandle]) guesses one the moment the member has a title, so the member +// is addressable at once. The conversation's own title model then chooses the +// word, once, when the conversation's title is made (internal/session's +// handlepick.go), through [File.ChooseHandle]; the manager and the members are +// told of the change in the Traffic log. A word list cannot tell a subject from +// the kind of work done to it, and the first handles made from real titles were +// @review, @reviewing and @session. +// +// A HANDLE A PERSON OR THE MANAGER GAVE IS NEVER REPLACED ([HandleByTyped]), +// and a handle the model chose is not chosen again, so a line in the log keeps +// meaning the member it meant. +// +// A member that joins before its conversation has a title has no handle yet; it +// takes one the first time it is saved with a title. + +// Who chose a member's handle ([Member.HandleBy]). +const ( + HandleByWords = "words" // the word list's instant guess ([DeriveHandle]) + HandleByModel = "model" // the title model's word ([File.ChooseHandle]) + HandleByTyped = "typed" // given by a person or the manager; never replaced +) + +// HandleDerived reports whether m's handle is the word list's guess, which the +// title model may replace once ([File.ChooseHandle]). A handle written before +// [Member.HandleBy] was kept reads as one: the only handles then were derived, +// but for the manager's own starts, which it names again the same way. +func (m Member) HandleDerived() bool { + return m.HandleBy == "" || m.HandleBy == HandleByWords +} + +// Handle lengths, in characters. +const ( + HandleMin = 2 + HandleMax = 12 +) + +// Reserved addresses are words the Traffic log uses for someone who is not a +// member, so no member may take one as its handle. +var reservedHandles = map[string]bool{ + FromManager: true, FromYou: true, FromSystem: true, ToEveryone: true, ToRoom: true, +} + +// stopWords are dropped when a handle is derived from a title. +var stopWords = map[string]bool{ + "a": true, "an": true, "the": true, "and": true, "or": true, "but": true, + "of": true, "to": true, "in": true, "on": true, "for": true, "with": true, + "at": true, "by": true, "from": true, "into": true, "about": true, "as": true, + "is": true, "are": true, "be": true, "it": true, "this": true, "that": true, + "my": true, "our": true, "your": true, "its": true, "please": true, + "can": true, "could": true, "would": true, "should": true, "will": true, + "i": true, "we": true, "you": true, "me": true, "us": true, "let": true, + "lets": true, "some": true, "how": true, "what": true, "why": true, +} + +// ValidHandle says what is wrong with h as a handle, or nil. A handle is +// lowercase letters, digits and hyphens, starts with a letter or digit, is +// HandleMin to HandleMax characters, and is not a reserved address. +func ValidHandle(h string) error { + if err := handleShape(h); err != nil { + return err + } + if reservedHandles[h] { + return fmt.Errorf("%s is reserved", h) + } + return nil +} + +// handleShape is [ValidHandle] without the reserved words. +func handleShape(h string) error { + if len(h) < HandleMin || len(h) > HandleMax { + return fmt.Errorf("a handle is %d to %d characters", HandleMin, HandleMax) + } + for i, r := range h { + switch { + case r >= 'a' && r <= 'z', r >= '0' && r <= '9': + case r == '-' && i > 0: + default: + return errors.New("a handle is lowercase letters, digits and hyphens") + } + } + return nil +} + +// handleProblem says why h cannot be the handle of the member with key in t. +func handleProblem(t Team, key, h string) error { + if err := ValidHandle(h); err != nil { + return err + } + for _, m := range t.Members { + if m.Key != key && m.Handle == h { + return fmt.Errorf("%s is already the handle of another member", h) + } + } + return nil +} + +// fillerWords are words a title is made of that name no piece of work: the +// verbs a person opens a request with (checking, review, fix), and the words +// nearly every title on one machine shares (codeaf, repo, agent). A handle made +// of one of them says nothing about which conversation it is, which is what the +// first handles made from real titles were: @checking, @review, @agent. +var fillerWords = map[string]bool{ + "check": true, "checking": true, "checked": true, "checks": true, + "review": true, "reviewing": true, "reviewed": true, "reviews": true, + "look": true, "looking": true, "see": true, "tell": true, "show": true, + "help": true, "helping": true, "try": true, "trying": true, "want": true, "need": true, + "make": true, "making": true, "get": true, "getting": true, "do": true, "doing": true, + "run": true, "running": true, "find": true, "finding": true, "add": true, "adding": true, + "fix": true, "fixing": true, "refactor": true, "refactoring": true, + "update": true, "updating": true, "write": true, "writing": true, + "explain": true, "explaining": true, "investigate": true, "investigating": true, + "debug": true, "debugging": true, "happening": true, "going": true, + "agent": true, "agents": true, "chat": true, "conversation": true, "question": true, + "codeaf": true, "code": true, "repo": true, "repository": true, "project": true, + "thing": true, "things": true, "stuff": true, "work": true, "task": true, + "new": true, "hey": true, "hi": true, "hello": true, "whats": true, + "here": true, "there": true, "now": true, "just": true, "also": true, "again": true, +} + +// genericHeads are nouns that end a title without saying what it is about: in +// "Fix the login bug" the bug is not the subject, the login is, and in "lexer +// rewrite" the rewrite is what is done to the lexer. +var genericHeads = map[string]bool{ + "bug": true, "bugs": true, "issue": true, "issues": true, "problem": true, + "problems": true, "error": true, "errors": true, "support": true, + "rewrite": true, "sweep": true, "cleanup": true, "pass": true, "audit": true, + "change": true, "changes": true, "plan": true, "notes": true, "draft": true, + "overview": true, "summary": true, "polish": true, "tweaks": true, "wip": true, +} + +// handleWordMin is the shortest word a handle is made of on its own. A shorter +// one is a fragment ("can you te" gave @te) or a qualifier, and a qualifier +// only ever rides in front of the word it qualifies (@qa-binary, @api-docs). +const handleWordMin = 3 + +// DeriveHandle is the handle a title suggests, before collisions and reserved +// words are taken into account. +// +// IT IS THE TITLE'S HEAD NOUN, as nearly as a word list can find it: the last +// word that is not a function word, a filler word ([fillerWords]) or a +// fragment, because an English title names its subject last ("checking codeaf +// branches for qa binary" is about the binary). A generic last word ("bug", +// "support") gives way to the one before it. A short qualifier right in front +// of the head rides with it when both fit (@qa-binary, @api-docs). The result +// is lowercased and cut to HandleMax. A title with no usable word gives "chat"; +// an empty title gives "". +func DeriveHandle(title string) string { + if strings.TrimSpace(title) == "" { + return "" + } + words := strings.FieldsFunc(strings.ToLower(title), func(r rune) bool { + return !(r >= 'a' && r <= 'z' || r >= '0' && r <= '9') + }) + usable := func(w string) bool { + return !stopWords[w] && !fillerWords[w] && strings.Trim(w, "0123456789") != "" + } + head := -1 + for i := len(words) - 1; i >= 0; i-- { + w := words[i] + if len(w) < handleWordMin || !usable(w) { + continue + } + if head < 0 { + head = i + } + if !genericHeads[w] { + head = i + break + } + } + if head < 0 { + return "chat" + } + base := words[head] + if head > 0 { + prev := words[head-1] + if len(prev) >= HandleMin && len(prev) <= handleWordMin && usable(prev) && len(prev)+1+len(base) <= HandleMax { + base = prev + "-" + base + } + } + base = cutHandle(base, HandleMax) + if handleShape(base) != nil { + return "chat" + } + return base +} + +// cutHandle is h cut to n characters with no hyphen left at the end. +func cutHandle(h string, n int) string { + if len(h) > n { + h = h[:n] + } + return strings.TrimRight(h, "-") +} + +// uniqueHandle is base, or base with the lowest number from 2 that no member +// of t other than key uses, cut so the whole stays within HandleMax. +func uniqueHandle(t Team, key, base string) string { + if handleProblem(t, key, base) == nil { + return base + } + for n := 2; ; n++ { + suffix := strconv.Itoa(n) + h := cutHandle(base, HandleMax-len(suffix)) + suffix + if handleProblem(t, key, h) == nil { + return h + } + } +} + +// assignHandles clears every handle in t that is invalid or repeats one an +// earlier member has, then gives each member with a title and no handle one, +// in member order. It reports whether it changed anything. +func assignHandles(t *Team) bool { + changed := false + seen := map[string]bool{} + for i := range t.Members { + h := t.Members[i].Handle + if h == "" { + continue + } + if ValidHandle(h) != nil || seen[h] { + t.Members[i].Handle = "" + changed = true + continue + } + seen[h] = true + } + for i := range t.Members { + m := &t.Members[i] + if m.Handle != "" { + continue + } + base := DeriveHandle(m.Word) + if base == "" { + continue + } + m.Handle, m.HandleBy = uniqueHandle(*t, m.Key, base), HandleByWords + changed = true + } + return changed +} + +// ChooseHandle gives the member with key in team id the title model's word: +// the first of choices, best first, that no other member of the team has. +// When every choice is taken, the first is qualified by a word of the title in +// front of it (@api-security), as [DeriveHandle] qualifies; only when nothing +// fits is it numbered. old is the handle the member had and now the one it has; +// a member whose handle was given ([HandleByTyped]) or already chosen by the +// model keeps it, and so does a member whose handle is already the choice. +func (f *File) ChooseHandle(id, key string, choices []string, title string) (old, now string, err error) { + i, err := f.at(id) + if err != nil { + return "", "", err + } + t := &f.Teams[i] + j := t.member(key) + if j < 0 { + return "", "", fmt.Errorf("%s is not in team %s", key, t.Name) + } + m := &t.Members[j] + old = m.Handle + if !m.HandleDerived() && m.Handle != "" { + return old, old, nil + } + var usable []string + for _, c := range choices { + if ValidHandle(c) == nil && !strings.Contains(c, "-") { + usable = append(usable, c) + } + } + if len(usable) == 0 { + return old, old, errors.New("no usable handle among the choices") + } + now = pickHandle(*t, key, usable, title) + m.Handle, m.HandleBy = now, HandleByModel + return old, now, nil +} + +// pickHandle is the first free choice, else the first qualified by a title +// word, else the first numbered. +func pickHandle(t Team, key string, choices []string, title string) string { + for _, c := range choices { + if handleProblem(t, key, c) == nil { + return c + } + } + words := strings.FieldsFunc(strings.ToLower(title), func(r rune) bool { + return !(r >= 'a' && r <= 'z' || r >= '0' && r <= '9') + }) + for _, c := range choices { + for _, q := range words { + if q == c || len(q) < handleWordMin || stopWords[q] || fillerWords[q] || strings.Trim(q, "0123456789") == "" { + continue + } + if h := q + "-" + c; len(h) <= HandleMax && handleProblem(t, key, h) == nil { + return h + } + } + } + return uniqueHandle(t, key, choices[0]) +} diff --git a/internal/teams/handle_test.go b/internal/teams/handle_test.go new file mode 100644 index 0000000000..2ff9ce8192 --- /dev/null +++ b/internal/teams/handle_test.go @@ -0,0 +1,236 @@ +package teams + +import ( + "strings" + "testing" +) + +func TestDeriveHandle(t *testing.T) { + for title, want := range map[string]string{ + "": "", + " ": "", + "Refactor the parser": "parser", + "Fix the login bug": "login", + "The API docs": "api-docs", + "Add OAuth2 support": "oauth2", + "Internationalization pipeline": "pipeline", + "Internationalization": "internationa", + "a the of": "chat", + "日本語": "chat", + "x": "chat", + "Port: codeaf -> linux/arm64": "arm64", + "Can you help me with benchmarks": "benchmarks", + "release 2026": "release", + "lexer rewrite": "lexer", + "benchmark sweep": "benchmark", + } { + got := DeriveHandle(title) + if got != want { + t.Errorf("DeriveHandle(%q) = %q, want %q", title, got, want) + } + if got != "" && ValidHandle(got) != nil { + t.Errorf("DeriveHandle(%q) = %q is not valid: %v", title, got, ValidHandle(got)) + } + } +} + +// THE TITLES THAT GAVE @checking, @review, @agent AND @te, as they were on the +// machine where a team of them was first made. Each handle names what the +// conversation is about, none is a filler word or a two-letter fragment, and +// the team's handles are all different. +func TestHandlesFromRealTitlesNameTheWork(t *testing.T) { + titles := map[string]string{ + "checking codeaf branches for qa binary": "qa-binary", + "review santosh dev2 branch code complexity security": "security", + "reviewing codeaf repo issue tags and milestones": "milestones", + "agent native user journey automated testing": "testing", + "can you te": "chat", + } + tm := Team{ID: "t"} + for title, want := range titles { + got := DeriveHandle(title) + if got != want { + t.Errorf("DeriveHandle(%q) = %q, want %q", title, got, want) + } + if want != "chat" && (fillerWords[got] || len(got) < handleWordMin) { + t.Errorf("DeriveHandle(%q) = %q, a filler word or a fragment", title, got) + } + tm.Members = append(tm.Members, Member{Key: title, Word: title}) + } + assignHandles(&tm) + seen := map[string]bool{} + for _, m := range tm.Members { + if seen[m.Handle] { + t.Fatalf("two members of one team were given @%s", m.Handle) + } + seen[m.Handle] = true + } +} + +func TestHandleCollisionsAreNumberedWithinTheLimit(t *testing.T) { + tm := Team{ID: "t"} + for i := 0; i < 12; i++ { + tm.Members = append(tm.Members, Member{Key: string(rune('a' + i)), Word: "Internationalization"}) + } + assignHandles(&tm) + seen := map[string]bool{} + for i, m := range tm.Members { + if ValidHandle(m.Handle) != nil || seen[m.Handle] { + t.Fatalf("member %d has handle %q", i, m.Handle) + } + seen[m.Handle] = true + } + if tm.Members[0].Handle != "internationa" || tm.Members[1].Handle != "internation2" || tm.Members[11].Handle != "internatio12" { + t.Fatalf("handles %+v", tm.Members) + } + // A reserved word is never a handle, even when a title suggests one. + tm = Team{ID: "t", Members: []Member{{Key: "m", Word: "Manager"}}} + assignHandles(&tm) + if tm.Members[0].Handle != "manager2" { + t.Fatalf("a title of Manager gave %q", tm.Members[0].Handle) + } +} + +func TestSetHandleValidates(t *testing.T) { + f := &File{Teams: []Team{{ID: "t1", Members: []Member{{Key: "a", Word: "alpha"}, {Key: "b", Word: "beta"}}}}} + tidy(f.Teams) + for h, why := range map[string]string{ + "beta": "another member's handle", + "b": "too short", + "thirteenchars": "too long", + "Alpha": "upper case", + "al pha": "a space", + "-alpha": "a leading hyphen", + "everyone": "a reserved address", + } { + if err := f.SetHandle("t1", "a", h); err == nil { + t.Errorf("%q (%s) was accepted", h, why) + } + } + if err := f.SetHandle("t1", "a", "alpha"); err != nil { + t.Fatalf("a member's own handle again: %v", err) + } + if err := f.SetHandle("t1", "a", "lead-1"); err != nil { + t.Fatal(err) + } + if m, ok := f.Teams[0].ByHandle("lead-1"); !ok || m.Key != "a" { + t.Fatalf("by handle: %+v %v", m, ok) + } + if err := f.SetHandle("t1", "zz", "free"); err == nil || !strings.Contains(err.Error(), "not in team") { + t.Fatalf("a stranger's handle: %v", err) + } +} + +// A FILE WITH A REPEATED OR BROKEN HANDLE IS PUT RIGHT: the first keeps it, +// and a later one is given a fresh one. +func TestRepairClearsRepeatedAndInvalidHandles(t *testing.T) { + tm := Team{ID: "t", Members: []Member{ + {Key: "a", Word: "alpha", Handle: "lead"}, + {Key: "b", Word: "beta", Handle: "lead"}, + {Key: "c", Word: "gamma", Handle: "NOT VALID"}, + {Key: "d", Word: "delta", Handle: "fine"}, + }} + if !assignHandles(&tm) { + t.Fatal("the repair reported no change") + } + var got []string + for _, m := range tm.Members { + got = append(got, m.Handle) + } + if strings.Join(got, ",") != "lead,beta,gamma,fine" { + t.Fatalf("handles %v", got) + } + if assignHandles(&tm) { + t.Fatal("a second repair changed something") + } +} + +// THE TITLE MODEL CHOOSES THE WORD, AND THE STORE KEEPS THE RULES. The three +// titles the manager had made @review, @reviewing and @session of, each given +// the word a model answers for it: each member takes its word, a derived +// handle is replaced once and marked as the model's, and a second choice is +// never asked for again. +func TestChooseHandleTakesTheModelsWord(t *testing.T) { + f := &File{Teams: []Team{{ID: "t1", Name: "test"}}} + titles := map[string]string{ + "a": "santosh dev2 branch code complexity & security review", + "b": "CodeAF repo issue tags & milestones", + "c": "quantum gravity research updates / session monitor", + } + legacy := map[string]string{"a": "review", "b": "reviewing", "c": "session"} + for _, key := range []string{"a", "b", "c"} { + // Written by a build that did not keep who chose: read as derived. + f.Teams[0].Members = append(f.Teams[0].Members, Member{Key: key, Word: titles[key], Handle: legacy[key]}) + } + model := map[string][]string{"a": {"security"}, "b": {"milestones"}, "c": {"gravity"}} + for _, key := range []string{"a", "b", "c"} { + old, now, err := f.ChooseHandle("t1", key, model[key], titles[key]) + if err != nil { + t.Fatal(err) + } + if old != legacy[key] || now != model[key][0] { + t.Errorf("%s: %q -> %q, want %q -> %q", key, old, now, legacy[key], model[key][0]) + } + m, _ := f.Teams[0].Member(key) + if m.Handle != now || m.HandleBy != HandleByModel || m.HandleDerived() { + t.Errorf("%s: stored %+v", key, m) + } + } + // Chosen once: a later answer changes nothing. + if old, now, _ := f.ChooseHandle("t1", "a", []string{"complexity"}, titles["a"]); old != "security" || now != "security" { + t.Errorf("a chosen handle was chosen again: %q -> %q", old, now) + } +} + +// A CLASH TAKES THE SECOND CHOICE, THEN A QUALIFIER, NEVER A DIGIT SOUP; and a +// handle given by a person or the manager is never replaced. +func TestChooseHandleClashesAndTypedHandles(t *testing.T) { + f := &File{Teams: []Team{{ID: "t1", Name: "test"}}} + if err := f.AddMember("t1", Member{Key: "sec", Word: "security audit", Handle: "security"}); err != nil { + t.Fatal(err) + } + if m, _ := f.Teams[0].Member("sec"); m.HandleBy != HandleByTyped { + t.Fatalf("a handle that arrived with its member is not typed: %+v", m) + } + if err := f.AddMember("t1", Member{Key: "b", Word: "api token security"}); err != nil { + t.Fatal(err) + } + if m, _ := f.Teams[0].Member("b"); m.HandleBy != HandleByWords || !m.HandleDerived() { + t.Fatalf("a guessed handle is not marked the word list's: %+v", m) + } + if _, now, _ := f.ChooseHandle("t1", "b", []string{"security", "tokens"}, "api token security"); now != "tokens" { + t.Errorf("second choice: got %q", now) + } + if err := f.AddMember("t1", Member{Key: "c", Word: "oauth token security"}); err != nil { + t.Fatal(err) + } + _, now, _ := f.ChooseHandle("t1", "c", []string{"security", "tokens"}, "oauth token security") + // "oauth-security" is past HandleMax, so the second choice is qualified. + if now != "oauth-tokens" { + t.Errorf("qualified: got %q", now) + } + if strings.IndexAny(now, "0123456789") >= 0 { + t.Errorf("a digit in %q", now) + } + // The typed one is kept whatever the model says. + if old, now, _ := f.ChooseHandle("t1", "sec", []string{"audit"}, "security audit"); old != "security" || now != "security" { + t.Errorf("a typed handle was replaced: %q -> %q", old, now) + } + if err := f.SetHandle("t1", "b", "tok"); err != nil { + t.Fatal(err) + } + if old, now, _ := f.ChooseHandle("t1", "b", []string{"jwt"}, "api token security"); now != "tok" || old != "tok" { + t.Errorf("SetHandle's handle was replaced: %q -> %q", old, now) + } + // Nothing usable changes nothing. + if err := f.AddMember("t1", Member{Key: "d", Word: "release notes draft"}); err != nil { + t.Fatal(err) + } + before, _ := f.Teams[0].Member("d") + if _, _, err := f.ChooseHandle("t1", "d", []string{"Two Words", "x", "manager"}, ""); err == nil { + t.Error("an unusable answer was taken") + } + if after, _ := f.Teams[0].Member("d"); after != before { + t.Errorf("an unusable answer changed the member: %+v", after) + } +} diff --git a/internal/teams/home.go b/internal/teams/home.go new file mode 100644 index 0000000000..b226b7de73 --- /dev/null +++ b/internal/teams/home.go @@ -0,0 +1,350 @@ +package teams + +import ( + "errors" + "fmt" +) + +// ── WHO A CONVERSATION REPORTS TO ─────────────────────────────────────────── +// +// Every conversation that sits in a team with a manager somewhere above it +// reports to exactly one manager, its HOME (ruling c-5). Its routine direction +// and its clarifying questions go there; every other manager it can be reached +// by is a LINK, who may read it and send it an fyi and nothing else. +// +// THE HOME IS STORED, NOT DERIVED ON EVERY READ, because the ruling says it +// never changes by itself: a conversation that later joins a nearer team keeps +// reporting where it did until the person moves it ([File.SetHome]). It is a +// flag on one of the conversation's memberships ([Member.Home]), and the home +// manager is the nearest manager up THAT membership's chain, the membership's +// own team first. So the flag may sit on a membership of an unmanaged team +// whose parent has a manager, which is how a conversation in an unmanaged +// sub-team reports to the manager above it without being a member there. +// +// THE FLAG IS STABLE; THE MANAGER AT THE END OF ITS CHAIN IS WHOEVER THE +// PERSON MADE MANAGER THERE. A conversation in an unmanaged sub-team reports +// to the manager above it; when the person gives that sub-team a manager, the +// same flag now resolves to the new manager, one step nearer. That is not the +// home changing by itself: making a manager is the person's act, and a +// sub-team manager nobody under it reported to would be a manager of nothing. +// +// A MANAGER IS NEVER ITS OWN HOME. Walking up from a team a conversation +// manages skips that team, so a sub-team's manager reports to the manager of +// the team above, which is the ruling's "reports one level up". +// +// tidy keeps the flag honest on every load and write: a conversation with no +// valid flag and something to report to is given one by the rules below, a +// flag with nothing above it any more (the manager was cleared, the team was +// closed or the membership removed) is taken away and picked again, and a +// second flag is dropped. The pick, in order: +// +// 1. the membership with the NEAREST manager: its own team managed before a +// manager one or more levels up, and among equals the deeper, more +// specific team first; +// 2. then the membership the manager's team_start made ([Member.Started]); +// 3. then the first in the file's order. The file keeps teams in the order +// they were made and a team's members in the order they joined, and the +// pick is made at the first write that gives a conversation somewhere to +// report, so for a conversation that joins its managed teams one at a +// time this is the team it joined first. +// +// A CLOSED TEAM IS NOT SOMEWHERE TO REPORT (lifecycle.go). A membership of a +// closed team is never a home, a closed team's manager is never found by a +// walk, and a conversation whose home closed is given the next one by the same +// rules, or none, and is then an ordinary chat. + +// Report is one manager a conversation can be reached by. +type Report struct { + // Via is the team of the membership the line runs through. + Via string `json:"via"` + // Team is the managed team whose manager this is: Via itself or an + // ancestor of it. + Team string `json:"team"` + // Manager is that manager's conversation key. + Manager string `json:"manager"` + // Distance is how many levels up from Via the manager's team is. + Distance int `json:"distance"` +} + +// ErrNoManagerAbove is [File.SetHome] asked for a membership with no manager +// anywhere up its chain. +var ErrNoManagerAbove = errors.New("teams: no manager above that team to report to") + +// Home is the manager the conversation with key reports to, false when it has +// none (it is an ordinary chat). +func (f *File) Home(key string) (Report, bool) { + for _, t := range f.Teams { + m, ok := t.Member(key) + if !ok || !m.Home || t.Closed() { + continue + } + if r, ok := managerUp(f.Teams, t.ID, key); ok { + return r, true + } + } + return Report{}, false +} + +// Links is every other manager the conversation with key can be reached by: +// the nearest manager up each of its memberships, in the pick order, each +// managed team once, the home left out. +func (f *File) Links(key string) []Report { + home, _ := f.Home(key) + seen := map[string]bool{home.Team: true} + var out []Report + for _, r := range candidates(f.Teams, key) { + if seen[r.Team] { + continue + } + seen[r.Team] = true + out = append(out, r) + } + return out +} + +// SetHome makes the membership of key in team id its home. The membership +// must exist and have a manager up its chain, else [ErrNoManagerAbove]. +func (f *File) SetHome(key, id string) error { + t, ok := f.Team(id) + if !ok { + return fmt.Errorf("no team %s", id) + } + if !t.Holds(key) { + return fmt.Errorf("%s is not in team %s", key, t.Name) + } + if _, ok := managerUp(f.Teams, id, key); !ok { + return ErrNoManagerAbove + } + setHomeFlag(f.Teams, key, id) + return nil +} + +// setHomeFlag puts key's one home flag on its membership of team id. +func setHomeFlag(teams []Team, key, id string) { + for i := range teams { + for j := range teams[i].Members { + if teams[i].Members[j].Key == key { + teams[i].Members[j].Home = teams[i].ID == id + } + } + } +} + +// managerUp is the nearest manager up from team id, id itself first, that is +// not key: the team must be open and have a manager. The walk is bounded by +// the list, so a loop cannot hang it. +func managerUp(teams []Team, id, key string) (Report, bool) { + at := id + for distance := 0; at != "" && distance <= len(teams); distance++ { + i := Index(teams, at) + if i < 0 { + return Report{}, false + } + t := teams[i] + if !t.Closed() && t.Manager != "" && t.Manager != key { + return Report{Via: id, Team: t.ID, Manager: t.Manager, Distance: distance}, true + } + at = t.Parent + } + return Report{}, false +} + +// candidate is one membership that could be a home, with what the pick order +// reads. +type candidate struct { + r Report + depth int + started bool + order int +} + +// before is the pick order between two candidates (see the file header). +func (a candidate) before(b candidate) bool { + if a.r.Distance != b.r.Distance { + return a.r.Distance < b.r.Distance + } + if a.depth != b.depth { + return a.depth > b.depth + } + if a.started != b.started { + return a.started + } + return a.order < b.order +} + +// candidates is every open membership of key with a manager up its chain, as +// a Report, in the pick order. +func candidates(teams []Team, key string) []Report { + var all []candidate + for i, t := range teams { + if t.Closed() { + continue + } + m, ok := t.Member(key) + if !ok { + continue + } + r, ok := managerUp(teams, t.ID, key) + if !ok { + continue + } + all = append(all, candidate{r: r, depth: depthIn(teams, r.Team), started: m.Started, order: i}) + } + // An insertion sort: a conversation is in a handful of teams. + for i := 1; i < len(all); i++ { + for j := i; j > 0 && all[j].before(all[j-1]); j-- { + all[j], all[j-1] = all[j-1], all[j] + } + } + out := make([]Report, len(all)) + for i, c := range all { + out[i] = c.r + } + return out +} + +// depthIn is how many levels team id stands at, 1 at the top. +func depthIn(teams []Team, id string) int { + depth := 0 + for at := id; at != "" && depth <= len(teams); depth++ { + i := Index(teams, at) + if i < 0 { + break + } + at = teams[i].Parent + } + return depth +} + +// assignHomes keeps one valid home flag for every conversation that has a +// manager to report to and none for any other, and reports whether it moved +// a flag. A valid flag is never moved. +func assignHomes(teams []Team) bool { + changed := false + done := map[string]bool{} + for _, t := range teams { + for _, m := range t.Members { + if done[m.Key] { + continue + } + done[m.Key] = true + if homeHolds(teams, m.Key) { + continue + } + want := "" + if c := candidates(teams, m.Key); len(c) > 0 { + want = c[0].Via + } + if clearOrSet(teams, m.Key, want) { + changed = true + } + } + } + return changed +} + +// homeHolds reports whether key carries exactly one home flag and it is on an +// open membership with a manager up its chain. +func homeHolds(teams []Team, key string) bool { + flags, valid := 0, false + for _, t := range teams { + m, ok := t.Member(key) + if !ok || !m.Home { + continue + } + flags++ + if !t.Closed() { + _, valid = managerUp(teams, t.ID, key) + } + } + if flags == 0 { + // No flag is right exactly when there is nothing to report to. + return len(candidates(teams, key)) == 0 + } + return flags == 1 && valid +} + +// clearOrSet leaves key's one flag on its membership of want ("" for none) and +// reports whether anything moved. A key with several flags of which one is +// valid keeps that one. +func clearOrSet(teams []Team, key, want string) bool { + for _, t := range teams { + if m, ok := t.Member(key); ok && m.Home && !t.Closed() { + if _, valid := managerUp(teams, t.ID, key); valid { + want = t.ID + break + } + } + } + changed := false + for i := range teams { + for j := range teams[i].Members { + m := &teams[i].Members[j] + if m.Key != key { + continue + } + on := want != "" && teams[i].ID == want + if m.Home != on { + m.Home, changed = on, true + } + } + } + return changed +} + +// ── WHO DECIDES BETWEEN SEVERAL ───────────────────────────────────────────── + +// LCA is the team whose manager decides between the conversations keys +// (ruling c-6): the lowest team that is at or above some membership of every +// one of them, is open, and has a manager who is not one of them. The lowest +// is the deepest; among equally deep teams the first in the file. false is +// nobody, and then the person decides. One key is that conversation's nearest +// manager, which for a conversation in one team is its home. +// +// A MANAGER WHO IS A PARTY DOES NOT JUDGE ITS OWN CASE: a team whose manager +// is one of keys is passed over for the next team up that holds them all. +func (f *File) LCA(keys ...string) (Team, bool) { + if len(keys) == 0 { + return Team{}, false + } + party := map[string]bool{} + for _, k := range keys { + party[k] = true + } + // above[k] is every team at or above one of k's open memberships. + var common map[string]bool + for _, k := range keys { + above := map[string]bool{} + for _, t := range f.Teams { + if t.Closed() || !t.Holds(k) { + continue + } + above[t.ID] = true + for _, a := range f.Ancestors(t.ID) { + above[a.ID] = true + } + } + if common == nil { + common = above + continue + } + for id := range common { + if !above[id] { + delete(common, id) + } + } + } + best, bestDepth := -1, 0 + for i, t := range f.Teams { + if !common[t.ID] || t.Closed() || t.Manager == "" || party[t.Manager] { + continue + } + if d := depthIn(f.Teams, t.ID); best < 0 || d > bestDepth { + best, bestDepth = i, d + } + } + if best < 0 { + return Team{}, false + } + return f.Teams[best], true +} diff --git a/internal/teams/hue.go b/internal/teams/hue.go new file mode 100644 index 0000000000..48227ef483 --- /dev/null +++ b/internal/teams/hue.go @@ -0,0 +1,88 @@ +package teams + +import "math" + +// A team's colour is a hue angle in OKLCH degrees and a lightness tier. The +// arithmetic here spaces a new team's hue as far as it can from every hue in +// use and from the hues a palette reserves for meaning. Turning a hue into +// something a terminal can draw, and saying which hues are reserved, belongs to +// the interface (internal/tui3/teamhue.go). + +// HueSpec is a team's colour as stored: a hue angle in degrees and a +// lightness tier, 0 or 1. +type HueSpec struct { + Hue float64 + Tier int +} + +// HueBand is how many degrees either side of a reserved hue no team may take. +const HueBand = 25 + +// HueTierFree is how many teams are all drawn at tier 0 before the tiers +// start to alternate. +const HueTierFree = 6 + +// HueGap is the distance between two hues around the circle, 0..180. +func HueGap(a, b float64) float64 { + d := math.Mod(math.Abs(a-b), 360) + if d > 180 { + d = 360 - d + } + return d +} + +// HueAllowed reports whether a hue is clear of every reserved band. +func HueAllowed(h float64, reserved []float64) bool { + for _, r := range reserved { + if HueGap(h, r) < HueBand { + return false + } + } + return true +} + +// TierFor is the tier the n-th team (from zero) is drawn at. +func TierFor(n int) int { + if n < HueTierFree { + return 0 + } + return 1 - (n-HueTierFree)%2 +} + +// NextHue is the colour for a new team beside the used ones: the allowed whole +// degree farthest from every used hue, the lowest such degree on a tie. +func NextHue(used []HueSpec, reserved []float64) HueSpec { + best, bestGap := -1.0, -1.0 + for d := 0; d < 360; d++ { + h := float64(d) + if !HueAllowed(h, reserved) { + continue + } + gap := 1000.0 + for _, u := range used { + gap = math.Min(gap, HueGap(h, u.Hue)) + } + if gap > bestGap { + best, bestGap = h, gap + } + } + if best < 0 { + best = 0 + } + return HueSpec{Hue: best, Tier: TierFor(len(used))} +} + +// HueChoices is k colours a new team could take, best first: each the +// farthest from the used hues and from the choices before it. +func HueChoices(used []HueSpec, reserved []float64, k int) []HueSpec { + tier := TierFor(len(used)) + seen := append([]HueSpec(nil), used...) + out := make([]HueSpec, 0, k) + for len(out) < k { + next := NextHue(seen, reserved) + next.Tier = tier + out = append(out, next) + seen = append(seen, next) + } + return out +} diff --git a/internal/teams/lifecycle.go b/internal/teams/lifecycle.go new file mode 100644 index 0000000000..5c009fbfd4 --- /dev/null +++ b/internal/teams/lifecycle.go @@ -0,0 +1,279 @@ +package teams + +import ( + "errors" + "fmt" + "os" + "path/filepath" + "time" + + "github.com/Agent-Field/codeaf/internal/config" +) + +// ── A TEAM IS OPEN OR CLOSED, AND ONLY A CLOSED ONE CAN BE DELETED ────────── +// +// The ruling (c-9): a team the work is done with is CLOSED, not deleted. It +// keeps its members, its Traffic, its packets and its closing report, it is +// drawn folded under `Closed · N`, and it can be reopened. Deleting forgets +// the grouping, its Traffic and its packets, and is offered only from Closed, +// so nothing that is running is ever one keystroke from gone. The +// conversations are never deleted; they stay in history. +// +// WHAT CLOSED MEANS TO THE REST OF THIS PACKAGE. A closed team is outside +// every walk: it is never anybody's home and its manager is found by no walk +// (home.go), it is never the team that decides between parties ([File.LCA]), +// its overrides are skipped by a team under it ([File.Effective]) and its own +// effective cap is none, because a closed team spends nothing. tidy re-runs +// the home rule on the same write that closes a team, so a conversation whose +// home closed reports to its next manager, or to nobody, from that write on. +// +// CLOSING CASCADES DOWN AND ONLY DOWN. Closing a team closes every open team +// under it and records which close closed them ([Team.ClosedWith]), so +// reopening the team reopens exactly those and not a sub-team the person had +// closed on its own before. A sub-team may close alone; its parent stays open. +// A team under a closed parent cannot be reopened until the parent is. +// +// THE SESSION'S WRAP-UP IS NOT HERE. What a manager does before a close (tell +// members to finish, answer what it can, write the closing report as a +// [KindClosing] packet) is internal/session's; stopping member turns and +// closing tabs is the interface's. This file is the record those two write. + +// Team states. +const ( + TeamOpen = "open" + TeamClosed = "closed" +) + +// ErrOpen is [Delete] asked to delete a team that is not closed. +var ErrOpen = errors.New("teams: only a closed team can be deleted; close it first") + +// ErrParentClosed is [File.Reopen] asked to reopen a team whose parent is +// closed. +var ErrParentClosed = errors.New("teams: its parent team is closed; reopen that first") + +// Closed reports whether the team is closed. +func (t Team) Closed() bool { return t.State == TeamClosed } + +// Descendants is every team under id, at any depth, parents before children. +func (f *File) Descendants(id string) []Team { + var out []Team + frontier := []string{id} + seen := map[string]bool{id: true} + for len(frontier) > 0 && len(out) < len(f.Teams) { + next := frontier[0] + frontier = frontier[1:] + for _, t := range f.Children(next) { + if seen[t.ID] { + continue + } + seen[t.ID] = true + out = append(out, t) + frontier = append(frontier, t.ID) + } + } + return out +} + +// Close closes team id at at, with report the id of its closing report packet +// ("" for none), and every open team under it. A team already closed is left +// as it was, and so is a sub-team already closed on its own. +func (f *File) Close(id string, at time.Time, report string) error { + i, err := f.at(id) + if err != nil { + return err + } + if f.Teams[i].Root { + return ErrRoot + } + if f.Teams[i].Closed() { + return nil + } + if at.IsZero() { + at = time.Now() + } + t := &f.Teams[i] + t.State, t.ClosedAt, t.ClosedWith, t.Report = TeamClosed, at, id, report + // A closed team has no wrap-up left to resume. + t.Wrap = nil + for _, d := range f.Descendants(id) { + j := Index(f.Teams, d.ID) + if f.Teams[j].Closed() { + continue + } + c := &f.Teams[j] + c.State, c.ClosedAt, c.ClosedWith = TeamClosed, at, id + c.Wrap = nil + } + return nil +} + +// Reopen opens team id again, and every team under it that its own close +// closed. Its closing report stays recorded; a team reopened and closed again +// gets the new one. A team whose parent is closed is [ErrParentClosed]. +func (f *File) Reopen(id string) error { + i, err := f.at(id) + if err != nil { + return err + } + if !f.Teams[i].Closed() { + return nil + } + if p := f.Teams[i].Parent; p != "" { + if parent, ok := f.Team(p); ok && parent.Closed() { + return ErrParentClosed + } + } + reopen := func(j int) { + t := &f.Teams[j] + t.State, t.ClosedAt, t.ClosedWith = "", time.Time{}, "" + } + for _, d := range f.Descendants(id) { + if d.Closed() && d.ClosedWith == id { + reopen(Index(f.Teams, d.ID)) + } + } + reopen(i) + return nil +} + +// Open is the teams that are open, in stored order. +func (f *File) Open() []Team { + var out []Team + for _, t := range f.Teams { + if !t.Closed() { + out = append(out, t) + } + } + return out +} + +// ClosedTeams is the teams that are closed, most recently closed first, for +// the folded `Closed · N` section. +func (f *File) ClosedTeams() []Team { + var out []Team + for _, t := range f.Teams { + if t.Closed() { + out = append(out, t) + } + } + for i := 1; i < len(out); i++ { + for j := i; j > 0 && out[j].ClosedAt.After(out[j-1].ClosedAt); j-- { + out[j], out[j-1] = out[j-1], out[j] + } + } + return out +} + +// TeamDir is team id's own directory, <profile>/teams/<id>, which holds its +// Traffic and its decision packets. +func TeamDir(profileDir, teamID string) string { + return config.ProfilePath(profileDir, filepath.Join("teams", teamID)) +} + +// Delete forgets closed team id and every team under it (closed with it, by +// the cascade): their entries in the teams file, then their Traffic and packet +// files. It answers the ids it deleted. A team that is open is [ErrOpen] and +// nothing is changed; so is one with an open team under it, which only a +// hand-edited file can have. The conversations are not touched. +// +// THE FILE IS WRITTEN FIRST. A crash between the two leaves directories no +// team names, which cost a few kilobytes and are harmless; the other order +// could leave a team whose Traffic was gone. +func Delete(profileDir, id string) ([]string, error) { + var gone []string + err := Update(profileDir, func(f *File) error { + t, ok := f.Team(id) + if !ok { + return fmt.Errorf("no team %s", id) + } + if !t.Closed() { + return ErrOpen + } + gone = []string{id} + for _, d := range f.Descendants(id) { + if !d.Closed() { + return ErrOpen + } + gone = append(gone, d.ID) + } + drop := map[string]bool{} + for _, g := range gone { + drop[g] = true + } + kept := f.Teams[:0:0] + for _, t := range f.Teams { + if !drop[t.ID] { + kept = append(kept, t) + } + } + f.Teams = kept + return nil + }) + if err != nil { + return nil, err + } + for _, g := range gone { + if safeTeamID(g) == nil { + _ = os.RemoveAll(TeamDir(profileDir, g)) + } + } + forgetPackets(profileDir) + return gone, nil +} + +// QuietAfter is how long a team goes without activity before Organize may +// propose closing it (ruling c-9's "about seven days"). +const QuietAfter = 7 * 24 * time.Hour + +// Quiet is every open team in f, the root aside, that Organize may propose +// closing at now: nothing in its Traffic, its packets or its members' +// transcripts for idle, and no packet waiting on it or raised from it. It is +// a proposal's input and closes nothing. It reads one Traffic line and one +// packet fold per team and stats each member's transcript, so it is asked off +// the loop, when Organize is. +func Quiet(profileDir string, f *File, now time.Time, idle time.Duration) ([]string, error) { + waiting := map[string]bool{} + open, _, err := OpenPackets(profileDir, ScopeAll) + if err != nil { + return nil, err + } + for _, p := range open { + waiting[p.Team], waiting[p.Origin] = true, true + } + cut := now.Add(-idle) + var out []string + for _, t := range f.Teams { + if t.Closed() || t.Root || waiting[t.ID] { + continue + } + if last := lastActivity(profileDir, t); last.After(cut) { + continue + } + out = append(out, t.ID) + } + return out, nil +} + +// lastActivity is the latest of team t's last Traffic line, its last packet +// change and its members' transcripts' modification times; a team with none +// of these is as old as it was made. +func lastActivity(profileDir string, t Team) time.Time { + last := t.Made + later := func(at time.Time) { + if at.After(last) { + last = at + } + } + if tail, err := ReadTraffic(profileDir, t.ID, "", 1); err == nil && len(tail) == 1 { + later(tail[0].At) + } + if packets, err := Packets(profileDir, t.ID); err == nil { + for _, p := range packets { + later(p.At) + } + } + for _, m := range t.Members { + later(modTime(m.Key)) + } + return last +} diff --git a/internal/teams/move.go b/internal/teams/move.go new file mode 100644 index 0000000000..557c9185e4 --- /dev/null +++ b/internal/teams/move.go @@ -0,0 +1,536 @@ +package teams + +import ( + "sort" + "strings" +) + +// ── MOVING TEAMS: WHERE ONE MAY GO, AND WHAT A MOVE CHANGES ───────────────── +// +// The person moves a team by putting it inside another (ruling c-12, amended +// by c-13): `Move into…` on the teams page, a drag in its rail, or `Inside:` on +// the team's card. The write itself is [File.SetParent], which refuses only +// what would break the tree (a loop, the root under something). Two questions +// come before it, and both are here rather than in the interface because the +// session's own restructuring tools will ask the same ones: +// +// WHERE MAY IT GO ([File.MoveCheck]). Not into itself or anything under it, +// not into a closed team, and not so deep that the deepest team it carries +// would stand past the depth limit of the team it lands in. The answer is a +// [MoveBlock] with the facts a sentence needs (`harbor is 3 levels deep · +// limit 3 · Settings`), and the interface draws every target, dimming the ones +// that are blocked and saying why, so nothing is hidden. +// +// WHAT WOULD CHANGE ([File.MoveEffects]). A move is only a line in a tree +// until it moves authority, money or judgement, and those are what a person +// should see before it happens: whose manager each conversation carried along +// reports to ([File.Home]), whose capped pool the moved team's spend now counts +// toward (a cap is a pool over the subtree, spend.go), and which manager +// decides a conflict among the team's own conversations ([File.LCA]). Each is +// computed on a copy of the file as the move would leave it, tidied exactly as +// the store's write would tidy it, so the answer is the one the next read will +// show. A move that changes none of them is applied at once. + +// The kinds of [MoveBlock]. +const ( + // MoveBlockSelf is a team asked to go inside itself. + MoveBlockSelf = "self" + // MoveBlockInside is a team asked to go inside a team under it. + MoveBlockInside = "inside" + // MoveBlockClosed is a closed target. + MoveBlockClosed = "closed" + // MoveBlockDepth is a move that would stand a team past the target's + // depth limit. + MoveBlockDepth = "depth" + // MoveBlockHere is a target every moved team is already directly under. + MoveBlockHere = "here" + // MoveBlockRoot is the root team asked to move (it holds every team). + MoveBlockRoot = "root" + // MoveBlockGone is a team or a target that is not in the file. + MoveBlockGone = "gone" +) + +// MoveBlock is why teams cannot go inside a target. Team names the team the +// reason is about: the moved team for self, inside and root, the target for +// closed, depth and here. For depth, Depth is how many levels deep the target +// stands, Need how many levels the moved teams take up (a team with one level +// of sub-teams under it needs two), Limit the target's effective depth limit +// and LimitFrom where that limit came from. +type MoveBlock struct { + Kind string + Team string + Name string + Depth int + Need int + Limit int + LimitFrom Origin +} + +// MoveTarget is the id a move into parent really writes: "" is the top level, +// which is the root team when there is one (root.go keeps every other +// top-level team under it). +func (f *File) MoveTarget(parent string) string { + if parent != "" { + return parent + } + if r, ok := f.Root(); ok { + return r.ID + } + return "" +} + +// MoveRoots is ids with every id that sits under another of them left out, in +// the order given: a team moved together with its parent goes along inside +// it and is not moved on its own. +func (f *File) MoveRoots(ids []string) []string { + set := map[string]bool{} + for _, id := range ids { + set[id] = true + } + var out []string + seen := map[string]bool{} + for _, id := range ids { + if seen[id] { + continue + } + seen[id] = true + carried := false + for _, a := range f.Ancestors(id) { + if set[a.ID] { + carried = true + break + } + } + if !carried { + out = append(out, id) + } + } + return out +} + +// levels is how many levels team id and its open sub-teams take up: 1 for a +// team with none under it. The walk is bounded by the list, so a loop in a +// file not yet tidied cannot hang it. +func (f *File) levels(id string) int { return f.levelsWithin(id, len(f.Teams)) } + +func (f *File) levelsWithin(id string, budget int) int { + most := 1 + if budget <= 0 { + return most + } + for _, c := range f.Children(id) { + if c.Closed() { + continue + } + if n := 1 + f.levelsWithin(c.ID, budget-1); n > most { + most = n + } + } + return most +} + +// MoveCheck reports whether the teams ids may go inside parent ("" the top +// level), and when not, why. Among several teams the first that cannot go is +// the answer; a team already under parent is not moved and does not block, +// unless every one of them is (MoveBlockHere). +func (f *File) MoveCheck(ids []string, parent string, d Defaults) (MoveBlock, bool) { + ids = f.MoveRoots(ids) + if len(ids) == 0 { + return MoveBlock{Kind: MoveBlockGone}, false + } + target := f.MoveTarget(parent) + var p Team + if target != "" { + var ok bool + if p, ok = f.Team(target); !ok { + return MoveBlock{Kind: MoveBlockGone, Team: target}, false + } + if p.Closed() { + return MoveBlock{Kind: MoveBlockClosed, Team: p.ID, Name: p.Name}, false + } + } + limit, from := d.DepthLimit, Origin{Kind: OriginSettings} + if target != "" { + e := f.Effective(target, d) + limit, from = e.DepthLimit, e.DepthFrom + } + moving := 0 + for _, id := range ids { + t, ok := f.Team(id) + if !ok { + return MoveBlock{Kind: MoveBlockGone, Team: id}, false + } + if t.Root { + return MoveBlock{Kind: MoveBlockRoot, Team: t.ID, Name: t.Name}, false + } + if id == target { + return MoveBlock{Kind: MoveBlockSelf, Team: t.ID, Name: t.Name}, false + } + if target != "" && ParentLoops(f.Teams, id, target) { + return MoveBlock{Kind: MoveBlockInside, Team: t.ID, Name: t.Name}, false + } + if t.Parent == target { + continue + } + moving++ + need := f.levels(id) + if depth := f.Depth(target); limit > 0 && depth+need > limit { + return MoveBlock{Kind: MoveBlockDepth, Team: p.ID, Name: p.Name, Depth: depth, Need: need, + Limit: limit, LimitFrom: from}, false + } + } + if moving == 0 { + return MoveBlock{Kind: MoveBlockHere, Team: p.ID, Name: p.Name}, false + } + return MoveBlock{}, true +} + +// Move puts every team in ids inside parent ("" the top level), each team +// carried along inside another moved one left where it is. It checks nothing +// [File.SetParent] does not; ask [File.MoveCheck] first. +func (f *File) Move(ids []string, parent string) error { + target := f.MoveTarget(parent) + for _, id := range f.MoveRoots(ids) { + if t, ok := f.Team(id); ok && t.Parent == target { + continue + } + if err := f.SetParent(id, target); err != nil { + return err + } + } + return nil +} + +// ReportMove is one conversation whose manager a move changes: the manager it +// reports to before and after, each with whether there is one. +type ReportMove struct { + Key string + Before, After Report + Had, Has bool +} + +// PoolMove is one moved team whose spend counts toward another capped pool: +// Before and After are the teams that own the pool above it ("" none), and +// BeforeCap and AfterCap those pools' daily caps. +type PoolMove struct { + Team string + Before, After string + BeforeCap, AfterCap float64 +} + +// JudgeMove is one moved team whose conflicts another manager decides: Before +// and After are the deciding teams ([File.LCA]), "" for the person. +type JudgeMove struct { + Team string + Before, After string +} + +// MoveEffect is what a move changes. +type MoveEffect struct { + Reports []ReportMove + Pools []PoolMove + Judges []JudgeMove +} + +// Changes reports whether the move changes anything a person is asked about. +func (e MoveEffect) Changes() bool { + return len(e.Reports) > 0 || len(e.Pools) > 0 || len(e.Judges) > 0 +} + +// MoveEffects is what moving ids inside parent would change, computed on +// copies of the file tidied as the store's write tidies them. The file is not +// changed. An error is a move [File.SetParent] refuses. +func (f *File) MoveEffects(ids []string, parent string, d Defaults) (MoveEffect, error) { + before := f.tidyCopy() + after := f.tidyCopy() + if err := after.Move(ids, parent); err != nil { + return MoveEffect{}, err + } + tidy(after.Teams) + var out MoveEffect + for _, id := range before.MoveRoots(ids) { + t, ok := before.Team(id) + if !ok { + continue + } + // Every conversation carried: the team's and every open team's under it. + keys := before.subtreeKeys(id) + for _, k := range keys { + was, had := before.Home(k) + now, has := after.Home(k) + if had != has || was.Manager != now.Manager || was.Team != now.Team { + out.Reports = append(out.Reports, ReportMove{Key: k, Before: was, After: now, Had: had, Has: has}) + } + } + was, wasCap := before.poolAbove(t.Parent, d) + nt, _ := after.Team(id) + now, nowCap := after.poolAbove(nt.Parent, d) + if was != now { + out.Pools = append(out.Pools, PoolMove{Team: id, Before: was, After: now, BeforeCap: wasCap, AfterCap: nowCap}) + } + if len(keys) > 0 { + jb, okb := before.LCA(keys...) + ja, oka := after.LCA(keys...) + if okb != oka || jb.ID != ja.ID { + out.Judges = append(out.Judges, JudgeMove{Team: id, Before: jb.ID, After: ja.ID}) + } + } + } + return out, nil +} + +// tidyCopy is a copy of f that shares nothing with it, tidied. +func (f *File) tidyCopy() *File { + g := &File{Version: f.Version, Teams: make([]Team, len(f.Teams))} + for i, t := range f.Teams { + g.Teams[i] = t.Clone() + } + tidy(g.Teams) + return g +} + +// subtreeKeys is every member key of team id and of the open teams under it, +// each once, in file order. +func (f *File) subtreeKeys(id string) []string { + in := map[string]bool{id: true} + for _, t := range f.Descendants(id) { + if !t.Closed() { + in[t.ID] = true + } + } + var out []string + seen := map[string]bool{} + for _, t := range f.Teams { + if !in[t.ID] { + continue + } + for _, m := range t.Members { + if !seen[m.Key] { + seen[m.Key] = true + out = append(out, m.Key) + } + } + } + return out +} + +// poolAbove is the team owning the capped pool a team directly under parent +// counts toward, and that pool's cap: "" and 0 for a team at the top or under +// no cap. An inherited cap is its owner's one pool; the profile's default cap +// is measured over the whole chain, so its pool is the top of it. +func (f *File) poolAbove(parent string, d Defaults) (string, float64) { + if parent == "" { + return "", 0 + } + e := f.Effective(parent, d) + if e.CapUSDDay <= 0 { + return "", 0 + } + switch e.CapFrom.Kind { + case OriginTeam, OriginAncestor: + return e.CapFrom.Team, e.CapUSDDay + case OriginSettings: + top := parent + for _, a := range f.Ancestors(parent) { + if !a.Closed() { + top = a.ID + } + } + return top, e.CapUSDDay + } + return "", 0 +} + +// MoveNotice is one Traffic line a committed move writes: Team is whose log, +// Entry the line. The store appends it; a frame never does. +type MoveNotice struct { + Team string + Entry Entry +} + +// MoveNotices is the Traffic written when ids have moved, read off the file +// before the move and the file after it. A team whose parent did not change +// contributes nothing, so a refused move (the file left as it was) writes +// nothing, and asking twice about the same pair does not invent a second move. +// +// EACH AFFECTED TEAM GETS ONE [KindEvent] PER MEMBER THAT MOVED WITH THE TEAM. +// The team that was left, and the moved team, say `@handle moved to harbor`. +// The team that was joined says `@handle joined from ops`. A manager reads +// those on its next turn through the ordinary Traffic read. The lines are +// from codeaf to everyone and carry no member state, so they do not start a +// wake of their own. A member with no handle is named by the team's name, +// once, so a team of unnamed conversations is still told. +func MoveNotices(before, after *File, ids []string) []MoveNotice { + if before == nil || after == nil { + return nil + } + var out []MoveNotice + for _, id := range before.MoveRoots(ids) { + was, ok := before.Team(id) + if !ok { + continue + } + now, ok := after.Team(id) + if !ok || now.Parent == was.Parent { + continue + } + to := placeName(after, now.Parent) + from := placeName(before, was.Parent) + for _, h := range moveHandles(was) { + moved := "@" + h + " moved to " + to + joined := "@" + h + " joined from " + from + // The moved team, and the team it left, both lost the line it had. + out = append(out, moveEvent(id, moved)) + if was.Parent != "" { + out = append(out, moveEvent(was.Parent, moved)) + } + // The team it joined gained it. + if now.Parent != "" { + out = append(out, moveEvent(now.Parent, joined)) + } + } + } + return out +} + +// moveHandles is who a move names: each member's handle, or the team's name +// once when nobody has one. +func moveHandles(t Team) []string { + var out []string + seen := map[string]bool{} + for _, m := range t.Members { + h := strings.TrimPrefix(strings.TrimSpace(m.Handle), "@") + if h == "" || seen[h] { + continue + } + seen[h] = true + out = append(out, h) + } + if len(out) == 0 && strings.TrimSpace(t.Name) != "" { + out = append(out, t.Name) + } + return out +} + +// placeName is team id's name, or "the top" when id is the top level. +func placeName(f *File, id string) string { + if id == "" { + return "the top" + } + if t, ok := f.Team(id); ok && t.Name != "" { + return t.Name + } + return id +} + +// moveEvent is one move line, from codeaf to everyone, with no member state +// so the wake watch does not start a turn for it. +func moveEvent(team, text string) MoveNotice { + return MoveNotice{Team: team, Entry: Entry{ + Kind: KindEvent, From: FromSystem, To: ToEveryone, Text: text, + }} +} + +// MemberMoveNotices is the Traffic for conversations that left one team and +// joined another between before and after. A team move that only changes a +// parent is not one of these (that is [MoveNotices]). A file that did not +// change membership writes nothing, so a refused transfer writes nothing. +// Each team left says `@handle moved to harbor`. Each team joined says +// `@handle joined from ops`. +func MemberMoveNotices(before, after *File) []MoveNotice { + if before == nil || after == nil { + return nil + } + type seat struct { + team Team + mem Member + } + was := map[string][]seat{} + for _, t := range before.Teams { + for _, m := range t.Members { + if m.Key == "" { + continue + } + was[m.Key] = append(was[m.Key], seat{t, m}) + } + } + now := map[string][]seat{} + for _, t := range after.Teams { + for _, m := range t.Members { + if m.Key == "" { + continue + } + now[m.Key] = append(now[m.Key], seat{t, m}) + } + } + var out []MoveNotice + seen := map[string]bool{} + for key, froms := range was { + tos := now[key] + for _, from := range froms { + still := false + for _, to := range tos { + if to.team.ID == from.team.ID { + still = true + break + } + } + if still { + continue + } + h := moveHandle(from.mem) + if h == "" { + continue + } + for _, to := range tos { + if to.team.ID == from.team.ID { + continue + } + held := false + for _, back := range froms { + if back.team.ID == to.team.ID { + held = true + break + } + } + if held { + continue + } + mark := from.team.ID + "->" + to.team.ID + ":" + h + if seen[mark] { + continue + } + seen[mark] = true + out = append(out, moveEvent(from.team.ID, "@"+h+" moved to "+placeName(after, to.team.ID))) + out = append(out, moveEvent(to.team.ID, "@"+h+" joined from "+placeName(before, from.team.ID))) + } + } + } + sort.Slice(out, func(i, j int) bool { + if out[i].Team != out[j].Team { + return out[i].Team < out[j].Team + } + return out[i].Entry.Text < out[j].Entry.Text + }) + return out +} + +// moveHandle is the handle a move line uses, or "" when the member has none. +func moveHandle(m Member) string { + return strings.TrimPrefix(strings.TrimSpace(m.Handle), "@") +} + +// WriteMoveNotices appends each notice to that team's Traffic, once per +// notice. A refused move hands none, and this writes none. +func WriteMoveNotices(profileDir string, notes []MoveNotice) error { + var err error + for _, n := range notes { + if n.Team == "" || strings.TrimSpace(n.Entry.Text) == "" { + continue + } + if e := AppendTraffic(profileDir, n.Team, n.Entry); e != nil && err == nil { + err = e + } + } + return err +} diff --git a/internal/teams/move_test.go b/internal/teams/move_test.go new file mode 100644 index 0000000000..2a6de24ad2 --- /dev/null +++ b/internal/teams/move_test.go @@ -0,0 +1,254 @@ +package teams + +import ( + "strings" + "testing" +) + +// moveFile is harbor (managed, $10 a day) over dock, with api at the top +// level holding its own $3 cap, and a closed team shut beside them. +// +// harbor ◆ boss $10/day +// dock +// api $3/day (web, srv) +// shut closed +func moveFile() *File { + ten, three := 10.0, 3.0 + f := &File{Teams: []Team{ + {ID: "harbor", Name: "harbor", Members: []Member{{Key: "boss"}}, Manager: "boss", + Settings: Settings{CapUSDDay: &ten}}, + {ID: "dock", Name: "dock", Parent: "harbor", Members: []Member{{Key: "crane"}}}, + {ID: "api", Name: "api", Members: []Member{{Key: "web"}, {Key: "srv"}}, Settings: Settings{CapUSDDay: &three}}, + {ID: "shut", Name: "shut", State: TeamClosed}, + }} + tidy(f.Teams) + return f +} + +// WHERE A TEAM MAY GO: never into itself or under itself, never into a closed +// team, never past the depth limit, and a target it is already in is said. +func TestMoveCheckSaysWhyATargetIsBlocked(t *testing.T) { + f := moveFile() + d := Defaults{DepthLimit: 2} + for _, c := range []struct { + ids []string + parent string + kind string + }{ + {[]string{"harbor"}, "harbor", MoveBlockSelf}, + {[]string{"harbor"}, "dock", MoveBlockInside}, + {[]string{"api"}, "shut", MoveBlockClosed}, + {[]string{"api"}, "dock", MoveBlockDepth}, + {[]string{"dock"}, "harbor", MoveBlockHere}, + {[]string{"nobody"}, "", MoveBlockGone}, + } { + b, ok := f.MoveCheck(c.ids, c.parent, d) + if ok || b.Kind != c.kind { + t.Fatalf("%v into %q: got %+v ok %v, want %s", c.ids, c.parent, b, ok, c.kind) + } + } + b, _ := f.MoveCheck([]string{"api"}, "dock", d) + if b.Name != "dock" || b.Depth != 2 || b.Need != 1 || b.Limit != 2 || b.LimitFrom.Kind != OriginSettings { + t.Fatalf("the depth block lacks its facts: %+v", b) + } + if _, ok := f.MoveCheck([]string{"api"}, "harbor", d); !ok { + t.Fatal("api may not go into harbor") + } + // A team with a level under it needs two levels where it lands. + if _, ok := f.MoveCheck([]string{"harbor"}, "api", d); ok { + t.Fatal("harbor and dock under api stand three deep past a limit of two") + } + if _, ok := f.MoveCheck([]string{"dock"}, "", d); !ok { + t.Fatal("dock may not go to the top level") + } +} + +// SEVERAL TEAMS MOVE AS ONE, and a team selected with its parent rides along +// inside it rather than being moved out on its own. +func TestMoveCarriesATeamSelectedWithItsParent(t *testing.T) { + f := moveFile() + if got := f.MoveRoots([]string{"dock", "harbor", "api"}); len(got) != 2 || got[0] != "harbor" || got[1] != "api" { + t.Fatalf("roots of the selection: %v", got) + } + if err := f.Move([]string{"harbor", "dock"}, "api"); err != nil { + t.Fatal(err) + } + h, _ := f.Team("harbor") + k, _ := f.Team("dock") + if h.Parent != "api" || k.Parent != "harbor" { + t.Fatalf("harbor under %q, dock under %q", h.Parent, k.Parent) + } +} + +// THE TOP LEVEL IS THE ROOT when there is one: a move to "" writes the root. +func TestMoveToTheTopLevelLandsUnderTheRoot(t *testing.T) { + f := moveFile() + root := f.MakeRoot(f.Teams[0].Made) + if got := f.MoveTarget(""); got != root { + t.Fatalf("the top level is %q, want the root %q", got, root) + } + if b, ok := f.MoveCheck([]string{root}, "harbor", Defaults{DepthLimit: 5}); ok || b.Kind != MoveBlockRoot { + t.Fatalf("the root may move: %+v", b) + } + if err := f.Move([]string{"dock"}, ""); err != nil { + t.Fatal(err) + } + if k, _ := f.Team("dock"); k.Parent != root { + t.Fatalf("dock at the top is under %q", k.Parent) + } +} + +// WHAT A MOVE CHANGES: api into harbor puts its conversations under harbor's +// manager, its spend in harbor's pool and its conflicts before harbor's +// manager; a move inside one unmanaged, uncapped place changes nothing. +func TestMoveEffectsNameAuthorityPoolAndJudge(t *testing.T) { + f := moveFile() + d := Defaults{DepthLimit: 5} + e, err := f.MoveEffects([]string{"api"}, "harbor", d) + if err != nil { + t.Fatal(err) + } + if len(e.Reports) != 2 || e.Reports[0].Had || !e.Reports[0].Has || e.Reports[0].After.Team != "harbor" { + t.Fatalf("the reports: %+v", e.Reports) + } + if len(e.Pools) != 1 || e.Pools[0].Before != "" || e.Pools[0].After != "harbor" || e.Pools[0].AfterCap != 10 { + t.Fatalf("the pool: %+v", e.Pools) + } + if len(e.Judges) != 1 || e.Judges[0].Before != "" || e.Judges[0].After != "harbor" { + t.Fatalf("the judge: %+v", e.Judges) + } + // The file itself did not move. + if a, _ := f.Team("api"); a.Parent != "" { + t.Fatal("MoveEffects moved the team") + } + // Two unmanaged teams at the top with no cap: nothing to ask. + g := &File{Teams: []Team{{ID: "a", Name: "a", Members: []Member{{Key: "x"}}}, {ID: "b", Name: "b"}}} + e, err = g.MoveEffects([]string{"a"}, "b", d) + if err != nil || e.Changes() { + t.Fatalf("a quiet move changes %+v (%v)", e, err) + } +} + +// A COMMITTED MOVE WRITES ONE TRAFFIC LINE PER AFFECTED TEAM PER MEMBER, and a +// refused move writes none. Writing the notices of that one move once is the +// whole log: the same pair of files does not grow a second copy inside +// MoveNotices, and a file that did not move has nothing to append. +func TestMoveTrafficIsAppendedOnceAndNeverOnARefusal(t *testing.T) { + f := moveFile() + f.Teams = append(f.Teams, Team{ID: "ops", Name: "ops", Members: []Member{{Key: "lead", Handle: "lead"}}}) + for i := range f.Teams { + if f.Teams[i].ID == "api" { + f.Teams[i].Parent = "ops" + f.Teams[i].Members[0].Handle = "web" + f.Teams[i].Members[1].Handle = "srv" + } + } + tidy(f.Teams) + before := f.tidyCopy() + d := Defaults{DepthLimit: 5} + if _, ok := f.MoveCheck([]string{"api"}, "shut", d); ok { + t.Fatal("a closed team accepted the move") + } + if n := MoveNotices(before, f, []string{"api"}); len(n) != 0 { + t.Fatalf("a refused move wrote %d lines", len(n)) + } + if err := f.Move([]string{"api"}, "api"); err == nil { + t.Fatal("a team moved inside itself") + } + if n := MoveNotices(before, f, []string{"api"}); len(n) != 0 { + t.Fatalf("a move the store refused wrote %d lines", len(n)) + } + if err := f.Move([]string{"api"}, "harbor"); err != nil { + t.Fatal(err) + } + notes := MoveNotices(before, f, []string{"api"}) + want := map[string][]string{ + "api": {"@web moved to harbor", "@srv moved to harbor"}, + "ops": {"@web moved to harbor", "@srv moved to harbor"}, + "harbor": {"@web joined from ops", "@srv joined from ops"}, + } + if len(notes) != 6 { + t.Fatalf("got %d notices, want 6: %+v", len(notes), textsOf(notes)) + } + got := map[string][]string{} + for _, n := range notes { + if n.Entry.Kind != KindEvent || n.Entry.From != FromSystem || n.Entry.To != ToEveryone || n.Entry.State != "" { + t.Fatalf("a move line is not an ordinary event: %+v", n.Entry) + } + got[n.Team] = append(got[n.Team], n.Entry.Text) + } + for team, lines := range want { + if strings.Join(got[team], "\n") != strings.Join(lines, "\n") { + t.Fatalf("%s traffic: %q, want %q", team, got[team], lines) + } + } + dir := t.TempDir() + if err := WriteMoveNotices(dir, notes); err != nil { + t.Fatal(err) + } + for team, lines := range want { + log, err := ReadTraffic(dir, team, "", 0) + if err != nil { + t.Fatal(err) + } + if len(log) != len(lines) { + t.Fatalf("%s has %d lines, want %d (written once)", team, len(log), len(lines)) + } + for i, line := range lines { + if log[i].Text != line { + t.Fatalf("%s line %d is %q, want %q", team, i, log[i].Text, line) + } + } + } + // The move already happened: asking again about the file as it stands + // adds nothing, so a second commit of the same move cannot double the log. + if n := MoveNotices(f, f, []string{"api"}); len(n) != 0 { + t.Fatalf("the move that already landed wrote %d more lines", len(n)) + } +} + +// A CONVERSATION MOVED FROM ONE TEAM TO ANOTHER is one line on each side, and +// a transfer that did not happen (the same membership) is none. +func TestMemberMoveTrafficIsAppendedOnceAndNeverOnARefusal(t *testing.T) { + before := &File{Teams: []Team{ + {ID: "ops", Name: "ops", Members: []Member{{Key: "k", Handle: "web"}}}, + {ID: "harbor", Name: "harbor"}, + }} + if n := MemberMoveNotices(before, before); len(n) != 0 { + t.Fatalf("a refused transfer wrote %+v", textsOf(n)) + } + after := before.tidyCopy() + if err := after.AddMember("harbor", Member{Key: "k", Handle: "web"}); err != nil { + t.Fatal(err) + } + if err := after.RemoveMember("ops", "k"); err != nil { + t.Fatal(err) + } + notes := MemberMoveNotices(before, after) + if len(notes) != 2 { + t.Fatalf("got %+v", textsOf(notes)) + } + by := map[string]string{} + for _, n := range notes { + by[n.Team] = n.Entry.Text + } + if by["ops"] != "@web moved to harbor" || by["harbor"] != "@web joined from ops" { + t.Fatalf("texts %+v", by) + } + dir := t.TempDir() + if err := WriteMoveNotices(dir, notes); err != nil { + t.Fatal(err) + } + log, err := ReadTraffic(dir, "ops", "", 0) + if err != nil || len(log) != 1 || log[0].Text != "@web moved to harbor" { + t.Fatalf("ops log %+v (%v)", log, err) + } +} + +func textsOf(notes []MoveNotice) []string { + out := make([]string, len(notes)) + for i, n := range notes { + out[i] = n.Team + ": " + n.Entry.Text + } + return out +} diff --git a/internal/teams/nest_test.go b/internal/teams/nest_test.go new file mode 100644 index 0000000000..3941c70173 --- /dev/null +++ b/internal/teams/nest_test.go @@ -0,0 +1,172 @@ +package teams + +// NESTING, AS THE STORE KEEPS IT: a conflict's ruling reaches every party as a +// directive in its own team's log whoever decides it, a party never decides its +// own case, and the global manager's members are the top-level managers. + +import ( + "errors" + "strings" + "testing" + "time" +) + +// siblings is P (manager pm) with two sub-teams, A (manager am; member web) and +// B (no manager; member api), saved under dir. +func siblings(t *testing.T, dir string) { + t.Helper() + must(t, Save(dir, []Team{ + {ID: "pppppppppppp", Name: "harbor", Manager: "pm", Members: []Member{{Key: "pm", Handle: "boss"}, {Key: "am", Handle: "front"}}}, + {ID: "aaaaaaaaaaaa", Name: "front", Parent: "pppppppppppp", Manager: "am", Members: []Member{{Key: "am", Handle: "lead"}, {Key: "web", Handle: "web"}}}, + {ID: "bbbbbbbbbbbb", Name: "back", Parent: "pppppppppppp", Members: []Member{{Key: "api", Handle: "api"}}}, + })) +} + +func conflictBetween(t *testing.T, dir string) Packet { + t.Helper() + f, err := Load(dir) + must(t, err) + lca, ok := f.LCA("web", "api") + if !ok || lca.ID != "pppppppppppp" { + t.Fatalf("web and api meet at %+v %v, want harbor", lca, ok) + } + p, err := Raise(dir, Packet{Team: lca.ID, Origin: "aaaaaaaaaaaa", Kind: PacketConflict, RaisedBy: "web", + Question: "which shape does the signup form send?", + Parties: []Party{ + {Key: "web", Handle: "web", Team: "aaaaaaaaaaaa", Context: "the form posts JSON"}, + {Key: "api", Handle: "api", Team: "bbbbbbbbbbbb"}, + }, + Options: []Option{{Label: "JSON", Consequence: "@api changes the handler"}, {Label: "form data", Consequence: "@web rewrites the submit"}}}) + must(t, err) + return p +} + +// A CONFLICT'S LINES ARE IN EVERY INVOLVED TEAM, and its ruling is a directive +// to each party in its own team's log, carrying the packet. +func TestAConflictsRulingIsADirectiveToEveryPartyInItsOwnTeam(t *testing.T) { + dir := t.TempDir() + siblings(t, dir) + p := conflictBetween(t, dir) + for _, team := range []string{"pppppppppppp", "aaaaaaaaaaaa", "bbbbbbbbbbbb"} { + log, _ := ReadTraffic(dir, team, "", 0) + if len(log) != 1 || log[0].Kind != KindPacket || log[0].Packet != p.ID { + t.Fatalf("the raise is not in %s's traffic: %+v", team, log) + } + } + decided, err := Decide(dir, p.ID, "boss", "1", "the other endpoints take JSON") + must(t, err) + if decided.DecidedBy != "boss" { + t.Fatalf("decided by %q", decided.DecidedBy) + } + for team, handle := range map[string]string{"aaaaaaaaaaaa": "web", "bbbbbbbbbbbb": "api"} { + log, _ := ReadTraffic(dir, team, "", 0) + var ruling Entry + for _, e := range log { + if IsRuling(e) { + ruling = e + } + } + if ruling.To != handle || ruling.Member != handle || ruling.From != FromManager || ruling.Packet != p.ID { + t.Fatalf("%s's party was not directed: %+v", team, log) + } + for _, want := range []string{"ruling on the conflict " + p.ID, `◆ @boss (manager of "harbor")`, "JSON: @api changes the handler", "the other endpoints take JSON", "which shape"} { + if !strings.Contains(ruling.Text, want) { + t.Errorf("the ruling lacks %q: %s", want, ruling.Text) + } + } + } + // The decider's own team has the decision line and no directive. + log, _ := ReadTraffic(dir, "pppppppppppp", "", 0) + for _, e := range log { + if IsRuling(e) { + t.Fatalf("a ruling went to the decider's team: %+v", e) + } + } +} + +// THE PERSON'S RULING IS THE PERSON'S, and says so. +func TestThePersonsRulingIsFromThePerson(t *testing.T) { + dir := t.TempDir() + siblings(t, dir) + p := conflictBetween(t, dir) + _, err := Decide(dir, p.ID, Person, "keep both shapes for now", "") + must(t, err) + log, _ := ReadTraffic(dir, "bbbbbbbbbbbb", "", 0) + e := log[len(log)-1] + if !IsRuling(e) || e.From != FromYou || !strings.Contains(e.Text, "by the person: keep both shapes for now") { + t.Fatalf("the person's ruling: %+v", e) + } +} + +// A PARTY NEVER DECIDES ITS OWN CASE, even when the packet waits on the team +// it manages. +func TestAManagerWhoIsAPartyIsNotTheDecider(t *testing.T) { + dir := t.TempDir() + siblings(t, dir) + p, err := Raise(dir, Packet{Team: "pppppppppppp", Origin: "aaaaaaaaaaaa", Kind: PacketConflict, RaisedBy: "web", Question: "who owns the form?", + Parties: []Party{{Key: "web", Handle: "web", Team: "aaaaaaaaaaaa"}, {Key: "pm", Handle: "boss", Team: "pppppppppppp"}}, + Options: []Option{{Label: "web", Consequence: "web owns it"}}}) + must(t, err) + if _, err := Decide(dir, p.ID, "boss", "1", ""); !errors.Is(err, ErrNotDecider) { + t.Fatalf("a party decided its own case: %v", err) + } + if _, err := Decide(dir, p.ID, Person, "1", ""); err != nil { + t.Fatalf("the person could not decide it: %v", err) + } +} + +// THE GLOBAL MANAGER'S MEMBERS ARE THE TOP-LEVEL MANAGERS: seated in the root +// with their handles while the root has a manager, and TopManagers is exactly +// the ones who manage a top-level team now. +func TestTheRootSeatsTheTopLevelManagers(t *testing.T) { + dir := t.TempDir() + must(t, Save(dir, []Team{ + {ID: "aaaaaaaaaaaa", Name: "harbor", Manager: "hm", Members: []Member{{Key: "hm", Handle: "harbor"}}}, + {ID: "bbbbbbbbbbbb", Name: "yard", Manager: "ym", Members: []Member{{Key: "ym", Handle: "yard"}}}, + {ID: "cccccccccccc", Name: "dock", Parent: "aaaaaaaaaaaa", Manager: "dm", Members: []Member{{Key: "dm", Handle: "dock"}}}, + {ID: "dddddddddddd", Name: "quiet"}, + })) + root := "" + must(t, Update(dir, func(f *File) error { + root = f.MakeRoot(time.Time{}) + if err := f.AddMember(root, Member{Key: "gm", Handle: "all"}); err != nil { + return err + } + return f.SetManager(root, "gm") + })) + f, err := Load(dir) + must(t, err) + r, _ := f.Root() + if !r.Holds("hm") || !r.Holds("ym") || r.Holds("dm") { + t.Fatalf("the root holds %+v; want the two top-level managers and not dock's", r.Members) + } + if m, _ := r.Member("ym"); m.Handle != "yard" { + t.Fatalf("yard's manager is %q in the root", m.Handle) + } + top := f.TopManagers() + if len(top) != 2 || top[0].Key != "hm" || top[1].Key != "ym" { + t.Fatalf("TopManagers: %+v", top) + } + if h, _ := f.Home("ym"); h.Team != root { + t.Fatalf("yard's manager reports to %+v, want the root", h) + } + // A top-level manager replaced is no longer one of the global manager's. + must(t, Update(dir, func(f *File) error { + if err := f.AddMember("bbbbbbbbbbbb", Member{Key: "y2", Handle: "yard2"}); err != nil { + return err + } + return f.SetManager("bbbbbbbbbbbb", "y2") + })) + f, _ = Load(dir) + top = f.TopManagers() + if len(top) != 2 || top[1].Key != "y2" { + t.Fatalf("after yard's manager changed: %+v", top) + } + // With no manager on the root nothing is seated. + must(t, Save(dir, []Team{{ID: "aaaaaaaaaaaa", Name: "harbor", Manager: "hm", Members: []Member{{Key: "hm"}}}})) + must(t, Update(dir, func(f *File) error { f.MakeRoot(time.Time{}); return nil })) + f, _ = Load(dir) + if r, _ := f.Root(); len(r.Members) != 0 { + t.Fatalf("a root with no manager was given members: %+v", r.Members) + } +} diff --git a/internal/teams/root.go b/internal/teams/root.go new file mode 100644 index 0000000000..1dea3442b0 --- /dev/null +++ b/internal/teams/root.go @@ -0,0 +1,184 @@ +package teams + +import ( + "errors" + "time" +) + +// ── THE OPTIONAL GLOBAL MANAGER IS THE MANAGER OF A REAL ROOT TEAM ────────── +// +// The ruling's goal is a person who talks to the top manager and steps away. +// With several top-level teams there is no top manager until the person makes +// one, on the teams page's `All teams` row. That manager could have been a +// special case beside the tree (a field on the file, a pseudo-team every walk +// would have to know about); it is instead the manager of an ordinary team +// marked Root that every other top-level team is moved under. So every rule +// already written holds without a special case: two parties in different trees +// meet at the root ([File.LCA]) and its manager decides instead of the person; +// a top-level team's manager reports to it ([File.Home]); an override on the +// root is what `· from All teams` means ([File.Effective]); and its spend is +// the whole machine's teams ([TeamSpend]). +// +// THE ROOT IS NOT A LEVEL. [File.Depth] does not count it, so a depth limit +// of three still means three levels of the person's own teams. +// +// tidy keeps it true: at most one root (the first), at the top, open, and +// every other top-level team under it, so a team made later at the top level +// lands under the root on the same write. [File.DissolveRoot] undoes it: the +// root team is removed and its children are top-level again; the global +// manager's conversation stays a conversation. +// +// Until the person asks, there is no root team, and the `All teams` row is a +// row the interface draws over the top level with nothing stored behind it. +// +// THE GLOBAL MANAGER'S MEMBERS ARE THE TOP-LEVEL MANAGERS (ruling c-5: orders go +// one level down, and a sub-team's manager is a member of the team above). So +// while the root has a manager, tidy makes every open top-level team's manager +// a member of the root, with the handle it has in its own team when that is +// free there. Its directives then reach them by the ordinary road, its digest +// lists them, and each reports to it by the ordinary home rule. It is only ever +// added: a membership the person removes comes back while that conversation +// still manages a top-level team, and one left behind by a manager who stopped +// being one stays until the person removes it (the session's view of the root +// shows only the current managers). + +// RootName is the root team's name. +const RootName = "All teams" + +// ErrRoot is a change the root cannot take: closing it (dissolve it instead) +// or putting it under another team. +var ErrRoot = errors.New("teams: All teams holds every team; remove its manager or dissolve it instead") + +// Root is the root team, false when there is none. +func (f *File) Root() (Team, bool) { + for _, t := range f.Teams { + if t.Root { + return t, true + } + } + return Team{}, false +} + +// MakeRoot makes the root team, when there is none, and moves every other +// top-level team under it. It answers the root's id. The caller then makes +// the global manager with [File.AddMember] and [File.SetManager], in the same +// write. +func (f *File) MakeRoot(at time.Time) string { + if r, ok := f.Root(); ok { + return r.ID + } + if at.IsZero() { + at = time.Now() + } + root := Team{ID: NewID(), Name: RootName, Made: at, Root: true} + f.Teams = append([]Team{root}, f.Teams...) + tidyRoot(f.Teams) + return root.ID +} + +// DissolveRoot removes the root team and puts every team under it back at the +// top level. A file with no root is left as it is. +func (f *File) DissolveRoot() { + r, ok := f.Root() + if !ok { + return + } + kept := f.Teams[:0:0] + for _, t := range f.Teams { + if t.ID == r.ID { + continue + } + if t.Parent == r.ID { + t.Parent = "" + } + kept = append(kept, t) + } + f.Teams = kept +} + +// tidyRoot keeps one open root at the top with every other top-level team +// under it, and reports whether it changed anything. +func tidyRoot(teams []Team) bool { + changed := false + rootID := "" + for i := range teams { + t := &teams[i] + if !t.Root { + continue + } + if rootID != "" { + t.Root, changed = false, true + continue + } + rootID = t.ID + if t.Parent != "" { + t.Parent, changed = "", true + } + if t.Closed() { + t.State, t.ClosedAt, t.ClosedWith, changed = "", time.Time{}, "", true + } + } + if rootID == "" { + return changed + } + for i := range teams { + if teams[i].ID != rootID && teams[i].Parent == "" { + teams[i].Parent, changed = rootID, true + } + } + if seatTopManagers(teams, rootID) { + changed = true + } + return changed +} + +// seatTopManagers makes every open top-level team's manager a member of the +// root rootID while the root has a manager, and reports whether it added one. +func seatTopManagers(teams []Team, rootID string) bool { + r := Index(teams, rootID) + if r < 0 || teams[r].Manager == "" { + return false + } + changed := false + for _, t := range teams { + if t.Parent != rootID || t.Closed() || t.Manager == "" || teams[r].Holds(t.Manager) { + continue + } + m, ok := t.Member(t.Manager) + if !ok { + continue + } + m.Home, m.Started = false, false + if m.Handle != "" && handleProblem(teams[r], m.Key, m.Handle) != nil { + m.Handle = "" + } + teams[r].Members = append(teams[r].Members, m) + assignHandles(&teams[r]) + changed = true + } + return changed +} + +// TopManagers is the members of the root who manage an open top-level team +// right now, in the root's member order: the global manager's own members. +// Anything else the root holds (a manager who stopped being one, a +// conversation the person put there) is not one of them. +func (f *File) TopManagers() []Member { + r, ok := f.Root() + if !ok { + return nil + } + managing := map[string]bool{} + for _, t := range f.Teams { + if t.Parent == r.ID && !t.Closed() && t.Manager != "" { + managing[t.Manager] = true + } + } + var out []Member + for _, m := range r.Members { + if managing[m.Key] && m.Key != r.Manager { + out = append(out, m) + } + } + return out +} diff --git a/internal/teams/spend.go b/internal/teams/spend.go new file mode 100644 index 0000000000..8a369df923 --- /dev/null +++ b/internal/teams/spend.go @@ -0,0 +1,278 @@ +package teams + +import ( + "bufio" + "encoding/json" + "io" + "os" + "path/filepath" + "strings" + "sync" + "time" + + "github.com/Agent-Field/codeaf/internal/home" +) + +// ── WHAT A TEAM HAS SPENT TODAY ───────────────────────────────────────────── +// +// A team's cap (teamsettings.go) is measured against what its conversations +// spent in one local day, and that figure already exists: every model call +// this machine makes is one line of the usage ledger (internal/session's +// usage_ledger.go), <home>/v3/usage.jsonl, carrying the local day, the cost, +// the 16-hex id of the conversation it was made in (session) and, for the +// work a conversation started, that conversation's id again (root). A member +// is known here by its transcript path, <bucket>/<id>/transcript.jsonl, and +// the id is its folder's name. So a team's spend on a day is the sum of the +// ledger's lines on that day whose session or root is one of its members, or +// a member of any team under it: a cap is a POOL over the subtree. +// +// A CONVERSATION IN SEVERAL COUNTED TEAMS IS COUNTED ONCE, and a line whose +// session and root are both members is one line. A sub-team closed today still +// counts toward its parent's day: the money was spent, and a closed team +// spends nothing more. +// +// IT IS READ ONCE AND THEN ONLY WHAT WAS APPENDED. The ledger is machine-wide +// and grows by a line per call, and the teams page asks about spend on its +// clock. So the ledger is folded, once per process, into totals by day and by +// (session, root) pair, and afterwards a read whose stamp has not moved is +// answered from memory and one that grew reads from the byte the last read +// stopped at. This package does not import internal/session (it imports this +// one), so it reads the five fields it needs itself; internal/session's +// TestTeamSpendReadsTheSessionsLedger pins that both name the same file. +// +// NOTHING HERE ENFORCES A CAP. It is the read model the session's cap check +// and the teams page's `$1.20 of $5 today` are both drawn from. + +// UsageLedgerPath is the machine's usage ledger, the same path +// internal/session's UsageLedgerPath names. +func UsageLedgerPath() string { return home.Join("v3", "usage.jsonl") } + +// dayLayout is the ledger's day, the LOCAL calendar day. +const dayLayout = "2006-01-02" + +// Today is today's local day in the ledger's spelling. +func Today() string { return time.Now().Local().Format(dayLayout) } + +// Spend is what a team and every team under it spent on one day. +type Spend struct { + Team string `json:"team"` + Day string `json:"day"` + USD float64 `json:"usd"` + Calls int `json:"calls"` + // ByMember is each counted conversation's share, by conversation key. + ByMember map[string]float64 `json:"by_member,omitempty"` +} + +// TeamSpend is team teamID's spend on day ("2006-01-02", local) from this +// machine's usage ledger. +func TeamSpend(profileDir, teamID, day string) (Spend, error) { + return TeamSpendIn(profileDir, UsageLedgerPath(), teamID, day) +} + +// TeamSpendIn is [TeamSpend] against the ledger at ledger. +func TeamSpendIn(profileDir, ledger, teamID, day string) (Spend, error) { + f, err := Load(profileDir) + if err != nil { + return Spend{}, err + } + out := Spend{Team: teamID, Day: day} + team, ok := f.Team(teamID) + if !ok { + return out, nil + } + ids := map[string]string{} // session id -> member key + for _, t := range append([]Team{team}, f.Descendants(teamID)...) { + for _, m := range t.Members { + for _, id := range sessionIDs(m.Key) { + if _, ok := ids[id]; !ok { + ids[id] = m.Key + } + } + } + } + totals, err := spendCache.day(ledger, day) + if err != nil { + return out, err + } + for pair, sum := range totals { + key, ok := ids[pair.session] + if !ok { + key, ok = ids[pair.root] + } + if !ok { + continue + } + out.USD += sum.usd + out.Calls += sum.calls + if out.ByMember == nil { + out.ByMember = map[string]float64{} + } + out.ByMember[key] += sum.usd + } + return out, nil +} + +// SpendStamp is one stamp over what a team's spend is read from: the teams +// file (membership) and the ledger. Equal stamps on one day are one answer. +func SpendStamp(profileDir, ledger string) string { + return Stamp(profileDir) + "|" + stampOf(ledger) +} + +// TeamSpendStamp is the stamp of one team's day as [TeamSpend] reads it: the +// day, the team, and [SpendStamp] over the machine's ledger. The engine and a +// local window both answer "same" from it. +func TeamSpendStamp(profileDir, teamID, day string) string { + return day + "|" + teamID + "|" + SpendStamp(profileDir, UsageLedgerPath()) +} + +// sessionIDs is the ledger ids a conversation key can carry: its folder's +// name, the ordinary layout, and for an older flat file its own name. +func sessionIDs(key string) []string { + key = strings.TrimSpace(key) + if key == "" { + return nil + } + var out []string + if dir := filepath.Base(filepath.Dir(key)); isSessionID(dir) { + out = append(out, dir) + } + if base := strings.TrimSuffix(filepath.Base(key), filepath.Ext(key)); isSessionID(base) { + out = append(out, base) + } + return out +} + +// isSessionID reports whether s looks like a session id: 16 hex digits. +func isSessionID(s string) bool { + if len(s) != 16 { + return false + } + for _, r := range s { + if !(r >= '0' && r <= '9' || r >= 'a' && r <= 'f') { + return false + } + } + return true +} + +// spendPair is where a ledger line's money went. +type spendPair struct{ session, root string } + +type spendSum struct { + usd float64 + calls int +} + +// ledgerFold is one ledger as read so far. +type ledgerFold struct { + stamp string + offset int64 + days map[string]map[spendPair]spendSum +} + +// spendMemory is every ledger folded so far, shared by the process. +type spendMemory struct { + mu sync.Mutex + ledgers map[string]*ledgerFold + // reads counts the bytes read, for a test to see a quiet ledger costs none. + reads int64 +} + +var spendCache spendMemory + +// ledgerLine is the five fields of a usage line this package reads. +type ledgerLine struct { + At time.Time `json:"at"` + Day string `json:"day"` + Calls int `json:"calls"` + USD float64 `json:"usd"` + Session string `json:"session"` + Root string `json:"root"` +} + +// day is the ledger's totals for one day, a copy, brought up to date first. +func (m *spendMemory) day(path, day string) (map[spendPair]spendSum, error) { + m.mu.Lock() + defer m.mu.Unlock() + if m.ledgers == nil { + m.ledgers = map[string]*ledgerFold{} + } + f, err := m.refresh(path) + if err != nil { + return nil, err + } + out := make(map[spendPair]spendSum, len(f.days[day])) + for k, v := range f.days[day] { + out[k] = v + } + return out, nil +} + +// refresh brings the fold of path up to date: nothing when its stamp has not +// moved, the appended bytes when it grew, the whole file when it is new here +// or shrank. The caller holds m.mu. +func (m *spendMemory) refresh(path string) (*ledgerFold, error) { + stamp := stampOf(path) + f := m.ledgers[path] + if f != nil && f.stamp == stamp { + return f, nil + } + if stamp == MissingStamp { + f = &ledgerFold{stamp: stamp, days: map[string]map[spendPair]spendSum{}} + m.ledgers[path] = f + return f, nil + } + info, err := os.Stat(path) + if err != nil { + return nil, err + } + if f == nil || info.Size() < f.offset { + f = &ledgerFold{days: map[string]map[spendPair]spendSum{}} + } + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + if _, err := file.Seek(f.offset, io.SeekStart); err != nil { + return nil, err + } + r := bufio.NewReaderSize(file, 32<<10) + for { + raw, err := r.ReadBytes('\n') + if len(raw) > 0 && raw[len(raw)-1] == '\n' { + m.reads += int64(len(raw)) + f.offset += int64(len(raw)) + var line ledgerLine + if json.Unmarshal(raw, &line) == nil && (line.Session != "" || line.Root != "") { + day := line.Day + if day == "" && !line.At.IsZero() { + day = line.At.Local().Format(dayLayout) + } + calls := line.Calls + if calls == 0 { + calls = 1 + } + totals := f.days[day] + if totals == nil { + totals = map[spendPair]spendSum{} + f.days[day] = totals + } + pair := spendPair{session: line.Session, root: line.Root} + sum := totals[pair] + sum.usd += line.USD + sum.calls += calls + totals[pair] = sum + } + } + if err == io.EOF { + break + } + if err != nil { + return nil, err + } + } + f.stamp = stamp + m.ledgers[path] = f + return f, nil +} diff --git a/internal/teams/spend_test.go b/internal/teams/spend_test.go new file mode 100644 index 0000000000..c8d3cdfeda --- /dev/null +++ b/internal/teams/spend_test.go @@ -0,0 +1,86 @@ +package teams + +import ( + "fmt" + "os" + "path/filepath" + "testing" +) + +// A TEAM'S DAY IS ITS SUBTREE'S LEDGER LINES, EACH ONCE. harbor holds one +// conversation, dock under it another; a third is in neither. A task's line +// counts through its root; a line on another day, or of an outsider, does not. +func TestTeamSpendSumsTheSubtreeFromTheLedger(t *testing.T) { + dir := t.TempDir() + a, b, x := "0123456789abcdef", "fedcba9876543210", "1111111111111111" + key := func(id string) string { return filepath.Join("/srv/sessions", id, "transcript.jsonl") } + must(t, Save(dir, []Team{ + {ID: "aaaaaaaaaaaa", Name: "harbor", Members: []Member{{Key: key(a)}}}, + {ID: "bbbbbbbbbbbb", Name: "dock", Parent: "aaaaaaaaaaaa", Members: []Member{{Key: key(b)}, {Key: key(a)}}}, + })) + ledger := filepath.Join(dir, "usage.jsonl") + lines := []string{ + line("2026-09-24", 1.00, a, ""), + line("2026-09-24", 0.25, "9999999999999999", b), // a task b started + line("2026-09-24", 5.00, x, ""), // somebody else + line("2026-09-23", 7.00, a, ""), // yesterday + line("2026-09-24", 0.50, b, ""), + } + writeLedger(t, ledger, lines...) + + got, err := TeamSpendIn(dir, ledger, "aaaaaaaaaaaa", "2026-09-24") + if err != nil || fmt.Sprintf("%.2f", got.USD) != "1.75" || got.Calls != 3 { + t.Fatalf("harbor's day: %+v, %v", got, err) + } + if fmt.Sprintf("%.2f", got.ByMember[key(b)]) != "0.75" { + t.Fatalf("by member: %+v", got.ByMember) + } + dock, _ := TeamSpendIn(dir, ledger, "bbbbbbbbbbbb", "2026-09-24") + if fmt.Sprintf("%.2f", dock.USD) != "1.75" { + t.Fatalf("dock (which holds a too) spent %v", dock.USD) + } + if none, _ := TeamSpendIn(dir, ledger, "cccccccccccc", "2026-09-24"); none.USD != 0 { + t.Fatal("an unknown team spent something") + } + + // Quiet: no bytes read. Grown: only the appended line. + before := spendCache.bytes() + _, _ = TeamSpendIn(dir, ledger, "aaaaaaaaaaaa", "2026-09-24") + if spendCache.bytes() != before { + t.Fatal("a quiet ledger was read again") + } + extra := line("2026-09-24", 2.00, a, "") + appendLedger(t, ledger, extra) + again, _ := TeamSpendIn(dir, ledger, "aaaaaaaaaaaa", "2026-09-24") + if fmt.Sprintf("%.2f", again.USD) != "3.75" || spendCache.bytes()-before != int64(len(extra)+1) { + t.Fatalf("after one more line: %v, read %d bytes", again.USD, spendCache.bytes()-before) + } +} + +func line(day string, usd float64, session, root string) string { + return fmt.Sprintf(`{"at":"2026-09-24T10:00:00Z","day":%q,"usd":%v,"calls":1,"session":%q,"root":%q}`, day, usd, session, root) +} + +func writeLedger(t *testing.T, path string, lines ...string) { + t.Helper() + body := "" + for _, l := range lines { + body += l + "\n" + } + must(t, os.WriteFile(path, []byte(body), 0o600)) +} + +func appendLedger(t *testing.T, path, l string) { + t.Helper() + f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o600) + must(t, err) + _, err = f.WriteString(l + "\n") + must(t, err) + must(t, f.Close()) +} + +func (m *spendMemory) bytes() int64 { + m.mu.Lock() + defer m.mu.Unlock() + return m.reads +} diff --git a/internal/teams/stamp.go b/internal/teams/stamp.go new file mode 100644 index 0000000000..d3b91fab3f --- /dev/null +++ b/internal/teams/stamp.go @@ -0,0 +1,188 @@ +package teams + +import ( + "errors" + "os" + "strconv" + "sync" + "time" +) + +// ── STAMPS: WHETHER A FILE MOVED, ANSWERED BY A STAT ──────────────────────── +// +// A reader that asks every second whether the teams file or a Traffic log has +// changed must not read either file to find out. A stamp is what one stat says +// about a file, its size and its modification time, written as a short string +// so that it can cross a wire and be handed back unchanged. Two equal stamps +// are a file nobody wrote in between. +// +// EVERY WRITE HERE MOVES THE TIME FORWARD, so the stamp is a real answer and not +// a likely one. A filesystem keeps modification times at some granularity, and +// two writes inside one tick with the same size would read as one; [write] and +// [AppendTraffic] therefore set the new file's time to one microsecond past the +// old one's whenever the clock has not moved past it. Every write of the teams +// file happens under its lock, so the times it leaves only ever increase. +// +// A stamp is never "": [MissingStamp] is the answer for a file that is not +// there, and "" is kept for a reader that has not looked yet, so a reader +// passing "" to [ChangeIf] or to a caller that compares is always told the file +// moved. + +// MissingStamp is the stamp of a file that does not exist. +const MissingStamp = "-" + +// ErrStale is [ChangeIf] finding the file changed since the stamp it was given. +// Nothing was written; the caller reads again and makes its change again. +var ErrStale = errors.New("teams: the file changed since it was read") + +// Stamp is the teams file's stamp in profileDir. +func Stamp(profileDir string) string { return stampOf(Path(profileDir)) } + +// TrafficStamp is the stamp of team teamID's current Traffic log. A rotation +// starts a new current file, so it moves this stamp as an append does. +func TrafficStamp(profileDir, teamID string) string { + return stampOf(TrafficPath(profileDir, teamID)) +} + +func stampOf(path string) string { + info, err := os.Stat(path) + if err != nil { + return MissingStamp + } + return strconv.FormatInt(info.Size(), 10) + "." + strconv.FormatInt(info.ModTime().UnixNano(), 10) +} + +// advance sets path's modification time one microsecond past before when the +// write that made it did not already move past it. A zero before is a file +// that did not exist, and nothing needs moving. +func advance(path string, before time.Time) { + if before.IsZero() { + return + } + info, err := os.Stat(path) + if err != nil || info.ModTime().After(before) { + return + } + at := before.Add(time.Microsecond) + _ = os.Chtimes(path, at, at) +} + +// modTime is path's modification time, zero when it is not there. +func modTime(path string) time.Time { + info, err := os.Stat(path) + if err != nil { + return time.Time{} + } + return info.ModTime() +} + +// Change is [Update] that answers what it wrote and the file's stamp after the +// write, both taken under the lock, so the caller can hold the list and know +// which version of the file it is. +func Change(profileDir string, fn func(*File) error) (*File, string, error) { + return change(profileDir, nil, fn) +} + +// ChangeIf is [Change] only while the file is still at stamp base: the +// compare-and-swap a writer on the far side of a wire needs, because it read +// the file in one call and writes it in another and the lock cannot be held +// across the two. A file that moved in between is [ErrStale], nothing is +// written, and fn is not called. +func ChangeIf(profileDir, base string, fn func(*File) error) (*File, string, error) { + return change(profileDir, &base, fn) +} + +func change(profileDir string, base *string, fn func(*File) error) (*File, string, error) { + var ( + wrote *File + stamp string + ) + err := withLock(profileDir, lockWait, func() error { + if base != nil && Stamp(profileDir) != *base { + return ErrStale + } + f, err := updateLocked(profileDir, fn) + if err != nil { + return err + } + wrote, stamp = f, Stamp(profileDir) + return nil + }) + if err != nil { + return nil, "", err + } + return wrote, stamp, nil +} + +// ── A TRAFFIC READER THAT STATS BEFORE IT READS ───────────────────────────── + +// Watch reads Traffic logs for a reader that comes back with the cursor it was +// last given, and answers "nothing new" from one stat when the log has not +// moved since. It is the reading a clock makes once a second while a managed +// team is held, locally and on the engine's side of a wire, and it is safe for +// several goroutines at once. The zero value is ready. +// +// IT REMEMBERS ONE MARK PER LOG: the stamp the log had just before the last +// read, and the cursor that read left the reader at. A read asked from that +// cursor with the stamp unchanged cannot find anything, so it is not made. The +// stamp is taken BEFORE the read, so a line written while the read was going +// on moves the stamp past the mark and is found on the next turn. +type Watch struct { + mu sync.Mutex + marks map[string]watchMark + // reads counts the reads made, for a test to see the quiet turns make none. + reads int +} + +type watchMark struct{ stamp, after string } + +// Traffic is [ReadTraffic] for team teamID, after the cursor after, at most +// limit entries, with the log's stamp; a read from the cursor the last one +// left, of a log that has not moved, answers no entries without reading. +// A tail (after "") or an unlimited read is always made. +func (w *Watch) Traffic(profileDir, teamID, after string, limit int) ([]Entry, string, error) { + if err := safeTeamID(teamID); err != nil { + return nil, "", err + } + key := profileDir + "\x00" + teamID + stamp := TrafficStamp(profileDir, teamID) + if after != "" && limit > 0 && w.quiet(key, stamp, after) { + return nil, stamp, nil + } + entries, err := ReadTraffic(profileDir, teamID, after, limit) + if err != nil { + return nil, stamp, err + } + next := after + if len(entries) > 0 { + next = entries[len(entries)-1].ID + } + // A page that came back full may have more behind it, and a tail is not a + // cursor; neither is remembered, so the next ask reads. + if limit > 0 && len(entries) >= limit || after == "" && len(entries) == 0 { + next = "" + } + w.mark(key, stamp, next) + return entries, stamp, nil +} + +func (w *Watch) quiet(key, stamp, after string) bool { + w.mu.Lock() + defer w.mu.Unlock() + m, ok := w.marks[key] + return ok && m.stamp == stamp && m.after == after +} + +func (w *Watch) mark(key, stamp, after string) { + w.mu.Lock() + defer w.mu.Unlock() + w.reads++ + if w.marks == nil { + w.marks = map[string]watchMark{} + } + if after == "" { + delete(w.marks, key) + return + } + w.marks[key] = watchMark{stamp: stamp, after: after} +} diff --git a/internal/teams/stamp_test.go b/internal/teams/stamp_test.go new file mode 100644 index 0000000000..6c02b11de1 --- /dev/null +++ b/internal/teams/stamp_test.go @@ -0,0 +1,110 @@ +package teams + +import ( + "errors" + "os" + "testing" + "time" +) + +// A STAMP MOVES WITH EVERY WRITE, EVEN INSIDE ONE CLOCK TICK. Two writes of the +// same size, with the file's time pinned in between as a coarse filesystem +// would leave it, still give two stamps; a file that is not there has the +// missing stamp, never "". +func TestStampMovesWithEveryWrite(t *testing.T) { + dir := t.TempDir() + if got := Stamp(dir); got != MissingStamp { + t.Fatalf("a missing file's stamp is %q", got) + } + one := []Team{{ID: "0a0a0a0a0a0a", Name: "aaaa"}} + two := []Team{{ID: "0a0a0a0a0a0a", Name: "bbbb"}} + if err := Save(dir, one); err != nil { + t.Fatal(err) + } + pinned := time.Now().Add(time.Hour) + if err := os.Chtimes(Path(dir), pinned, pinned); err != nil { + t.Fatal(err) + } + first := Stamp(dir) + if err := Save(dir, two); err != nil { + t.Fatal(err) + } + if second := Stamp(dir); second == first || second == "" { + t.Fatalf("a write of the same size did not move the stamp: %q then %q", first, second) + } + if !modTime(Path(dir)).After(pinned) { + t.Fatal("the write left the file's time behind the one it replaced") + } +} + +// CHANGEIF IS A COMPARE-AND-SWAP. At the stamp it was given it writes and +// answers the new stamp and the list it wrote; after another writer it is +// ErrStale, writes nothing and does not call its change. +func TestChangeIfRefusesAFileThatMoved(t *testing.T) { + dir := t.TempDir() + base := Stamp(dir) + f, stamp, err := ChangeIf(dir, base, func(f *File) error { + f.Teams = append(f.Teams, Team{ID: "0a0a0a0a0a0a", Name: "port"}) + return nil + }) + if err != nil || len(f.Teams) != 1 || stamp == base || stamp != Stamp(dir) { + t.Fatalf("the first swap: %+v, %q (base %q), %v", f, stamp, base, err) + } + if err := Update(dir, func(f *File) error { f.Teams[0].Name = "moved"; return nil }); err != nil { + t.Fatal(err) + } + called := false + _, _, err = ChangeIf(dir, stamp, func(f *File) error { called = true; return nil }) + if !errors.Is(err, ErrStale) || called { + t.Fatalf("a swap on a moved file answered %v (change called %v)", err, called) + } + got, _ := Load(dir) + if got.Teams[0].Name != "moved" { + t.Fatalf("the refused swap wrote: %+v", got.Teams) + } + // "" is a reader that never looked, and is always stale. + if _, _, err := ChangeIf(dir, "", func(*File) error { return nil }); !errors.Is(err, ErrStale) { + t.Fatalf("an empty base was taken: %v", err) + } +} + +// THE WATCH ANSWERS A QUIET LOG FROM A STAT. Asked again from the cursor its +// last read left, with nothing appended, it reads nothing; a line appended is +// found on the next ask; a full page is not remembered, so the rest is read. +func TestWatchReadsOnlyWhatMoved(t *testing.T) { + dir := t.TempDir() + const id = "harbor" + for i := 0; i < 3; i++ { + if err := AppendTraffic(dir, id, Entry{Kind: KindNote, From: "a", To: "b", Text: "x"}); err != nil { + t.Fatal(err) + } + } + var w Watch + got, _, err := w.Traffic(dir, id, "", 10) + if err != nil || len(got) != 3 { + t.Fatalf("the tail: %d entries, %v", len(got), err) + } + cursor := got[2].ID + reads := w.reads + for i := 0; i < 5; i++ { + if more, _, _ := w.Traffic(dir, id, cursor, 10); len(more) != 0 { + t.Fatalf("a quiet log answered %d entries", len(more)) + } + } + if w.reads != reads { + t.Fatalf("five quiet asks made %d reads", w.reads-reads) + } + if err := AppendTraffic(dir, id, Entry{Kind: KindNote, From: "a", To: "b", Text: "y"}); err != nil { + t.Fatal(err) + } + more, _, _ := w.Traffic(dir, id, cursor, 10) + if len(more) != 1 || more[0].Text != "y" { + t.Fatalf("the appended line: %+v", more) + } + // A page of exactly the limit is not a cursor to rest on. + page, _, _ := w.Traffic(dir, id, "000000000000", 2) + reads = w.reads + if _, _, _ = w.Traffic(dir, id, page[1].ID, 2); len(page) != 2 || w.reads != reads+1 { + t.Fatalf("a full page was remembered as the end (%d entries, %d reads)", len(page), w.reads-reads) + } +} diff --git a/internal/teams/store.go b/internal/teams/store.go new file mode 100644 index 0000000000..7f9d8ee3ec --- /dev/null +++ b/internal/teams/store.go @@ -0,0 +1,297 @@ +package teams + +import ( + "encoding/json" + "errors" + "fmt" + "os" + "path/filepath" + "strconv" + "time" + + "github.com/Agent-Field/codeaf/internal/config" + "github.com/Agent-Field/codeaf/internal/filelock" +) + +// The file's name inside the profile directory, and the first build's. +const ( + FileName = "teams.json" + LegacyFileName = "spaces.json" +) + +// lockWait is how long a write waits for another writer before it gives up +// with [ErrBusy]. A write holds the lock for one small read and one small +// write, so anything near this long is a writer that is stuck, and waiting on +// it for good would freeze whoever called. +const lockWait = 2 * time.Second + +// ErrBusy is another process holding the teams file's lock for longer than a +// write should take. Nothing was written. +var ErrBusy = errors.New("teams: the file is being written by somebody else; try again") + +// disk is the file's whole shape. Legacy is the first build's list, read and +// never written. +type disk struct { + Version int `json:"version"` + Teams []Team `json:"teams"` + Legacy []Team `json:"spaces,omitempty"` +} + +// Path is where the teams live. An empty profile directory is the ordinary +// launch and resolves to this process's own profile ([config.ProfilePath]). +func Path(profileDir string) string { return config.ProfilePath(profileDir, FileName) } + +func legacyPath(profileDir string) string { return config.ProfilePath(profileDir, LegacyFileName) } + +func lockPath(profileDir string) string { return Path(profileDir) + ".lock" } + +// Load reads the teams from profileDir and puts them in order ([tidy]). It +// takes no lock and does not wait: a repair it had to make is written back +// only when the lock is free at that moment, and is otherwise made again on +// the next load. Teams the file left without a colour stay without one; the +// interface, which knows the palette, uses [LoadHued]. +// +// A missing file is an empty File and no error. A file that is there but +// unreadable is an error and is left exactly as it was. +// +// THE FIRST BUILD'S FILE IS MIGRATED HERE, once. With no teams.json and a +// spaces.json beside it, the old list is read, written as teams.json, and only +// then is spaces.json renamed to spaces.json.migrated. +func Load(profileDir string) (*File, error) { return load(profileDir, false, nil) } + +// LoadHued is [Load] that also gives every uncoloured team a colour around +// the reserved hues ([File.Colour]) and writes that back as a repair. +func LoadHued(profileDir string, reserved []float64) (*File, error) { + return load(profileDir, true, reserved) +} + +func load(profileDir string, colour bool, reserved []float64) (*File, error) { + f, legacy, stale, err := read(profileDir) + if err != nil || f == nil { + return &File{Version: Version}, err + } + changed := tidy(f.Teams) + if colour && f.Colour(reserved) { + changed = true + } + if !legacy && !changed && !stale { + return f, nil + } + // Write the repair under the lock, reading afresh so a writer that got + // in between is not undone. A busy lock leaves the repair for next time. + var fresh *File + err = withLock(profileDir, 0, func() error { + g, gLegacy, _, err := read(profileDir) + if err != nil || g == nil { + return err + } + tidy(g.Teams) + if colour { + g.Colour(reserved) + } + if err := write(profileDir, g.Teams); err != nil { + return err + } + if gLegacy { + _ = os.Rename(legacyPath(profileDir), legacyPath(profileDir)+".migrated") + } + fresh = g + return nil + }) + if err == nil && fresh != nil { + return fresh, nil + } + return f, nil +} + +// read is the file as it is on disk, with no repair: nil for no file at all, +// legacy when it came from spaces.json, stale when it is an older version. +func read(profileDir string) (f *File, legacy, stale bool, err error) { + raw, err := os.ReadFile(Path(profileDir)) + if errors.Is(err, os.ErrNotExist) { + raw, err = os.ReadFile(legacyPath(profileDir)) + if errors.Is(err, os.ErrNotExist) { + return nil, false, false, nil + } + legacy = true + } + if err != nil { + return nil, false, false, err + } + var d disk + if err := json.Unmarshal(raw, &d); err != nil { + name := FileName + if legacy { + name = LegacyFileName + } + return nil, false, false, fmt.Errorf("teams: %s is unreadable: %w", name, err) + } + teams := d.Teams + if legacy || (d.Version < Version && len(teams) == 0) { + teams = d.Legacy + } + return &File{Version: Version, Teams: teams}, legacy, !legacy && d.Version < Version, nil +} + +// Save writes teams as the whole file, under the lock. It puts the list in +// order first, in place (ids, parents, handles, the manager), so the caller's +// memory and the disk agree afterwards. +// +// IT REPLACES WHATEVER IS ON DISK. A caller that loaded the file a while ago +// and saves its copy undoes any change another process made in between; a +// caller that shares the file should change it with [Update] instead. +func Save(profileDir string, teams []Team) error { + tidy(teams) + return withLock(profileDir, lockWait, func() error { return write(profileDir, teams) }) +} + +// Update is the one read-modify-write: under the exclusive lock it loads the +// file fresh (repaired, and migrated if it has not been), hands it to fn, and +// saves what fn left. An error from fn writes nothing and is returned. An +// unreadable file is returned as its error and fn is not called. A file that +// did not exist and that fn left with no teams is not created. +// +// Teams stay as coloured as they were; a team fn adds without [Team.SetHue] +// is coloured by the next [LoadHued]. +func Update(profileDir string, fn func(*File) error) error { + return withLock(profileDir, lockWait, func() error { + _, err := updateLocked(profileDir, fn) + return err + }) +} + +// updateLocked is [Update]'s body, for a caller that holds the lock. It +// answers the file as fn left it, tidied, which is what was written; a missing +// file that fn left with no teams is answered empty and is not created. +func updateLocked(profileDir string, fn func(*File) error) (*File, error) { + f, legacy, _, err := read(profileDir) + if err != nil { + return nil, err + } + missing := f == nil + if missing { + f = &File{Version: Version} + } + tidy(f.Teams) + if err := fn(f); err != nil { + return nil, err + } + if missing && len(f.Teams) == 0 { + return f, nil + } + tidy(f.Teams) + if err := write(profileDir, f.Teams); err != nil { + return nil, err + } + if legacy { + _ = os.Rename(legacyPath(profileDir), legacyPath(profileDir)+".migrated") + } + return f, nil +} + +// SetAside moves an unreadable teams file out of the way, to +// <name>.unreadable-<nanos> beside it, so that starting again does not +// overwrite a file that may hold every team a person made. It moves teams.json +// when there is one and spaces.json otherwise, and returns the new path. +func SetAside(profileDir string) (string, error) { + path := Path(profileDir) + if _, err := os.Stat(path); err != nil { + path = legacyPath(profileDir) + } + aside := path + ".unreadable-" + strconv.FormatInt(time.Now().UnixNano(), 10) + return aside, os.Rename(path, aside) +} + +// write puts the teams on disk all at once or not at all: the bytes go to a +// temporary file beside the real one and are renamed over it, so a crash +// mid-write leaves the previous file whole. The caller holds the lock. +func write(profileDir string, teams []Team) error { + path := Path(profileDir) + dir := filepath.Dir(path) + if teams == nil { + teams = []Team{} + } + raw, err := json.MarshalIndent(disk{Version: Version, Teams: teams}, "", " ") + if err != nil { + return err + } + if err := os.MkdirAll(dir, 0o700); err != nil { + return err + } + temp, err := os.CreateTemp(dir, FileName+".writing-*") + if err != nil { + return err + } + name := temp.Name() + if _, err := temp.Write(raw); err != nil { + _ = temp.Close() + _ = os.Remove(name) + return err + } + if err := temp.Close(); err != nil { + _ = os.Remove(name) + return err + } + // The time moves past the file this replaces, so its stamp moves + // (stamp.go); the caller holds the lock, so no other write is between. + before := modTime(path) + if err := os.Rename(name, path); err != nil { + _ = os.Remove(name) + return err + } + advance(path, before) + return nil +} + +// ── THE LOCK ──────────────────────────────────────────────────────────────── + +// withLock runs fn holding the exclusive lock on the teams file, waiting up to +// wait for it (0 is one try). +// +// A LOCK THAT CANNOT BE TAKEN IS NOT A REASON TO REFUSE A WRITE. A read-only +// directory or a filesystem with no advisory locking: fn runs unlocked, which +// is what a lone process has always done. A lock that is BUSY past the wait is +// the other answer, [ErrBusy], and fn does not run. The wait is non-blocking +// tries with backoff, never a blocking lock, so no caller can hang on a writer +// that never lets go. +func withLock(profileDir string, wait time.Duration, fn func() error) error { + return lockedAt(lockPath(profileDir), wait, fn) +} + +func lockedAt(path string, wait time.Duration, fn func() error) error { + if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { + return fn() + } + gate, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o600) + if err != nil { + return fn() + } + defer gate.Close() + held, err := take(gate, wait) + if err != nil { + return err + } + if held { + defer filelock.Unlock(gate) + } + return fn() +} + +// take tries for the lock until wait runs out. It answers held, not held with +// no error when the filesystem does not lock, or [ErrBusy]. +func take(gate *os.File, wait time.Duration) (bool, error) { + deadline := time.Now().Add(wait) + for pause := 2 * time.Millisecond; ; pause = min(pause*2, 50*time.Millisecond) { + err := filelock.Lock(gate, true, true) + if err == nil { + return true, nil + } + if !filelock.IsBusy(err) { + return false, nil + } + if !time.Now().Add(pause).Before(deadline) { + return false, ErrBusy + } + time.Sleep(pause) + } +} diff --git a/internal/teams/store_test.go b/internal/teams/store_test.go new file mode 100644 index 0000000000..17a92c311c --- /dev/null +++ b/internal/teams/store_test.go @@ -0,0 +1,487 @@ +package teams + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "os" + "path/filepath" + "reflect" + "strings" + "sync" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/config" +) + +// reservedForTest stands in for a palette's reserved hues. +var reservedForTest = []float64{70, 145, 25, 260} + +func TestSaveLoadRoundTrip(t *testing.T) { + dir := t.TempDir() + made := time.Date(2026, 9, 23, 10, 0, 0, 0, time.UTC) + want := []Team{ + {ID: "0a0a0a0a0a0a", Name: "port", Made: made, Hue: 40, hued: true, Members: []Member{{Key: "k1", File: "f1", Where: "/w/a", Word: "one", Handle: "one"}}}, + {ID: "0b0b0b0b0b0b", Name: "docs", Parent: "0a0a0a0a0a0a", Made: made, Hue: 0, Tier: 1, hued: true, Members: []Member{{Key: "k2", File: "f2", Where: "/w/b", Word: "two", Handle: "two"}}}, + } + if err := Save(dir, want); err != nil { + t.Fatal(err) + } + got, err := Load(dir) + if err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(got.Teams, want) { + t.Fatalf("round trip:\n got %#v\nwant %#v", got.Teams, want) + } + // The write is a rename, so nothing temporary is left beside the file; + // the lock is the only other thing there. + entries, _ := os.ReadDir(dir) + var names []string + for _, e := range entries { + names = append(names, e.Name()) + } + if strings.Join(names, ",") != FileName+","+FileName+".lock" { + t.Fatalf("profile holds %v", names) + } +} + +func TestMissingFileIsNoTeamsAndNoError(t *testing.T) { + dir := t.TempDir() + f, err := Load(dir) + if err != nil || f == nil || f.Teams != nil { + t.Fatalf("missing file: %+v, %v", f, err) + } + // Reading made nothing. + if entries, _ := os.ReadDir(dir); len(entries) != 0 { + t.Fatalf("a load of nothing left %v", entries) + } + // An Update that adds nothing does not create the file either. + if err := Update(dir, func(*File) error { return nil }); err != nil { + t.Fatal(err) + } + if _, err := os.Stat(Path(dir)); !os.IsNotExist(err) { + t.Fatalf("an empty update created the file: %v", err) + } +} + +// AN EMPTY PROFILE DIRECTORY IS THE ORDINARY LAUNCH: the file and the Traffic +// log go to this process's own profile, never nowhere. +func TestTheOrdinaryLaunchIsTheProfilesOwn(t *testing.T) { + if got, want := Path(""), config.ProfilePath("", FileName); got != want || !filepath.IsAbs(got) { + t.Fatalf("teams at %q, the profile keeps its files at %q", got, want) + } + if got, want := TrafficPath("", "abc"), config.ProfilePath("", filepath.Join("teams", "abc", "traffic.jsonl")); got != want || !filepath.IsAbs(got) { + t.Fatalf("traffic at %q, want %q", got, want) + } +} + +func TestCorruptFileErrorsIsNotClobberedAndCanBeSetAside(t *testing.T) { + dir := t.TempDir() + bad := []byte("{not json") + if err := os.WriteFile(Path(dir), bad, 0o600); err != nil { + t.Fatal(err) + } + if _, err := Load(dir); err == nil { + t.Fatal("corrupt file loaded without error") + } + called := false + if err := Update(dir, func(*File) error { called = true; return nil }); err == nil || called { + t.Fatalf("update over a corrupt file: err %v, fn called %v", err, called) + } + if raw, _ := os.ReadFile(Path(dir)); string(raw) != string(bad) { + t.Fatalf("the file became %q", raw) + } + aside, err := SetAside(dir) + if err != nil { + t.Fatal(err) + } + if raw, _ := os.ReadFile(aside); string(raw) != string(bad) || !strings.HasPrefix(aside, Path(dir)+".unreadable-") { + t.Fatalf("set aside to %s holding %q", aside, raw) + } +} + +// THE FIRST BUILD'S FILE BECOMES TEAMS, ONCE, AND NOTHING IS LOST. +func TestMigratesTheFirstBuildsFile(t *testing.T) { + dir := t.TempDir() + v1 := `{"spaces":[` + + `{"name":"harbor","members":[{"key":"k1","file":"f1","where":"/w/a","word":"one"}],"made":"2026-09-20T10:00:00Z"},` + + `{"name":"orbit","members":[{"key":"k2"}],"made":"2026-09-21T10:00:00Z","hue":200,"tier":0},` + + `{"name":"lumen","members":[]}]}` + legacy := filepath.Join(dir, LegacyFileName) + if err := os.WriteFile(legacy, []byte(v1), 0o600); err != nil { + t.Fatal(err) + } + // The colours the first build gave this file, worked out the way it did. + first := &File{} + if err := json.Unmarshal([]byte(`[{"name":"harbor"},{"name":"orbit","hue":200},{"name":"lumen"}]`), &first.Teams); err != nil { + t.Fatal(err) + } + first.Colour(reservedForTest) + + f, err := LoadHued(dir, reservedForTest) + if err != nil { + t.Fatal(err) + } + got := f.Teams + if len(got) != 3 || got[0].Name != "harbor" || got[1].Name != "orbit" || got[2].Name != "lumen" { + t.Fatalf("migrated %+v", got) + } + if !reflect.DeepEqual(got[0].Members, []Member{{Key: "k1", File: "f1", Where: "/w/a", Word: "one", Handle: "one", HandleBy: HandleByWords}}) { + t.Fatalf("members lost: %+v", got[0].Members) + } + seen := map[string]bool{} + for i, tm := range got { + if len(tm.ID) != 12 || strings.Trim(tm.ID, "0123456789abcdef") != "" || seen[tm.ID] { + t.Fatalf("team %d has id %q", i, tm.ID) + } + seen[tm.ID] = true + if tm.Parent != "" || tm.Manager != "" { + t.Fatalf("team %d came up with parent %q manager %q", i, tm.Parent, tm.Manager) + } + if tm.HueSpec() != first.Teams[i].HueSpec() { + t.Fatalf("team %d drawn %v before and %v after", i, first.Teams[i].HueSpec(), tm.HueSpec()) + } + } + if _, err := os.Stat(legacy); !os.IsNotExist(err) { + t.Fatalf("spaces.json is still there: %v", err) + } + if raw, err := os.ReadFile(legacy + ".migrated"); err != nil || string(raw) != v1 { + t.Fatalf("the old file was not kept as it was: %q %v", raw, err) + } + raw, err := os.ReadFile(Path(dir)) + if err != nil { + t.Fatal(err) + } + var d struct { + Version int `json:"version"` + Teams []json.RawMessage `json:"teams"` + } + if err := json.Unmarshal(raw, &d); err != nil || d.Version != 2 || len(d.Teams) != 3 { + t.Fatalf("teams.json is %s", raw) + } + again, err := LoadHued(dir, reservedForTest) + if err != nil || !reflect.DeepEqual(again.Teams, got) { + t.Fatalf("reloaded %+v, %v", again, err) + } +} + +// A MIGRATION THROUGH Update is the same migration: the writer that gets there +// first carries the old list over. +func TestUpdateMigratesTheFirstBuildsFile(t *testing.T) { + dir := t.TempDir() + legacy := filepath.Join(dir, LegacyFileName) + if err := os.WriteFile(legacy, []byte(`{"spaces":[{"name":"harbor","members":[{"key":"k1","word":"one"}]}]}`), 0o600); err != nil { + t.Fatal(err) + } + if err := Update(dir, func(f *File) error { + if len(f.Teams) != 1 || f.Teams[0].Name != "harbor" { + return fmt.Errorf("update saw %+v", f.Teams) + } + return f.SetManager(f.Teams[0].ID, "k1") + }); err != nil { + t.Fatal(err) + } + if _, err := os.Stat(legacy + ".migrated"); err != nil { + t.Fatalf("spaces.json not moved aside: %v", err) + } + f, _ := Load(dir) + if len(f.Teams) != 1 || f.Teams[0].Manager != "k1" { + t.Fatalf("after update: %+v", f.Teams) + } +} + +// A TEAMS FILE ALREADY THERE WINS, and the old one is left alone. +func TestMigrationLeavesTheOldFileWhenTeamsExist(t *testing.T) { + dir := t.TempDir() + if err := Save(dir, []Team{{ID: "aaaaaaaaaaaa", Name: "kept", hued: true}}); err != nil { + t.Fatal(err) + } + legacy := filepath.Join(dir, LegacyFileName) + if err := os.WriteFile(legacy, []byte(`{"spaces":[{"name":"old"}]}`), 0o600); err != nil { + t.Fatal(err) + } + f, err := LoadHued(dir, nil) + if err != nil || len(f.Teams) != 1 || f.Teams[0].Name != "kept" { + t.Fatalf("loaded %+v %v", f, err) + } + if _, err := os.Stat(legacy); err != nil { + t.Fatalf("spaces.json was moved though teams.json was there: %v", err) + } +} + +// WHAT A LATER BUILD WROTE SURVIVES THIS ONE, through Load and Save and +// through Update. +func TestRoundTripKeepsUnknownFieldsAndTheManager(t *testing.T) { + dir := t.TempDir() + in := `{"version":2,"teams":[{"id":"abcdefabcdef","name":"harbor","parent":"","members":[{"key":"k1","file":"","where":"","word":""}],` + + `"manager":"k1","hue":120,"tier":1,"made":"2026-09-20T10:00:00Z","pinned":true,"rules":{"quiet":["k2"]}}]}` + if err := os.WriteFile(Path(dir), []byte(in), 0o600); err != nil { + t.Fatal(err) + } + f, err := Load(dir) + if err != nil || len(f.Teams) != 1 || f.Teams[0].Manager != "k1" { + t.Fatalf("loaded %+v %v", f, err) + } + check := func(when string) { + t.Helper() + raw, _ := os.ReadFile(Path(dir)) + var d struct { + Teams []map[string]json.RawMessage `json:"teams"` + } + if err := json.Unmarshal(raw, &d); err != nil || len(d.Teams) != 1 { + t.Fatalf("%s: saved %s", when, raw) + } + for key, want := range map[string]string{"pinned": `true`, "rules": `{"quiet":["k2"]}`, "manager": `"k1"`, "id": `"abcdefabcdef"`, "hue": `120`, "tier": `1`} { + var flat bytes.Buffer + if err := json.Compact(&flat, d.Teams[0][key]); err != nil || flat.String() != want { + t.Fatalf("%s: %s saved as %s, want %s\n%s", when, key, d.Teams[0][key], want, raw) + } + } + } + if err := Save(dir, f.Teams); err != nil { + t.Fatal(err) + } + check("save") + if err := Update(dir, func(f *File) error { f.Teams[0].Name = "dock"; return nil }); err != nil { + t.Fatal(err) + } + check("update") +} + +// A TEAM WITH NO COLOUR IS WRITTEN WITH NONE by a writer that has no palette, +// so the interface still colours it on its next load rather than reading 0 as +// a choice. +func TestAnUncolouredTeamStaysUncolouredWithoutAPalette(t *testing.T) { + dir := t.TempDir() + if err := os.WriteFile(Path(dir), []byte(`{"version":2,"teams":[{"id":"aaaaaaaaaaaa","name":"a","members":[]}]}`), 0o600); err != nil { + t.Fatal(err) + } + if err := Update(dir, func(f *File) error { f.Teams[0].Name = "b"; return nil }); err != nil { + t.Fatal(err) + } + if raw, _ := os.ReadFile(Path(dir)); strings.Contains(string(raw), `"hue"`) { + t.Fatalf("a writer without a palette invented a colour:\n%s", raw) + } + f, _ := LoadHued(dir, reservedForTest) + if !f.Teams[0].Hued() { + t.Fatal("the palette's load left the team uncoloured") + } + if raw, _ := os.ReadFile(Path(dir)); !strings.Contains(string(raw), `"hue"`) { + t.Fatalf("the colour was not written back:\n%s", raw) + } +} + +// TWO WRITERS NEVER LOSE A WRITE. Each Update reads the file fresh under the +// lock, so every member either goroutine adds is there at the end. +func TestConcurrentUpdatesNeverLoseAWrite(t *testing.T) { + dir := t.TempDir() + if err := Save(dir, []Team{{ID: "aaaaaaaaaaaa", Name: "busy"}}); err != nil { + t.Fatal(err) + } + const each = 40 + var wg sync.WaitGroup + errs := make(chan error, 2*each) + for w := 0; w < 2; w++ { + wg.Add(1) + go func(w int) { + defer wg.Done() + for i := 0; i < each; i++ { + key := fmt.Sprintf("w%d-%d", w, i) + errs <- Update(dir, func(f *File) error { + return f.AddMember("aaaaaaaaaaaa", Member{Key: key, Word: "task " + key}) + }) + } + }(w) + } + wg.Wait() + close(errs) + for err := range errs { + if err != nil { + t.Fatal(err) + } + } + f, err := Load(dir) + if err != nil { + t.Fatal(err) + } + if n := len(f.Teams[0].Members); n != 2*each { + t.Fatalf("%d members after %d adds", n, 2*each) + } + handles := map[string]bool{} + for _, m := range f.Teams[0].Members { + if m.Handle == "" || handles[m.Handle] { + t.Fatalf("handle %q missing or repeated", m.Handle) + } + handles[m.Handle] = true + } +} + +// A WRITER THAT HOLDS THE LOCK TOO LONG IS A REFUSAL, NOT A WAIT FOREVER, and +// the refused write touched nothing. +func TestABusyLockIsRefusedAfterTheWait(t *testing.T) { + dir := t.TempDir() + if err := Save(dir, []Team{{ID: "aaaaaaaaaaaa", Name: "a"}}); err != nil { + t.Fatal(err) + } + release := make(chan struct{}) + held := make(chan struct{}) + go func() { + _ = withLock(dir, lockWait, func() error { + close(held) + <-release + return nil + }) + }() + <-held + defer close(release) + err := lockedAt(lockPath(dir), 20*time.Millisecond, func() error { + t.Error("ran under a lock somebody else holds") + return nil + }) + if !errors.Is(err, ErrBusy) { + t.Fatalf("a held lock answered %v", err) + } + // A load does not wait on it. + start := time.Now() + if _, err := Load(dir); err != nil || time.Since(start) > time.Second { + t.Fatalf("load under a held lock: %v after %v", err, time.Since(start)) + } +} + +// A FILE THAT LOOPS OR NAMES A MISSING PARENT IS PUT RIGHT ON LOAD. +func TestLoadCutsLoopsAndMissingParents(t *testing.T) { + dir := t.TempDir() + in := `{"version":2,"teams":[` + + `{"id":"aaaaaaaaaaaa","name":"a","parent":"bbbbbbbbbbbb","hue":1},` + + `{"id":"bbbbbbbbbbbb","name":"b","parent":"aaaaaaaaaaaa","hue":2},` + + `{"id":"cccccccccccc","name":"c","parent":"gone00000000","hue":3}]}` + if err := os.WriteFile(Path(dir), []byte(in), 0o600); err != nil { + t.Fatal(err) + } + f, err := Load(dir) + if err != nil { + t.Fatal(err) + } + got := f.Teams + if got[2].Parent != "" { + t.Fatalf("a missing parent was kept: %q", got[2].Parent) + } + if ParentLoops(got, got[0].ID, got[0].Parent) || ParentLoops(got, got[1].ID, got[1].Parent) { + t.Fatalf("the loop is still there: %+v", got) + } +} + +// REPAIRS ON LOAD: a repeated id gets a new one, a manager who is not a member +// is cleared, members with titles get handles, and all of it is written back. +func TestLoadRepairsIdsManagersAndHandles(t *testing.T) { + dir := t.TempDir() + in := `{"version":2,"teams":[` + + `{"id":"aaaaaaaaaaaa","name":"a","manager":"gone","hue":1,"members":[{"key":"k1","word":"Fix the login bug"},{"key":"k2","word":"Fix login page"},{"key":"k3","word":""}]},` + + `{"id":"aaaaaaaaaaaa","name":"b","hue":2}]}` + if err := os.WriteFile(Path(dir), []byte(in), 0o600); err != nil { + t.Fatal(err) + } + f, err := Load(dir) + if err != nil { + t.Fatal(err) + } + if f.Teams[0].ID == f.Teams[1].ID { + t.Fatal("a repeated id was kept") + } + if f.Teams[0].Manager != "" { + t.Fatalf("a manager who is not a member was kept: %q", f.Teams[0].Manager) + } + var handles []string + for _, m := range f.Teams[0].Members { + handles = append(handles, m.Handle) + } + if strings.Join(handles, ",") != "login,page," { + t.Fatalf("handles %q", handles) + } + again, _ := Load(dir) + if !reflect.DeepEqual(again.Teams, f.Teams) { + t.Fatalf("the repair was not written:\n%+v\n%+v", again.Teams, f.Teams) + } +} + +// A FILE FROM BEFORE THE WRAP-UP CLOCK HAS NO wrap KEY, and loading it leaves +// the team with none. Writing it back does not invent one. +func TestAnOldTeamsFileLoadsWithNoWrapUp(t *testing.T) { + dir := t.TempDir() + in := `{"version":2,"teams":[{"id":"abcdefabcdef","name":"harbor","parent":"","members":[{"key":"k1","file":"","where":"","word":"one"}],` + + `"manager":"k1","hue":120,"tier":1,"made":"2026-09-20T10:00:00Z"}]}` + if err := os.WriteFile(Path(dir), []byte(in), 0o600); err != nil { + t.Fatal(err) + } + f, err := Load(dir) + if err != nil || len(f.Teams) != 1 || f.Teams[0].Wrap != nil || f.Teams[0].Name != "harbor" { + t.Fatalf("old file: %+v %v", f, err) + } + if err := Save(dir, f.Teams); err != nil { + t.Fatal(err) + } + raw, err := os.ReadFile(Path(dir)) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(raw), `"wrap"`) { + t.Fatalf("an old team grew a wrap key:\n%s", raw) + } +} + +// THE CLOCK SURVIVES THE FILE. Change writes the start and the bound, the +// stamp moves, a reload reads them back, and a second SetWrap keeps the first. +func TestWrapUpRoundTripThroughChange(t *testing.T) { + dir := t.TempDir() + started := time.Date(2026, 9, 24, 15, 4, 0, 0, time.UTC) + bound := 15 * time.Minute + if err := Save(dir, []Team{{ID: "abcdefabcdef", Name: "harbor", hued: true, Hue: 1}}); err != nil { + t.Fatal(err) + } + before := Stamp(dir) + wrote, stamp, err := Change(dir, func(f *File) error { + return f.SetWrap("abcdefabcdef", started, bound) + }) + if err != nil { + t.Fatal(err) + } + if stamp == before || stamp == MissingStamp || stamp != Stamp(dir) { + t.Fatalf("stamp %q, was %q, file %q", stamp, before, Stamp(dir)) + } + if wrote == nil || wrote.Teams[0].Wrap == nil || !wrote.Teams[0].Wrap.Started.Equal(started) || wrote.Teams[0].Wrap.Bound != bound { + t.Fatalf("wrote %+v", wrote) + } + got, err := Load(dir) + if err != nil || got.Teams[0].Wrap == nil || !got.Teams[0].Wrap.Started.Equal(started) || got.Teams[0].Wrap.Bound != bound { + t.Fatalf("reloaded %+v %v", got, err) + } + later := started.Add(time.Hour) + if _, _, err := Change(dir, func(f *File) error { + return f.SetWrap("abcdefabcdef", later, time.Minute) + }); err != nil { + t.Fatal(err) + } + got, _ = Load(dir) + if !got.Teams[0].Wrap.Started.Equal(started) || got.Teams[0].Wrap.Bound != bound { + t.Fatalf("a second wrap-up reset the clock: %+v", got.Teams[0].Wrap) + } + if _, _, err := ChangeIf(dir, "not-the-stamp", func(f *File) error { + return f.ClearWrap("abcdefabcdef") + }); !errors.Is(err, ErrStale) { + t.Fatalf("a stale clear: %v", err) + } + if _, _, err := Change(dir, func(f *File) error { return f.ClearWrap("abcdefabcdef") }); err != nil { + t.Fatal(err) + } + got, _ = Load(dir) + if got.Teams[0].Wrap != nil { + t.Fatalf("cleared wrap still there: %+v", got.Teams[0].Wrap) + } + raw, _ := os.ReadFile(Path(dir)) + if strings.Contains(string(raw), `"wrap"`) { + t.Fatalf("a cleared wrap was still written:\n%s", raw) + } +} diff --git a/internal/teams/teams.go b/internal/teams/teams.go new file mode 100644 index 0000000000..2696503522 --- /dev/null +++ b/internal/teams/teams.go @@ -0,0 +1,547 @@ +package teams + +import ( + "bytes" + "crypto/rand" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "sort" + "strconv" + "time" +) + +// Version is the file format this build writes. +const Version = 2 + +// Member is one conversation a team holds, with enough to reopen it when no +// window has it open. +type Member struct { + Key string `json:"key"` + File string `json:"file"` + Where string `json:"where"` + Word string `json:"word"` + // Handle is the member's short name inside this team (handle.go). It is + // empty only while the member has no title to derive one from. + Handle string `json:"handle,omitempty"` + // Home marks the one membership, among all of this conversation's, that + // names the manager it reports to (home.go): the nearest manager up this + // team's chain. At most one membership of a key carries it, and only one + // with a manager somewhere up its chain. [File.SetHome] moves it; tidy + // picks it when there is none and never moves a valid one. + Home bool `json:"home,omitempty"` + // Started says this membership was made by the team manager's team_start + // (a [KindStart] the interface carried out), which is the second rule a + // home is picked by. + Started bool `json:"started,omitempty"` + // HandleBy is who chose Handle: [HandleByWords] for the word list's + // instant guess, [HandleByModel] for the title model's word, and + // [HandleByTyped] for a handle a person or the manager gave. "" is a + // handle written before this was kept, and is read as the word list's + // ([Member.HandleDerived]). + HandleBy string `json:"handle_by,omitempty"` +} + +// Team is one named set of conversations. +type Team struct { + // ID is random and minted once ([NewID]). + ID string + Name string + // Parent is the id of the team this one sits under, "" at the top level. + Parent string + // Members are the conversations, in the order the person stored them. + Members []Member + // Manager is the conversation key of the member that manages the team, "" + // for none. It is always one of Members. + Manager string + // Hue and Tier are the team's colour (hue.go). + Hue float64 + Tier int + Made time.Time + // State is [TeamOpen] or [TeamClosed] (lifecycle.go); the empty string a + // file from before the lifecycle wrote reads as open. ClosedAt is when it + // closed, ClosedWith the id of the team whose close closed it (itself, or + // the ancestor a cascade came from), and Report the id of its closing + // report packet, "" for a team closed without one. + State string + ClosedAt time.Time + ClosedWith string + Report string + // Root marks the one team that holds every other (root.go): the `All + // teams` row, made when the person gives it a manager. + Root bool + // Settings are the team's own delegation overrides (teamsettings.go), + // each unset field inheriting from the parent chain and then the + // profile's `teams.` defaults. They are stored flat on the team. + Settings Settings + // Wrap is a wrap-up in progress (wrap.go): when it started and how long + // it was given. Nil is none, which is also what a file from before the + // field was kept reads as. + Wrap *Wrap + + // hued says the team has a colour: the file gave it one or [Team.SetHue] + // did. A hue of 0 is a real hue, so absence is kept apart from the value. + // extra is every field a later build wrote that this one does not know. + hued bool + extra map[string]json.RawMessage +} + +// File is the whole of teams.json. +type File struct { + Version int + Teams []Team +} + +// knownFields is every key [Team] reads itself. +var knownFields = map[string]bool{ + "id": true, "name": true, "parent": true, "members": true, "manager": true, + "hue": true, "tier": true, "made": true, + "state": true, "closed_at": true, "closed_with": true, "report": true, "root": true, + "questions_up": true, "cap_usd_day": true, "depth_limit": true, "sub_share": true, "wake": true, + "wrap": true, +} + +// wireTeam is the stored shape. Hue and Tier are pointers so a team with no +// colour is written without one, and the next reader with a palette colours +// it rather than reading 0 as a choice. +type wireTeam struct { + ID string `json:"id"` + Name string `json:"name"` + Parent string `json:"parent"` + Members []Member `json:"members"` + Manager string `json:"manager"` + Hue *float64 `json:"hue,omitempty"` + Tier *int `json:"tier,omitempty"` + Made time.Time `json:"made"` + // The lifecycle, written only for a closed team. + State string `json:"state,omitempty"` + ClosedAt *time.Time `json:"closed_at,omitempty"` + ClosedWith string `json:"closed_with,omitempty"` + Report string `json:"report,omitempty"` + Root bool `json:"root,omitempty"` + // Wrap is written only while a wrap-up is in progress, so a team with + // none is written exactly as before. + Wrap *Wrap `json:"wrap,omitempty"` + // The overrides are written flat beside the fields above, each only when + // set, so a team with none is written exactly as before. + Settings +} + +// UnmarshalJSON reads a team, keeping every field it does not know. +func (t *Team) UnmarshalJSON(raw []byte) error { + var w wireTeam + if err := json.Unmarshal(raw, &w); err != nil { + return err + } + var all map[string]json.RawMessage + if err := json.Unmarshal(raw, &all); err != nil { + return err + } + *t = Team{ID: w.ID, Name: w.Name, Parent: w.Parent, Members: w.Members, Manager: w.Manager, Made: w.Made, + Settings: w.Settings, State: w.State, ClosedWith: w.ClosedWith, Report: w.Report, Root: w.Root, Wrap: w.Wrap} + if w.ClosedAt != nil { + t.ClosedAt = *w.ClosedAt + } + if w.Hue != nil { + t.Hue, t.hued = *w.Hue, true + } + if w.Tier != nil { + t.Tier = *w.Tier + } + for k, v := range all { + if knownFields[k] { + continue + } + if t.extra == nil { + t.extra = map[string]json.RawMessage{} + } + t.extra[k] = v + } + return nil +} + +// MarshalJSON writes the known fields in their order, then any field a later +// build wrote, sorted, exactly as it was read. +func (t Team) MarshalJSON() ([]byte, error) { + w := wireTeam{ID: t.ID, Name: t.Name, Parent: t.Parent, Members: t.Members, Manager: t.Manager, Made: t.Made, + Settings: t.Settings, ClosedWith: t.ClosedWith, Report: t.Report, Root: t.Root, Wrap: t.Wrap} + // A state this build does not know is written back as it was read, so a + // later build's word survives; open is written as nothing. + if t.State != "" && t.State != TeamOpen { + w.State = t.State + } + if !t.ClosedAt.IsZero() { + at := t.ClosedAt + w.ClosedAt = &at + } + if t.Hued() { + hue, tier := t.Hue, t.Tier + w.Hue, w.Tier = &hue, &tier + } + raw, err := json.Marshal(w) + if err != nil || len(t.extra) == 0 { + return raw, err + } + keys := make([]string, 0, len(t.extra)) + for k := range t.extra { + keys = append(keys, k) + } + sort.Strings(keys) + var b bytes.Buffer + b.Write(raw[:len(raw)-1]) + for _, k := range keys { + name, _ := json.Marshal(k) + b.WriteByte(',') + b.Write(name) + b.WriteByte(':') + b.Write(t.extra[k]) + } + b.WriteByte('}') + return b.Bytes(), nil +} + +// Wakes reports whether the team's OWN setting leaves waking on: true unless +// the team itself says "wake": false. It does not walk the chain; whether team +// traffic really wakes a conversation is [Effective].Wake, which inherits. +func (t Team) Wakes() bool { return t.Settings.Wake == nil || *t.Settings.Wake } + +// Hued reports whether the team has a colour. A team built in code with a +// non-zero hue or tier counts as coloured. +func (t Team) Hued() bool { return t.hued || t.Hue != 0 || t.Tier != 0 } + +// HueSpec is the team's colour. +func (t Team) HueSpec() HueSpec { return HueSpec{Hue: t.Hue, Tier: t.Tier} } + +// SetHue gives the team a colour. +func (t *Team) SetHue(h HueSpec) { t.Hue, t.Tier, t.hued = h.Hue, h.Tier, true } + +// Holds reports whether key is one of the team's members. +func (t Team) Holds(key string) bool { return t.member(key) >= 0 } + +// Member is the member with key. +func (t Team) Member(key string) (Member, bool) { + if i := t.member(key); i >= 0 { + return t.Members[i], true + } + return Member{}, false +} + +// ByHandle is the member with handle. +func (t Team) ByHandle(handle string) (Member, bool) { + for _, m := range t.Members { + if handle != "" && m.Handle == handle { + return m, true + } + } + return Member{}, false +} + +func (t Team) member(key string) int { + if key == "" { + return -1 + } + for i, m := range t.Members { + if m.Key == key { + return i + } + } + return -1 +} + +// Clone is a copy of t that shares nothing with it. +func (t Team) Clone() Team { + t.Members = append([]Member(nil), t.Members...) + t.Settings = t.Settings.clone() + if t.Wrap != nil { + w := *t.Wrap + t.Wrap = &w + } + if t.extra != nil { + extra := make(map[string]json.RawMessage, len(t.extra)) + for k, v := range t.extra { + extra[k] = v + } + t.extra = extra + } + return t +} + +// NewID is a fresh random team id: twelve hex digits, never derived from the +// name, so a rename is a rename and two teams once called the same are two. +func NewID() string { + var b [6]byte + if _, err := rand.Read(b[:]); err != nil { + return strconv.FormatInt(time.Now().UnixNano()&0xffffffffffff, 16) + } + return hex.EncodeToString(b[:]) +} + +// ── THE TREE ──────────────────────────────────────────────────────────────── + +// Index is where the team with id sits in teams, -1 when it is not there. +func Index(teams []Team, id string) int { + if id == "" { + return -1 + } + for i, t := range teams { + if t.ID == id { + return i + } + } + return -1 +} + +// ParentLoops reports whether making parent the parent of id would close a +// loop: whether id is parent itself or one of parent's ancestors. The walk is +// bounded by the list, so a loop already in the list cannot hang it. +func ParentLoops(teams []Team, id, parent string) bool { + for at, steps := parent, 0; at != "" && steps <= len(teams); steps++ { + if at == id { + return true + } + i := Index(teams, at) + if i < 0 { + return false + } + at = teams[i].Parent + } + return false +} + +// Team is the team with id. +func (f *File) Team(id string) (Team, bool) { + if i := Index(f.Teams, id); i >= 0 { + return f.Teams[i], true + } + return Team{}, false +} + +// Children is every team whose parent is id, in stored order; "" is the top +// level. +func (f *File) Children(id string) []Team { + var out []Team + for _, t := range f.Teams { + if t.Parent == id { + out = append(out, t) + } + } + return out +} + +// Ancestors is id's parent, its parent's parent, and so on to the top, +// nearest first. +func (f *File) Ancestors(id string) []Team { + var out []Team + t, ok := f.Team(id) + for ok && t.Parent != "" && len(out) < len(f.Teams) { + t, ok = f.Team(t.Parent) + if ok { + out = append(out, t) + } + } + return out +} + +// SetParent puts team id under parent, or at the top level for "". The parent +// must exist and may not be the team or anything under it. +func (f *File) SetParent(id, parent string) error { + i, err := f.at(id) + if err != nil { + return err + } + if f.Teams[i].Root && parent != "" { + return ErrRoot + } + if parent != "" { + if Index(f.Teams, parent) < 0 { + return fmt.Errorf("no team %s", parent) + } + if ParentLoops(f.Teams, id, parent) { + return errors.New("a team cannot sit under itself") + } + } + f.Teams[i].Parent = parent + return nil +} + +func (f *File) at(id string) (int, error) { + if i := Index(f.Teams, id); i >= 0 { + return i, nil + } + return -1, fmt.Errorf("no team %s", id) +} + +// ── MEMBERS AND THE MANAGER ───────────────────────────────────────────────── + +// AddMember puts m into team id after the members it has, and gives it a +// handle if it has a title. A key already there is left as it is. +func (f *File) AddMember(id string, m Member) error { + i, err := f.at(id) + if err != nil { + return err + } + if m.Key == "" { + return errors.New("a member needs a conversation key") + } + t := &f.Teams[i] + if t.Holds(m.Key) { + return nil + } + if m.Handle != "" && handleProblem(*t, m.Key, m.Handle) != nil { + m.Handle = "" + } + // A handle that arrives with the member was given, not guessed: the + // manager's team_start names the member it starts, and that name is kept. + switch { + case m.Handle == "": + m.HandleBy = "" + case m.HandleBy == "": + m.HandleBy = HandleByTyped + } + t.Members = append(t.Members, m) + assignHandles(t) + return nil +} + +// RemoveMember takes the conversation with key out of team id. The team is +// kept even when it is left empty, and a manager removed is no longer one. +func (f *File) RemoveMember(id, key string) error { + i, err := f.at(id) + if err != nil { + return err + } + t := &f.Teams[i] + if j := t.member(key); j >= 0 { + t.Members = append(t.Members[:j:j], t.Members[j+1:]...) + } + if t.Manager == key { + t.Manager = "" + } + return nil +} + +// SetManager makes the conversation with key team id's manager. A team has +// one manager, so this replaces any other. A conversation that is not a member +// is added first, with only its key; call [File.AddMember] before this to add +// it with its title and file. +func (f *File) SetManager(id, key string) error { + if key == "" { + return errors.New("a manager needs a conversation key") + } + if err := f.AddMember(id, Member{Key: key}); err != nil { + return err + } + f.Teams[Index(f.Teams, id)].Manager = key + return nil +} + +// ClearManager leaves team id without a manager. The conversation stays a +// member. +func (f *File) ClearManager(id string) error { + i, err := f.at(id) + if err != nil { + return err + } + f.Teams[i].Manager = "" + return nil +} + +// SetHandle gives the member with key in team id the handle h. It must be a +// valid handle ([ValidHandle]) that no other member of the team has. It is a +// handle given, never guessed, and nothing replaces it ([HandleByTyped]). +func (f *File) SetHandle(id, key, h string) error { + i, err := f.at(id) + if err != nil { + return err + } + t := &f.Teams[i] + j := t.member(key) + if j < 0 { + return fmt.Errorf("%s is not in team %s", key, t.Name) + } + if err := handleProblem(*t, key, h); err != nil { + return err + } + t.Members[j].Handle, t.Members[j].HandleBy = h, HandleByTyped + return nil +} + +// ── REPAIRS ───────────────────────────────────────────────────────────────── + +// tidy puts a list in order, in place, and reports whether it changed +// anything: an id for every team (and a new one for an id used twice), a +// parent that exists and does not lead back, handles for members with titles +// and no valid unique handle, a manager that is a member, overrides inside +// their bands, and one home for every conversation that has a manager to +// report to (home.go). Colour is not its business ([File.Colour] is). +func tidy(teams []Team) bool { + changed := false + seen := map[string]bool{} + for i := range teams { + if teams[i].ID == "" || seen[teams[i].ID] { + teams[i].ID = NewID() + changed = true + } + seen[teams[i].ID] = true + } + for i := range teams { + if p := teams[i].Parent; p != "" && (!seen[p] || p == teams[i].ID) { + teams[i].Parent = "" + changed = true + } + } + // A loop in the file is cut where it is first met. + for i := range teams { + if teams[i].Parent != "" && ParentLoops(teams, teams[i].ID, teams[i].Parent) { + teams[i].Parent = "" + changed = true + } + } + for i := range teams { + if assignHandles(&teams[i]) { + changed = true + } + if m := teams[i].Manager; m != "" && !teams[i].Holds(m) { + teams[i].Manager = "" + changed = true + } + if teams[i].Settings.tidy() { + changed = true + } + } + // The root holds every other top-level team (root.go). + if tidyRoot(teams) { + changed = true + } + // Homes last: they depend on the managers and parents settled above. + if assignHomes(teams) { + changed = true + } + return changed +} + +// Colour gives every team without a colour one from the generator, in file +// order, around the ones that have theirs, and reports whether it gave any. +// It depends on nothing but the list and reserved, so the same file is +// coloured the same way on every load. +func (f *File) Colour(reserved []float64) bool { + var used []HueSpec + for _, t := range f.Teams { + if t.Hued() { + used = append(used, t.HueSpec()) + } + } + changed := false + for i := range f.Teams { + if f.Teams[i].Hued() { + continue + } + next := NextHue(used, reserved) + next.Tier = TierFor(i) + f.Teams[i].SetHue(next) + used = append(used, next) + changed = true + } + return changed +} diff --git a/internal/teams/teams_test.go b/internal/teams/teams_test.go new file mode 100644 index 0000000000..4e848d9229 --- /dev/null +++ b/internal/teams/teams_test.go @@ -0,0 +1,211 @@ +package teams + +import ( + "encoding/json" + "strings" + "testing" +) + +func treeFile() *File { + return &File{Teams: []Team{ + {ID: "top", Name: "top"}, {ID: "mid", Name: "mid"}, {ID: "low", Name: "low"}, {ID: "other", Name: "other"}, + }} +} + +func names(ts []Team) string { + var out []string + for _, t := range ts { + out = append(out, t.Name) + } + return strings.Join(out, ",") +} + +// THE TREE: one parent, which exists, and no loops. +func TestTreeRefusesLoops(t *testing.T) { + f := treeFile() + if err := f.SetParent("mid", "top"); err != nil { + t.Fatal(err) + } + if err := f.SetParent("low", "mid"); err != nil { + t.Fatal(err) + } + for _, c := range []struct{ id, parent, why string }{ + {"top", "top", "a team under itself"}, + {"top", "low", "a team under its own grandchild"}, + {"mid", "low", "a team under its own child"}, + {"mid", "nobody", "a parent that does not exist"}, + {"nobody", "top", "a team that does not exist"}, + } { + if err := f.SetParent(c.id, c.parent); err == nil { + t.Fatalf("%s was allowed", c.why) + } + } + if got := names(f.Ancestors("low")); got != "mid,top" { + t.Fatalf("low's ancestors are %q", got) + } + if got := names(f.Children("")); got != "top,other" { + t.Fatalf("the top level is %q", got) + } + if got := names(f.Children("top")); got != "mid" { + t.Fatalf("top's children are %q", got) + } + if err := f.SetParent("low", ""); err != nil { + t.Fatal(err) + } + if got := names(f.Children("")); got != "top,low,other" { + t.Fatalf("after moving low to the top: %q", got) + } +} + +// ONE MANAGER, ALWAYS A MEMBER. +func TestManagerSetAndClear(t *testing.T) { + f := &File{Teams: []Team{{ID: "t1", Name: "harbor", Members: []Member{{Key: "a", Word: "alpha"}}}}} + if err := f.SetManager("t1", "a"); err != nil { + t.Fatal(err) + } + if f.Teams[0].Manager != "a" || len(f.Teams[0].Members) != 1 { + t.Fatalf("after setting a member: %+v", f.Teams[0]) + } + // A conversation that is not a member joins, and replaces the manager. + if err := f.SetManager("t1", "boss"); err != nil { + t.Fatal(err) + } + if f.Teams[0].Manager != "boss" || !f.Teams[0].Holds("boss") || !f.Teams[0].Holds("a") { + t.Fatalf("after setting an outsider: %+v", f.Teams[0]) + } + if err := f.SetManager("t1", ""); err == nil { + t.Fatal("an empty manager was accepted") + } + if err := f.SetManager("nope", "a"); err == nil { + t.Fatal("a manager for a team that does not exist was accepted") + } + if err := f.ClearManager("t1"); err != nil { + t.Fatal(err) + } + if f.Teams[0].Manager != "" || !f.Teams[0].Holds("boss") { + t.Fatalf("clear removed more than the role: %+v", f.Teams[0]) + } + // Removing the manager from the team ends the role. + _ = f.SetManager("t1", "a") + if err := f.RemoveMember("t1", "a"); err != nil { + t.Fatal(err) + } + if f.Teams[0].Manager != "" || f.Teams[0].Holds("a") { + t.Fatalf("a removed manager is still one: %+v", f.Teams[0]) + } + // And a manager set by hand to a stranger is cleared by the next save. + f.Teams[0].Manager = "stranger" + dir := t.TempDir() + if err := Save(dir, f.Teams); err != nil { + t.Fatal(err) + } + if f.Teams[0].Manager != "" { + t.Fatalf("saved a manager who is not a member: %q", f.Teams[0].Manager) + } +} + +func TestAddMemberAssignsAHandleOnce(t *testing.T) { + f := &File{Teams: []Team{{ID: "t1", Name: "harbor"}}} + if err := f.AddMember("t1", Member{Key: "a", Word: "Refactor the parser"}); err != nil { + t.Fatal(err) + } + if err := f.AddMember("t1", Member{Key: "b"}); err != nil { + t.Fatal(err) + } + if err := f.AddMember("t1", Member{Key: "a", Word: "again"}); err != nil { + t.Fatal(err) + } + tm := f.Teams[0] + if len(tm.Members) != 2 || tm.Members[0].Handle != "parser" || tm.Members[1].Handle != "" { + t.Fatalf("members %+v", tm.Members) + } + // The untitled member takes a handle when it has a title; the titled one + // keeps its handle when its title changes. + f.Teams[0].Members[1].Word = "Refactor the lexer" + f.Teams[0].Members[0].Word = "Something else entirely" + tidy(f.Teams) + if h := f.Teams[0].Members; h[0].Handle != "parser" || h[1].Handle != "lexer" { + t.Fatalf("handles after titles moved: %+v", h) + } + if err := f.AddMember("t1", Member{}); err == nil { + t.Fatal("a member with no key was accepted") + } +} + +// A TEAM WAKES UNLESS IT WAS TURNED OFF, and only what was set is written: a +// file that never mentioned waking reads as unset (inherit, on by default), +// unset is written as nothing, and the stored "wake": false spelling from +// before wake was inheritable still reads as off. +func TestATeamWakesUnlessTurnedOff(t *testing.T) { + var fresh Team + if err := json.Unmarshal([]byte(`{"id":"a","name":"a"}`), &fresh); err != nil { + t.Fatal(err) + } + if !fresh.Wakes() { + t.Fatal("a team whose file says nothing about waking does not wake") + } + raw, err := json.Marshal(fresh) + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(raw), `"wake"`) { + t.Fatalf("a team that wakes wrote the field: %s", raw) + } + off := false + fresh.Settings.Wake = &off + raw, err = json.Marshal(fresh) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(raw), `"wake":false`) { + t.Fatalf("a team turned off did not write wake false: %s", raw) + } + var back Team + if err := json.Unmarshal(raw, &back); err != nil { + t.Fatal(err) + } + if back.Wakes() { + t.Fatal("wake false did not survive a round trip") + } + if err := json.Unmarshal([]byte(`{"id":"a","name":"a","wake":true}`), &back); err != nil { + t.Fatal(err) + } + if !back.Wakes() { + t.Fatal("wake true reads as off") + } +} + +// WAKE IS INHERITED LIKE THE OTHER SETTINGS. Unset everywhere, it is the +// profile's default with origin Settings; a parent's stored "wake": false (the +// spelling a file from before this build wrote) turns its sub-teams off too, +// named as from the parent; a child's own true overrides it. +func TestWakeInheritsWithProvenance(t *testing.T) { + var f File + raw := `{"version":2,"teams":[ + {"id":"aaaaaaaaaaaa","name":"harbor","wake":false}, + {"id":"bbbbbbbbbbbb","name":"dock","parent":"aaaaaaaaaaaa"}, + {"id":"cccccccccccc","name":"yard"}]}` + if err := json.Unmarshal([]byte(raw), &f); err != nil { + t.Fatal(err) + } + on := Defaults{Wake: true} + if e := f.Effective("cccccccccccc", on); !e.Wake || e.WakeFrom.Kind != OriginSettings { + t.Fatalf("an unset team does not take the default: %+v", e) + } + if e := f.Effective("aaaaaaaaaaaa", on); e.Wake || e.WakeFrom.Kind != OriginTeam { + t.Fatalf("the stored wake false is not the team's own off: %+v", e) + } + if e := f.Effective("bbbbbbbbbbbb", on); e.Wake || e.WakeFrom.Words() != "from harbor" { + t.Fatalf("a sub-team does not inherit its parent's off: %+v", e) + } + yes := true + if err := f.SetSettings("bbbbbbbbbbbb", func(s *Settings) { s.Wake = &yes }); err != nil { + t.Fatal(err) + } + if e := f.Effective("bbbbbbbbbbbb", on); !e.Wake || e.WakeFrom.Kind != OriginTeam { + t.Fatalf("a sub-team's own on does not override: %+v", e) + } + if e := f.Effective("cccccccccccc", Defaults{}); e.Wake { + t.Fatalf("a profile default of off is not honoured: %+v", e) + } +} diff --git a/internal/teams/teamsettings.go b/internal/teams/teamsettings.go new file mode 100644 index 0000000000..1ce77917db --- /dev/null +++ b/internal/teams/teamsettings.go @@ -0,0 +1,297 @@ +package teams + +import ( + "errors" + "math" + + "github.com/Agent-Field/codeaf/internal/config" +) + +// ── A TEAM'S DELEGATION SETTINGS, AND WHERE EACH ONE CAME FROM ────────────── +// +// Five things about how work is delegated can differ from team to team: +// whether team traffic wakes an idle conversation (wake: a directive its +// member, a member's reply its manager), whether a member's clarifying +// questions go up to the manager first (questions_up), what the team and everything under it may spend in a local +// day (cap_usd_day, 0 for no cap), how many levels of teams may stand under it +// counting the top as one (depth_limit), and what share of its own cap a new +// sub-team is handed (sub_share, a fraction in (0, 1]). +// +// EACH IS OPTIONAL, AND UNSET IS INHERIT. A team that says nothing takes its +// parent's value, the parent its own parent's, and the top of the chain takes +// the profile's `teams.` defaults (internal/config's teamdefaults.go). The +// resolver ([File.Effective]) answers every value together with where it came +// from ([Origin]), so a settings card can draw an inherited value dim with +// `· from Settings` or `· from harbor` and an overridden one in ink with a +// `reset` beside it, and never has to walk the tree itself. +// +// A CLOSED TEAM IS NOT IN ANY WALK (lifecycle.go). Its overrides are kept, so +// a reopened team has them back, but a team under it (which a cascade closed +// too, so this is only a hand-edited file) skips it on the way up, and its own +// effective cap is none: a closed team spends nothing, so it has nothing to +// cap. + +// Settings are a team's own overrides. A nil field is unset. +type Settings struct { + QuestionsUp *bool `json:"questions_up,omitempty"` + CapUSDDay *float64 `json:"cap_usd_day,omitempty"` + DepthLimit *int `json:"depth_limit,omitempty"` + SubShare *float64 `json:"sub_share,omitempty"` + // Wake is stored as "wake". A file from before wake was inheritable wrote + // only "wake": false (on was written as nothing), and that spelling reads + // here unchanged as an override to off. + Wake *bool `json:"wake,omitempty"` +} + +// The bands an override is kept inside; a value outside them is dropped by +// tidy (it reads as inherit) and refused by [File.SetSettings]. +const ( + depthLimitMax = 10 +) + +// ErrSetting is an override outside its band. +var ErrSetting = errors.New("teams: a cap is 0 or more, a depth 1 to 10, a share above 0 and at most 1") + +// Empty reports whether the team overrides nothing. +func (s Settings) Empty() bool { + return s.QuestionsUp == nil && s.CapUSDDay == nil && s.DepthLimit == nil && s.SubShare == nil && s.Wake == nil +} + +// valid reports whether every set field is inside its band. +func (s Settings) valid() bool { + return (s.CapUSDDay == nil || validCap(*s.CapUSDDay)) && + (s.DepthLimit == nil || *s.DepthLimit >= 1 && *s.DepthLimit <= depthLimitMax) && + (s.SubShare == nil || validShare(*s.SubShare)) +} + +func validCap(v float64) bool { return v >= 0 && !math.IsInf(v, 0) && !math.IsNaN(v) } +func validShare(v float64) bool { return v > 0 && v <= 1 } + +// tidy drops every set field outside its band, and reports whether it did. +func (s *Settings) tidy() bool { + changed := false + if s.CapUSDDay != nil && !validCap(*s.CapUSDDay) { + s.CapUSDDay, changed = nil, true + } + if s.DepthLimit != nil && (*s.DepthLimit < 1 || *s.DepthLimit > depthLimitMax) { + s.DepthLimit, changed = nil, true + } + if s.SubShare != nil && !validShare(*s.SubShare) { + s.SubShare, changed = nil, true + } + return changed +} + +// clone is s with its own copies of every set value. +func (s Settings) clone() Settings { + if s.QuestionsUp != nil { + v := *s.QuestionsUp + s.QuestionsUp = &v + } + if s.CapUSDDay != nil { + v := *s.CapUSDDay + s.CapUSDDay = &v + } + if s.DepthLimit != nil { + v := *s.DepthLimit + s.DepthLimit = &v + } + if s.SubShare != nil { + v := *s.SubShare + s.SubShare = &v + } + if s.Wake != nil { + v := *s.Wake + s.Wake = &v + } + return s +} + +// SetSettings changes team id's overrides with change, which sets a field to +// override it and nils it to reset it to inherit. A result outside a band is +// [ErrSetting] and nothing is changed. +func (f *File) SetSettings(id string, change func(*Settings)) error { + i, err := f.at(id) + if err != nil { + return err + } + next := f.Teams[i].Settings.clone() + change(&next) + if !next.valid() { + return ErrSetting + } + f.Teams[i].Settings = next + return nil +} + +// Defaults are the profile's `teams.` rows as the resolver takes them. +type Defaults struct { + QuestionsUp bool `json:"questions_up"` + CapUSDDay float64 `json:"cap_usd_day"` + DepthLimit int `json:"depth_limit"` + // SubShare is a fraction, the row's whole percentage over 100. + SubShare float64 `json:"sub_share"` + // Wake is whether team traffic wakes idle conversations. + Wake bool `json:"wake"` +} + +// DefaultsAt reads the five rows from profileDir's config.json in one read +// (config's TeamDefaultsAt). An empty profileDir is the ordinary launch. +func DefaultsAt(profileDir string) Defaults { + d := config.TeamDefaultsAt(profileDir) + return Defaults{ + QuestionsUp: d.QuestionsUp, + CapUSDDay: d.CapUSDDay, + DepthLimit: d.DepthLimit, + SubShare: float64(d.SubSharePct) / 100, + Wake: d.Wake, + } +} + +// Where a value came from. +const ( + // OriginTeam is the team's own override. + OriginTeam = "team" + // OriginAncestor is an override on a team up the chain, named by Team. + OriginAncestor = "ancestor" + // OriginSettings is the profile's `teams.` default. + OriginSettings = "settings" + // OriginClosed is a closed team's cap, which is none. + OriginClosed = "closed" +) + +// Origin is where one resolved value came from: Kind is one of the Origin +// constants, and Team and Name name the team that set it for OriginTeam and +// OriginAncestor. +type Origin struct { + Kind string `json:"kind"` + Team string `json:"team,omitempty"` + Name string `json:"name,omitempty"` +} + +// Inherited reports whether the value is not the team's own. +func (o Origin) Inherited() bool { return o.Kind != OriginTeam } + +// Words is the dim words an inherited value is drawn with, "" for the team's +// own: `from Settings`, `from harbor`, `closed`. +func (o Origin) Words() string { + switch o.Kind { + case OriginSettings: + return "from Settings" + case OriginAncestor: + return "from " + o.Name + case OriginClosed: + return "closed" + } + return "" +} + +// Effective is a team's five settings resolved, each with its origin. +type Effective struct { + QuestionsUp bool `json:"questions_up"` + QuestionsUpFrom Origin `json:"questions_up_from"` + CapUSDDay float64 `json:"cap_usd_day"` + // CapFrom names the team whose cap this is. A cap is a POOL: a team's + // spend counts every team under it ([TeamSpend]), so an inherited cap is + // the ancestor's one pool, shared, and not a second allowance of the same + // size; the spend to set beside it is CapFrom.Team's. + CapFrom Origin `json:"cap_from"` + DepthLimit int `json:"depth_limit"` + DepthFrom Origin `json:"depth_from"` + SubShare float64 `json:"sub_share"` + SubShareFrom Origin `json:"sub_share_from"` + // Wake is whether team traffic wakes the team's idle conversations: a + // directive its member, a member's reply or event its manager. + Wake bool `json:"wake"` + WakeFrom Origin `json:"wake_from"` +} + +// Effective resolves team id's settings: each from the team's own override, +// else the nearest open ancestor's, else d. An id not in the file is d +// throughout. +func (f *File) Effective(id string, d Defaults) Effective { + settings := Origin{Kind: OriginSettings} + out := Effective{ + QuestionsUp: d.QuestionsUp, QuestionsUpFrom: settings, + CapUSDDay: d.CapUSDDay, CapFrom: settings, + DepthLimit: d.DepthLimit, DepthFrom: settings, + SubShare: d.SubShare, SubShareFrom: settings, + Wake: d.Wake, WakeFrom: settings, + } + self, ok := f.Team(id) + if !ok { + return out + } + var got struct{ questions, cap, depth, share, wake bool } + chain := append([]Team{self}, f.Ancestors(id)...) + for i, t := range chain { + if t.Closed() && i > 0 { + continue + } + origin := Origin{Kind: OriginAncestor, Team: t.ID, Name: t.Name} + if i == 0 { + origin.Kind = OriginTeam + } + s := t.Settings + if !got.questions && s.QuestionsUp != nil { + out.QuestionsUp, out.QuestionsUpFrom, got.questions = *s.QuestionsUp, origin, true + } + if !got.cap && s.CapUSDDay != nil { + out.CapUSDDay, out.CapFrom, got.cap = *s.CapUSDDay, origin, true + } + if !got.depth && s.DepthLimit != nil { + out.DepthLimit, out.DepthFrom, got.depth = *s.DepthLimit, origin, true + } + if !got.share && s.SubShare != nil { + out.SubShare, out.SubShareFrom, got.share = *s.SubShare, origin, true + } + if !got.wake && s.Wake != nil { + out.Wake, out.WakeFrom, got.wake = *s.Wake, origin, true + } + } + if self.Closed() { + out.CapUSDDay, out.CapFrom = 0, Origin{Kind: OriginClosed, Team: self.ID, Name: self.Name} + } + return out +} + +// Depth is how many levels team id stands at, the top level being 1, and 0 +// for an id not in the file. The root team (root.go) is not a level: it is 0, +// and a team directly under it is 1. +func (f *File) Depth(id string) int { + t, ok := f.Team(id) + if !ok || t.Root { + return 0 + } + depth := 1 + for _, a := range f.Ancestors(id) { + if !a.Root { + depth++ + } + } + return depth +} + +// CanNest reports whether a new sub-team may be made under parent: the parent +// is open and one more level stays inside the parent's effective depth limit. +func (f *File) CanNest(parent string, d Defaults) bool { + t, ok := f.Team(parent) + if !ok || t.Closed() { + return false + } + return f.Depth(parent)+1 <= f.Effective(parent, d).DepthLimit +} + +// SubTeamCap is the cap a new sub-team under parent is made with: the +// parent's effective cap times its effective share, rounded to the cent. A +// parent with no cap gives none (0), and the sub-team then shares whatever +// pool is above it. The caller writes the answer on the new team +// ([File.SetSettings]), so a later change to the share moves no team that +// exists. +func (f *File) SubTeamCap(parent string, d Defaults) float64 { + e := f.Effective(parent, d) + if e.CapUSDDay <= 0 { + return 0 + } + return math.Round(e.CapUSDDay*e.SubShare*100) / 100 +} diff --git a/internal/teams/thread.go b/internal/teams/thread.go new file mode 100644 index 0000000000..4312950de2 --- /dev/null +++ b/internal/teams/thread.go @@ -0,0 +1,158 @@ +package teams + +import ( + "slices" + "sort" + "strconv" + "strings" +) + +// THREADS: WHAT ANSWERS WHAT. +// +// A manager asks three members one question and the log used to hold twelve +// lines for it: three copies of the question, three wakes, three replies and +// the finishings, newest at the bottom, with nothing saying which reply was to +// which question. So the log is threaded, by one field: +// +// - A MESSAGE TO SEVERAL MEMBERS IS ONE ENTRY. [ToSeveral] with the handles +// in [Entry.Handles], or [ToEveryone]; delivery asks [Entry.Addressed], +// which is true for each of them, so every member is still told once. +// - AN ANSWER NAMES WHAT IT ANSWERS. [Entry.Answers] is the id of the entry a +// reply is to. A member's team_post to its manager names the last message +// the manager sent it, unless it named another, and the events its turn +// raises (finished, failed, asking, and the wake that started it) name the +// same one, so a reader can draw the question with its answers under it +// and fold the events into the answer's line. +// - AN ENTRY WRITTEN BEFORE THREADS answers nothing, and reads as a thread of +// its own, which is exactly what it was drawn as before. +// +// The field travels in the entry's JSON, so a log read over --host is threaded +// the same way, and a build that does not know the field keeps reading the log. + +// Addressed reports whether e is for the member with handle: to that handle, +// to everyone, or to several of which it is one. +func (e Entry) Addressed(handle string) bool { + if handle == "" { + return false + } + switch e.To { + case ToEveryone: + return true + case ToSeveral: + return slices.Contains(e.Handles, handle) + } + return e.To == handle +} + +// Recipients is the members e is addressed to by handle: its one handle, or +// its several. It is nil for an address that is not a member's (everyone, the +// room, the manager); a reader that wants everyone's names has the team. +func (e Entry) Recipients() []string { + switch e.To { + case ToSeveral: + return e.Handles + case "", ToEveryone, ToRoom, ToManager: + return nil + } + return []string{e.To} +} + +// Wake reports whether e says a turn was started by team traffic: `woke @web`, +// `woke ◆`. It is the cause of a state and never news of its own, so a reader +// draws the state (a member working) rather than the line. +func (e Entry) Wake() bool { + return e.Kind == KindEvent && e.State == StateRunning && strings.HasPrefix(strings.TrimSpace(e.Text), "woke ") +} + +// ThreadNumber is an entry id as a person and a model write it: "#42". +func ThreadNumber(id string) string { + trimmed := strings.TrimLeft(id, "0") + if trimmed == "" { + trimmed = "0" + } + return "#" + trimmed +} + +// ThreadID reads what a model wrote for a thread ("#42", "42", or a whole id) +// back into an entry id, and false when it is not one. +func ThreadID(s string) (string, bool) { + s = strings.TrimPrefix(strings.TrimSpace(s), "#") + if s == "" || len(s) > trafficIDWidth { + return "", false + } + n, err := strconv.ParseInt(s, 10, 64) + if err != nil || n <= 0 { + return "", false + } + return padID(n), true +} + +// padID is a sequence number as an entry id. +func padID(n int64) string { + id := strconv.FormatInt(n, 10) + if len(id) < trafficIDWidth { + id = strings.Repeat("0", trafficIDWidth-len(id)) + id + } + return id +} + +// Thread is one message and everything that answered it, directly or through +// another answer. +type Thread struct { + // Root is the message the thread began with. + Root Entry + // Replies is everything that answers it, oldest first. + Replies []Entry + // Latest is the id of the newest entry in the thread, which is what orders + // threads by activity. + Latest string +} + +// threadHops is the longest chain of answers followed to a root: a reply to a +// reply to a reply. Past it an entry is a root of its own, which can only +// happen to a log somebody wrote by hand. +const threadHops = 16 + +// Threads is entries (oldest first, as [ReadTraffic] gives them) grouped into +// threads, the thread with the newest activity FIRST and the entries inside +// each in the order they were written. An entry answering an id that is not +// among entries (older than the window, or never written) begins a thread of +// its own, as does every entry that answers nothing. +func Threads(entries []Entry) []Thread { + if len(entries) == 0 { + return nil + } + at := make(map[string]int, len(entries)) + for i, e := range entries { + at[e.ID] = i + } + rootOf := func(i int) int { + for hop := 0; hop < threadHops; hop++ { + up, ok := at[entries[i].Answers] + if entries[i].Answers == "" || !ok || up == i || entries[up].ID >= entries[i].ID { + return i + } + i = up + } + return i + } + index := map[int]int{} + var out []Thread + for i, e := range entries { + root := rootOf(i) + n, ok := index[root] + if !ok { + n = len(out) + index[root] = n + out = append(out, Thread{Root: entries[root], Latest: entries[root].ID}) + } + if root != i { + out[n].Replies = append(out[n].Replies, e) + } + if e.ID > out[n].Latest { + out[n].Latest = e.ID + } + } + sort.SliceStable(out, func(i, j int) bool { return out[i].Latest > out[j].Latest }) + return out +} diff --git a/internal/teams/thread_test.go b/internal/teams/thread_test.go new file mode 100644 index 0000000000..57baabf465 --- /dev/null +++ b/internal/teams/thread_test.go @@ -0,0 +1,87 @@ +package teams + +import ( + "strings" + "testing" +) + +// A MESSAGE TO SEVERAL MEMBERS IS ONE ENTRY, and each of them is addressed by +// it; a member it does not name is not. +func TestSeveralIsOneEntryAddressedToEach(t *testing.T) { + dir := t.TempDir() + e := Entry{Kind: KindDirective, From: FromManager, To: ToSeveral, Handles: []string{"agent", "checking", "review"}, Text: "a brief status, please"} + id, err := AppendTrafficID(dir, "t1", e) + if err != nil || id != "000000000001" { + t.Fatalf("append: %q %v", id, err) + } + got, _ := ReadTraffic(dir, "t1", "", 0) + if len(got) != 1 || strings.Join(got[0].Handles, ",") != "agent,checking,review" { + t.Fatalf("the log holds %+v", got) + } + for _, h := range []string{"agent", "checking", "review"} { + if !got[0].Addressed(h) { + t.Errorf("@%s is not addressed", h) + } + } + if got[0].Addressed("web") || got[0].Addressed("") { + t.Error("a member the message does not name is addressed") + } + if _, err := AppendTrafficID(dir, "t1", Entry{Kind: KindNote, From: FromManager, To: ToSeveral, Text: "x"}); err == nil { + t.Error("several with nobody named was written") + } + if r := (Entry{To: ToEveryone}).Recipients(); r != nil { + t.Errorf("everyone named %v", r) + } + if r := (Entry{To: "web"}).Recipients(); len(r) != 1 || r[0] != "web" { + t.Errorf("one member named %v", r) + } +} + +// THREADS ARE ORDERED BY THEIR NEWEST ACTIVITY, newest first, and inside a +// thread everything is in the order it was written. A reply to a reply joins +// the first message's thread; an old entry that answers nothing is a thread of +// its own; an answer to an id outside the window begins its own. +func TestThreadsGroupAndOrder(t *testing.T) { + log := []Entry{ + {ID: "000000000001", Kind: KindDirective, From: FromManager, To: ToSeveral, Handles: []string{"a", "b"}, Text: "q1"}, + {ID: "000000000002", Kind: KindNote, From: FromManager, To: "c", Text: "q2"}, + {ID: "000000000003", Kind: KindNote, From: "a", To: ToManager, Text: "r1a", Answers: "000000000001"}, + {ID: "000000000004", Kind: KindEvent, From: "old", To: ToManager, State: StateFinished}, + {ID: "000000000005", Kind: KindNote, From: "c", To: ToManager, Text: "r2", Answers: "000000000002"}, + {ID: "000000000006", Kind: KindEvent, From: "a", To: ToManager, State: StateFinished, Answers: "000000000003"}, + {ID: "000000000007", Kind: KindNote, From: "z", To: ToManager, Text: "orphan", Answers: "000000000000"}, + } + th := Threads(log) + if len(th) != 4 { + t.Fatalf("%d threads: %+v", len(th), th) + } + if th[0].Root.ID != "000000000007" || th[1].Root.ID != "000000000001" || th[2].Root.ID != "000000000002" || th[3].Root.ID != "000000000004" { + t.Fatalf("order: %s %s %s %s", th[0].Root.ID, th[1].Root.ID, th[2].Root.ID, th[3].Root.ID) + } + if r := th[1].Replies; len(r) != 2 || r[0].ID != "000000000003" || r[1].ID != "000000000006" || th[1].Latest != "000000000006" { + t.Fatalf("q1's replies: %+v", r) + } + if len(th[3].Replies) != 0 { + t.Fatal("an old unlinked event gathered replies") + } +} + +// A thread number reads back from what a model writes. +func TestThreadNumbers(t *testing.T) { + if got := ThreadNumber("000000000042"); got != "#42" { + t.Fatalf("number %q", got) + } + for _, s := range []string{"#42", "42", " 000000000042 "} { + if id, ok := ThreadID(s); !ok || id != "000000000042" { + t.Errorf("%q read as %q %v", s, id, ok) + } + } + for _, s := range []string{"", "#", "abc", "-3", "0"} { + if _, ok := ThreadID(s); ok { + t.Errorf("%q read as an id", s) + } + } + if !(Entry{Kind: KindEvent, State: StateRunning, Text: "woke @web"}).Wake() || (Entry{Kind: KindEvent, State: StateRunning, Text: "answered"}).Wake() { + t.Error("a wake is not told from a turn carrying on") + } +} diff --git a/internal/teams/traffic.go b/internal/teams/traffic.go new file mode 100644 index 0000000000..5bbdf6bfac --- /dev/null +++ b/internal/teams/traffic.go @@ -0,0 +1,580 @@ +package teams + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "sort" + "strconv" + "strings" + "time" + + "github.com/Agent-Field/codeaf/internal/config" +) + +// THE TRAFFIC LOG is what passes between a team's members, its manager and the +// person, and the events the team's conversations raise, in the order they +// happened. It is one file per team, <profile>/teams/<id>/traffic.jsonl, one +// JSON object per line, only ever appended to. Past trafficRotateBytes the +// file is renamed to traffic.1.jsonl (replacing the one before) and a new one +// begins, so a team that talks for weeks costs a few megabytes at most. +// +// EVERY ENTRY HAS AN ID THAT SORTS. The id is a sequence number, zero-padded +// to twelve digits, taken under the log's lock, so string order is the order +// of appending and a reader can ask for everything after the last id it saw. + +// Entry kinds. +const ( + KindEvent = "event" // something a conversation did: finished, failed, asked + KindNote = "note" // a message from one party to another + KindDirective = "directive" // an instruction from the manager or the person + KindStop = "stop" // a member was stopped + KindStart = "start" // a member was started + KindYou = "you" // the person spoke to the team + // The delegation kinds (DESIGN.md section 8). + KindQuestion = "question" // a member asks its home manager a clarifying question + KindAnswer = "answer" // the manager answers one; Reply is the question's id + KindPacket = "packet" // a decision packet was raised, decided or escalated + KindClose = "close" // the team was closed + KindReopen = "reopen" // the team was reopened +) + +// Addresses that are not a member's handle. +const ( + FromManager = "manager" + FromYou = "you" + FromSystem = "system" + ToEveryone = "everyone" + ToManager = "manager" + ToRoom = "room" + // ToYou is the person, as the one a question or a packet is put to. + ToYou = "you" + // ToSeveral is a message to more than one member and fewer than all of + // them, by name: [Entry.Handles] lists who (thread.go). + ToSeveral = "several" +) + +var kinds = map[string]bool{ + KindEvent: true, KindNote: true, KindDirective: true, KindStop: true, KindStart: true, KindYou: true, + KindQuestion: true, KindAnswer: true, KindPacket: true, KindClose: true, KindReopen: true, +} + +// Entry is one line of the Traffic log. This shape is the contract between +// the interface and the team tools. +type Entry struct { + // ID is assigned by [AppendTraffic]; any ID given is replaced. + ID string `json:"id"` + // At is when it happened; [AppendTraffic] fills a zero one with now. + At time.Time `json:"at"` + // Kind is one of the Kind constants. + Kind string `json:"kind"` + // From is a member's handle, or manager, you or system. + From string `json:"from"` + // To is a member's handle, or everyone, manager or room, or several with + // the handles in Handles. + To string `json:"to"` + Text string `json:"text"` + // Handles is who a message to several members is for, in the order the + // sender named them; empty on every other entry (thread.go). + Handles []string `json:"handles,omitempty"` + // Answers is the id of the entry this one answers, which is what threads + // the log: a member's reply names the manager's message it replies to, and + // the events its turn raises name the same one. Empty on an entry that + // answers nothing, and on every entry written before threads (thread.go). + Answers string `json:"answers,omitempty"` + // Files are paths the entry is about, when it is about any. + Files []string `json:"files,omitempty"` + // Member is the conversation key the entry concerns, when there is one. + Member string `json:"member,omitempty"` + // State is what a [KindEvent] says the member it concerns is now: one of + // the State constants ([StateFinished], [StateFailed], [StateAsking], + // [StateIdle] for a turn that was stopped, [StateRunning] for one that + // carried on after its question was answered). It is empty on every other + // kind but [KindPacket]. A reader colours by it rather than by reading Text, which is the + // words a person reads. + State string `json:"state,omitempty"` + // Packet is the decision packet a [KindPacket] entry is about, and State + // is then the packet's state after the change it records. + Packet string `json:"packet,omitempty"` + // Reply is the id of the [KindQuestion] entry a [KindAnswer] answers. + Reply string `json:"reply,omitempty"` + // Team is, on a [KindStart], the sub-team the started conversation is to + // manage (a manager's `team_start` of kind team): the interface opens and + // adds the member as for any start, and the new conversation, reading its + // brief, makes itself that team's manager. It is empty on every other + // start and every other kind. + Team string `json:"team,omitempty"` +} + +// trafficRotateBytes is the size past which the log starts a new file. +var trafficRotateBytes int64 = 4 << 20 + +// trafficIDWidth is how many digits an entry id has. +const trafficIDWidth = 12 + +// TrafficPath is the log of team id: <profile>/teams/<id>/traffic.jsonl. +func TrafficPath(profileDir, teamID string) string { + return config.ProfilePath(profileDir, filepath.Join("teams", teamID, "traffic.jsonl")) +} + +func trafficRotated(path string) string { + return strings.TrimSuffix(path, ".jsonl") + ".1.jsonl" +} + +// safeTeamID reports whether id can name a directory: letters, digits, _ and -. +func safeTeamID(id string) error { + if id == "" || len(id) > 64 { + return fmt.Errorf("teams: %q is not a team id", id) + } + for _, r := range id { + if !(r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '_' || r == '-') { + return fmt.Errorf("teams: %q is not a team id", id) + } + } + return nil +} + +// AppendTraffic adds e to the end of team teamID's log, under the log's lock, +// giving it the next id and, when it has none, the time now. +func AppendTraffic(profileDir, teamID string, e Entry) error { + _, err := AppendTrafficID(profileDir, teamID, e) + return err +} + +// AppendTrafficID is [AppendTraffic], and the id the entry was given, which a +// writer that will be answered keeps so the answer can name it. +func AppendTrafficID(profileDir, teamID string, e Entry) (string, error) { + if err := safeTeamID(teamID); err != nil { + return "", err + } + if !kinds[e.Kind] { + return "", fmt.Errorf("teams: %q is not a traffic kind", e.Kind) + } + if strings.TrimSpace(e.From) == "" || strings.TrimSpace(e.To) == "" { + return "", errors.New("teams: a traffic entry needs a from and a to") + } + if e.To == ToSeveral && len(e.Handles) == 0 { + return "", errors.New("teams: a message to several members needs their handles") + } + if e.At.IsZero() { + e.At = time.Now() + } + path := TrafficPath(profileDir, teamID) + err := lockedAt(strings.TrimSuffix(path, ".jsonl")+".lock", lockWait, func() error { + last, err := lastTrafficID(path) + if err != nil { + return err + } + e.ID = fmt.Sprintf("%0*d", trafficIDWidth, last+1) + line, err := json.Marshal(e) + if err != nil { + return err + } + line = append(line, '\n') + if info, err := os.Stat(path); err == nil && info.Size() > 0 && info.Size()+int64(len(line)) > trafficRotateBytes { + if err := os.Rename(path, trafficRotated(path)); err != nil { + return err + } + } + before := modTime(path) + file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600) + if err != nil { + return err + } + if _, err := file.Write(line); err != nil { + _ = file.Close() + return err + } + if err := file.Close(); err != nil { + return err + } + // The log's stamp moves with every line (stamp.go), under the log's + // lock, so a reader that stats before it reads never misses one. + advance(path, before) + return nil + }) + if err != nil { + return "", err + } + return e.ID, nil +} + +// ReadTraffic is team teamID's log after the entry with id after, oldest +// first, from both the current file and the rotated one before it. +// +// It is made for two readers. With after "" it is the TAIL: the last limit +// entries, for a digest or a first look. With an id it PAGES FORWARD: the first +// limit entries after that id, so a reader that keeps the last id it saw never +// skips one. A limit of 0 or less is every entry. A log that does not exist is +// no entries and no error. It takes no lock; a line still being written is +// skipped and read next time. +// +// IT READS WHAT IT RETURNS AND LITTLE ELSE. A log is up to two files of +// [trafficRotateBytes], and a reader asking at every step of a turn must not +// parse megabytes to learn that nothing is new. So a tail is read backwards +// from the end in windows until it holds limit entries ([tailTraffic]), and a +// page forward first asks each file for its last id (one window at its end, +// [lastIDIn]): a file with nothing past the cursor is not read at all, and one +// with something is entered where the cursor is, found by a binary search over +// byte offsets on the ids, which are in file order ([forwardTraffic]). Only a +// limit of 0 or less reads the files whole. +func ReadTraffic(profileDir, teamID string, after string, limit int) ([]Entry, error) { + if err := safeTeamID(teamID); err != nil { + return nil, err + } + path := TrafficPath(profileDir, teamID) + files := []string{trafficRotated(path), path} + var ( + all []Entry + err error + ) + switch { + case limit <= 0: + for _, p := range files { + got, err := readTrafficFile(p) + if err != nil { + return nil, err + } + all = append(all, got...) + } + case after == "": + all, err = tailTraffic(files, limit) + default: + all, err = forwardTraffic(files, after, limit) + } + if err != nil { + return nil, err + } + var out []Entry + seen := make(map[string]bool, len(all)) + for _, e := range all { + if seen[e.ID] || (after != "" && e.ID <= after) { + continue + } + seen[e.ID] = true + out = append(out, e) + } + sort.SliceStable(out, func(i, j int) bool { return out[i].ID < out[j].ID }) + if limit > 0 && len(out) > limit { + if after == "" { + out = out[len(out)-limit:] + } else { + out = out[:limit] + } + } + return out, nil +} + +// trafficWindow is how much of a file one backwards step reads. +var trafficWindow int64 = 64 << 10 + +// tailTraffic is at least the last limit entries of files (oldest file first), +// read backwards from the end of the newest in [trafficWindow] steps. +func tailTraffic(files []string, limit int) ([]Entry, error) { + var out []Entry + for index := len(files) - 1; index >= 0 && len(out) < limit; index-- { + got, err := tailTrafficFile(files[index], limit-len(out)) + if err != nil { + return nil, err + } + out = append(got, out...) + } + return out, nil +} + +// tailTrafficFile is at least the last want entries of one file, or all of it. +// Only complete lines count; a line still being written has no newline yet. +func tailTrafficFile(path string, want int) ([]Entry, error) { + file, err := os.Open(path) + if errors.Is(err, os.ErrNotExist) { + return nil, nil + } + if err != nil { + return nil, err + } + defer file.Close() + info, err := file.Stat() + if err != nil { + return nil, err + } + end := info.Size() + var carry []byte // the head of a line cut by the window, joined next step + var out []Entry + for end > 0 && len(out) < want { + start := max(end-trafficWindow, 0) + buf := make([]byte, end-start, end-start+int64(len(carry))) + if _, err := file.ReadAt(buf, start); err != nil && err != io.EOF { + return nil, err + } + buf = append(buf, carry...) + cut := 0 + if start > 0 { + // The first line may begin before this window; keep it for the next. + nl := bytes.IndexByte(buf, '\n') + if nl < 0 { + carry, end = buf, start + continue + } + cut = nl + 1 + } + carry = append([]byte(nil), buf[:cut]...) + var got []Entry + for _, line := range completeLines(buf[cut:]) { + if e, ok := parseTrafficLine(line); ok { + got = append(got, e) + } + } + out = append(got, out...) + end = start + } + return out, nil +} + +// forwardTraffic is the first limit entries after the id after, from files in +// order (the rotated file holds only ids below the current file's). +func forwardTraffic(files []string, after string, limit int) ([]Entry, error) { + var out []Entry + for _, path := range files { + if len(out) >= limit { + break + } + got, err := forwardTrafficFile(path, after, limit-len(out)) + if err != nil { + return nil, err + } + out = append(out, got...) + } + return out, nil +} + +// forwardTrafficFile is up to want entries of one file with ids past after. +func forwardTrafficFile(path, after string, want int) ([]Entry, error) { + last, found, err := lastIDIn(path) + if err != nil || !found { + return nil, err + } + if fmt.Sprintf("%0*d", trafficIDWidth, last) <= after { + return nil, nil + } + file, err := os.Open(path) + if errors.Is(err, os.ErrNotExist) { + return nil, nil + } + if err != nil { + return nil, err + } + defer file.Close() + info, err := file.Stat() + if err != nil { + return nil, err + } + start, err := trafficOffsetAfter(file, info.Size(), after) + if err != nil { + return nil, err + } + if _, err := file.Seek(start, io.SeekStart); err != nil { + return nil, err + } + var out []Entry + r := bufio.NewReader(file) + for len(out) < want { + line, err := r.ReadBytes('\n') + if len(line) > 0 && line[len(line)-1] == '\n' { + if e, ok := parseTrafficLine(line); ok && e.ID > after { + out = append(out, e) + } + } + if err == io.EOF { + break + } + if err != nil { + return nil, err + } + } + return out, nil +} + +// trafficOffsetAfter is the byte offset of the first line whose id is past +// after, found by a binary search over offsets: the id of the first whole line +// at or after an offset only grows with the offset. A line that does not parse +// is read as past, which can only move the answer earlier; the caller filters +// by id, so earlier costs a few lines read and never an entry skipped. +func trafficOffsetAfter(file *os.File, size int64, after string) (int64, error) { + lo, hi := int64(0), size + for lo < hi { + mid := lo + (hi-lo)/2 + _, id, ok, err := trafficLineAt(file, size, mid) + if err != nil { + return 0, err + } + if !ok || id > after { + hi = mid + } else { + lo = mid + 1 + } + } + start, _, _, err := trafficLineAt(file, size, lo) + return start, err +} + +// trafficLineAt is the first whole line starting at or after offset: where it +// starts and its id. ok is false when there is none or it does not parse. +func trafficLineAt(file *os.File, size, offset int64) (int64, string, bool, error) { + start := offset + if offset > 0 { + // A line starts after a newline; find the first one at or after offset-1. + at, err := nextNewline(file, size, offset-1) + if err != nil || at < 0 { + return size, "", false, err + } + start = at + 1 + } + if start >= size { + return size, "", false, nil + } + end, err := nextNewline(file, size, start) + if err != nil || end < 0 { + return start, "", false, err + } + buf := make([]byte, end-start) + if _, err := file.ReadAt(buf, start); err != nil && err != io.EOF { + return start, "", false, err + } + var e struct { + ID string `json:"id"` + } + if json.Unmarshal(buf, &e) != nil || e.ID == "" { + return start, "", false, nil + } + return start, e.ID, true, nil +} + +// nextNewline is the offset of the first newline at or after from, -1 for none. +func nextNewline(file *os.File, size, from int64) (int64, error) { + const step = 4 << 10 + buf := make([]byte, step) + for at := from; at < size; at += step { + n, err := file.ReadAt(buf[:min(step, size-at)], at) + if i := bytes.IndexByte(buf[:n], '\n'); i >= 0 { + return at + int64(i), nil + } + if err != nil && err != io.EOF { + return -1, err + } + } + return -1, nil +} + +// completeLines is the newline-ended lines of buf, without their newlines. +func completeLines(buf []byte) [][]byte { + var lines [][]byte + for { + nl := bytes.IndexByte(buf, '\n') + if nl < 0 { + return lines + } + lines = append(lines, buf[:nl]) + buf = buf[nl+1:] + } +} + +// parseTrafficLine is one line as an entry, false for one that is not. +func parseTrafficLine(line []byte) (Entry, bool) { + var e Entry + if json.Unmarshal(line, &e) != nil || e.ID == "" { + return Entry{}, false + } + return e, true +} + +// readTrafficFile is every entry in one file that parses; a missing file is +// none. +func readTrafficFile(path string) ([]Entry, error) { + file, err := os.Open(path) + if errors.Is(err, os.ErrNotExist) { + return nil, nil + } + if err != nil { + return nil, err + } + defer file.Close() + var out []Entry + r := bufio.NewReader(file) + for { + line, err := r.ReadBytes('\n') + if len(line) > 0 && line[len(line)-1] == '\n' { + if e, ok := parseTrafficLine(line); ok { + out = append(out, e) + } + } + if err == io.EOF { + return out, nil + } + if err != nil { + return nil, err + } + } +} + +// lastTrafficID is the highest id in the log, 0 for an empty one. It reads the +// end of the current file, or the rotated file when the current one is empty. +func lastTrafficID(path string) (int64, error) { + for _, p := range []string{path, trafficRotated(path)} { + n, found, err := lastIDIn(p) + if err != nil || found { + return n, err + } + } + return 0, nil +} + +// lastIDIn is the highest id among the complete lines at the end of one file: +// the last 64 KB, or the whole file when no whole entry fits in that. +func lastIDIn(path string) (int64, bool, error) { + file, err := os.Open(path) + if errors.Is(err, os.ErrNotExist) { + return 0, false, nil + } + if err != nil { + return 0, false, err + } + defer file.Close() + info, err := file.Stat() + if err != nil { + return 0, false, err + } + for _, window := range []int64{64 << 10, info.Size()} { + start := max(info.Size()-window, 0) + buf := make([]byte, info.Size()-start) + if _, err := file.ReadAt(buf, start); err != nil && err != io.EOF { + return 0, false, err + } + // FROM THE END BACKWARDS, stopping at the first line with an id: ids + // only grow down a file, so the last one that parses is the highest, and + // a reader asking "is there anything new" decodes one line, not a window. + lines := bytes.Split(buf, []byte{'\n'}) + for index := len(lines) - 1; index >= 0; index-- { + if start > 0 && index == 0 { + break // cut by the window + } + var e struct { + ID string `json:"id"` + } + if json.Unmarshal(lines[index], &e) != nil { + continue + } + if n, err := strconv.ParseInt(e.ID, 10, 64); err == nil { + return n, true, nil + } + } + if start == 0 { + return 0, false, nil + } + } + return 0, false, nil +} diff --git a/internal/teams/traffic_read_test.go b/internal/teams/traffic_read_test.go new file mode 100644 index 0000000000..5ddd226146 --- /dev/null +++ b/internal/teams/traffic_read_test.go @@ -0,0 +1,153 @@ +package teams + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +// writeTrafficLog writes n entries straight to a team's two files, the first +// rotatedN of them into the rotated file, each with text of textLen bytes, so a +// test or a benchmark can build a big log without taking the lock n times. +func writeTrafficLog(tb testing.TB, dir, team string, n, rotatedN, textLen int) { + tb.Helper() + path := TrafficPath(dir, team) + if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { + tb.Fatal(err) + } + var rotated, current strings.Builder + at := time.Date(2026, 9, 24, 12, 0, 0, 0, time.UTC) + for i := 1; i <= n; i++ { + text := strings.Repeat(string(rune('a'+i%26)), textLen+i%7) + raw, err := json.Marshal(Entry{ID: fmt.Sprintf("%012d", i), At: at.Add(time.Duration(i) * time.Second), + Kind: KindNote, From: "web", To: ToRoom, Text: text}) + if err != nil { + tb.Fatal(err) + } + if i <= rotatedN { + rotated.Write(raw) + rotated.WriteByte('\n') + } else { + current.Write(raw) + current.WriteByte('\n') + } + } + if rotatedN > 0 { + if err := os.WriteFile(trafficRotated(path), []byte(rotated.String()), 0o600); err != nil { + tb.Fatal(err) + } + } + if err := os.WriteFile(path, []byte(current.String()), 0o600); err != nil { + tb.Fatal(err) + } +} + +// referenceTraffic is what ReadTraffic answers, computed the slow way: every +// entry of both files, filtered and cut. +func referenceTraffic(t *testing.T, dir, team, after string, limit int) []string { + t.Helper() + all, err := ReadTraffic(dir, team, "", 0) + if err != nil { + t.Fatal(err) + } + var ids []string + for _, e := range all { + if after == "" || e.ID > after { + ids = append(ids, e.ID) + } + } + if limit > 0 && len(ids) > limit { + if after == "" { + ids = ids[len(ids)-limit:] + } else { + ids = ids[:limit] + } + } + return ids +} + +// THE BOUNDED READS ANSWER WHAT THE WHOLE READ ANSWERS, across window edges, +// across the rotation, past a line too long for one window, around a line +// that does not parse, and with a last line still being written. +func TestTrafficBoundedReadsAgreeWithTheWholeRead(t *testing.T) { + defer func(n int64) { trafficWindow = n }(trafficWindow) + trafficWindow = 700 + dir := t.TempDir() + writeTrafficLog(t, dir, "t1", 120, 50, 60) + path := TrafficPath(dir, "t1") + file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o600) + if err != nil { + t.Fatal(err) + } + long, _ := json.Marshal(Entry{ID: "000000000121", Kind: KindNote, From: "web", To: ToRoom, Text: strings.Repeat("x", 3000)}) + _, _ = file.WriteString("not json\n" + string(long) + "\n") + later, _ := json.Marshal(Entry{ID: "000000000122", Kind: KindNote, From: "web", To: ToRoom, Text: "after the long one"}) + _, _ = file.WriteString(string(later) + "\n" + `{"id":"000000000123","kind":"note"`) + _ = file.Close() + + afters := []string{"", "000000000000", "000000000001", "000000000049", "000000000050", "000000000051", "000000000077", + "000000000119", "000000000120", "000000000121", "000000000122", "000000000200"} + for _, after := range afters { + for _, limit := range []int{1, 3, 20, 71, 100, 500} { + got, err := ReadTraffic(dir, "t1", after, limit) + if err != nil { + t.Fatal(err) + } + var ids []string + for _, e := range got { + ids = append(ids, e.ID) + } + want := referenceTraffic(t, dir, "t1", after, limit) + if strings.Join(ids, ",") != strings.Join(want, ",") { + t.Errorf("after %q limit %d read %v, want %v", after, limit, ids, want) + } + } + } +} + +// benchLog is a log the size the audit measured: 4.4 MB over the two files. +func benchLog(b *testing.B) (string, string) { + dir := b.TempDir() + writeTrafficLog(b, dir, "t1", 22000, 20000, 140) + return dir, fmt.Sprintf("%012d", 22000) +} + +// BenchmarkTrafficNothingNew is a reader at the end of the log asking again. +func BenchmarkTrafficNothingNew(b *testing.B) { + dir, last := benchLog(b) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + if got, err := ReadTraffic(dir, "t1", last, 100); err != nil || len(got) != 0 { + b.Fatal(len(got), err) + } + } +} + +// BenchmarkTrafficTail is a digest's look at the newest entries. +func BenchmarkTrafficTail(b *testing.B) { + dir, _ := benchLog(b) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + if got, err := ReadTraffic(dir, "t1", "", 200); err != nil || len(got) != 200 { + b.Fatal(len(got), err) + } + } +} + +// BenchmarkTrafficPageFromTheMiddle is a reader catching up a page at a time. +func BenchmarkTrafficPageFromTheMiddle(b *testing.B) { + dir, _ := benchLog(b) + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + if got, err := ReadTraffic(dir, "t1", fmt.Sprintf("%012d", 11000), 100); err != nil || len(got) != 100 { + b.Fatal(len(got), err) + } + } +} diff --git a/internal/teams/traffic_test.go b/internal/teams/traffic_test.go new file mode 100644 index 0000000000..de805976d3 --- /dev/null +++ b/internal/teams/traffic_test.go @@ -0,0 +1,174 @@ +package teams + +import ( + "fmt" + "os" + "strings" + "sync" + "testing" + "time" +) + +func note(from, to, text string) Entry { + return Entry{Kind: KindNote, From: from, To: to, Text: text} +} + +func TestTrafficAppendAndRead(t *testing.T) { + dir := t.TempDir() + if got, err := ReadTraffic(dir, "t1", "", 0); err != nil || len(got) != 0 { + t.Fatalf("an empty log: %+v %v", got, err) + } + at := time.Date(2026, 9, 24, 12, 0, 0, 0, time.UTC) + first := Entry{ID: "ignored", At: at, Kind: KindDirective, From: FromManager, To: "fix", Text: "take the login bug", + Files: []string{"auth/login.go"}, Member: "k1"} + if err := AppendTraffic(dir, "t1", first); err != nil { + t.Fatal(err) + } + if err := AppendTraffic(dir, "t1", note("fix", ToManager, "on it")); err != nil { + t.Fatal(err) + } + got, err := ReadTraffic(dir, "t1", "", 0) + if err != nil || len(got) != 2 { + t.Fatalf("read %+v %v", got, err) + } + first.ID = "000000000001" + if got[0].ID != first.ID || !got[0].At.Equal(at) || got[0].Kind != first.Kind || got[0].Text != first.Text || + got[0].Files[0] != "auth/login.go" || got[0].Member != "k1" { + t.Fatalf("first entry came back %+v", got[0]) + } + if got[1].ID != "000000000002" || got[1].At.IsZero() { + t.Fatalf("second entry came back %+v", got[1]) + } + // The line on disk is the contract's shape. + raw, _ := os.ReadFile(TrafficPath(dir, "t1")) + line := strings.SplitN(string(raw), "\n", 2)[0] + for _, key := range []string{`"id":`, `"at":`, `"kind":"directive"`, `"from":"manager"`, `"to":"fix"`, `"text":`, `"files":["auth/login.go"]`, `"member":"k1"`} { + if !strings.Contains(line, key) { + t.Fatalf("the line lacks %s: %s", key, line) + } + } + // Two teams, two logs. + if other, _ := ReadTraffic(dir, "t2", "", 0); len(other) != 0 { + t.Fatalf("another team's log holds %+v", other) + } +} + +func TestTrafficRefusesBadEntriesAndIDs(t *testing.T) { + dir := t.TempDir() + for _, c := range []struct { + team string + e Entry + }{ + {"t1", Entry{Kind: "chat", From: "a", To: "b"}}, + {"t1", Entry{Kind: KindNote, To: "b"}}, + {"t1", Entry{Kind: KindNote, From: "a"}}, + {"../escape", note("a", "b", "x")}, + {"", note("a", "b", "x")}, + } { + if err := AppendTraffic(dir, c.team, c.e); err == nil { + t.Errorf("appended %+v to %q", c.e, c.team) + } + } + if _, err := ReadTraffic(dir, "a/b", "", 0); err == nil { + t.Error("read a team id with a slash") + } +} + +// AFTER PAGES FORWARD, AND NO LIMIT SKIPS AN ENTRY; with no after, the limit +// is the tail. +func TestTrafficAfterPaging(t *testing.T) { + dir := t.TempDir() + for i := 1; i <= 10; i++ { + if err := AppendTraffic(dir, "t1", note("a", "b", fmt.Sprint(i))); err != nil { + t.Fatal(err) + } + } + tail, _ := ReadTraffic(dir, "t1", "", 3) + if texts(tail) != "8,9,10" { + t.Fatalf("tail %s", texts(tail)) + } + // A follower that has seen nothing starts below the first id. + var pages []string + after := "000000000000" + for { + page, err := ReadTraffic(dir, "t1", after, 4) + if err != nil { + t.Fatal(err) + } + if len(page) == 0 { + break + } + pages = append(pages, texts(page)) + after = page[len(page)-1].ID + } + if strings.Join(pages, "|") != "1,2,3,4|5,6,7,8|9,10" { + t.Fatalf("pages %v", pages) + } + if rest, _ := ReadTraffic(dir, "t1", "000000000007", 0); texts(rest) != "8,9,10" { + t.Fatalf("after 7: %s", texts(rest)) + } +} + +// PAST THE SIZE GUARD THE LOG ROTATES, the ids keep counting, and a reader +// still sees both files in order. +func TestTrafficRotates(t *testing.T) { + dir := t.TempDir() + defer func(n int64) { trafficRotateBytes = n }(trafficRotateBytes) + trafficRotateBytes = 600 + for i := 1; i <= 12; i++ { + if err := AppendTraffic(dir, "t1", note("a", "b", fmt.Sprintf("entry %02d %s", i, strings.Repeat("x", 40)))); err != nil { + t.Fatal(err) + } + } + path := TrafficPath(dir, "t1") + info, err := os.Stat(path) + if err != nil || info.Size() > trafficRotateBytes { + t.Fatalf("current log: %v %v", info, err) + } + if _, err := os.Stat(trafficRotated(path)); err != nil { + t.Fatalf("no rotated log: %v", err) + } + all, _ := ReadTraffic(dir, "t1", "", 0) + if len(all) == 0 || all[len(all)-1].ID != "000000000012" { + t.Fatalf("after rotation the last id is %+v", all) + } + for i := 1; i < len(all); i++ { + if all[i].ID <= all[i-1].ID { + t.Fatalf("out of order: %s then %s", all[i-1].ID, all[i].ID) + } + } + // Only the current and one rotated file are kept, so the oldest are gone. + if all[0].ID == "000000000001" { + t.Fatalf("nothing was rotated away: %d entries kept", len(all)) + } +} + +// TWO WRITERS AT ONCE: every id is taken once. +func TestTrafficConcurrentAppends(t *testing.T) { + dir := t.TempDir() + var wg sync.WaitGroup + for w := 0; w < 2; w++ { + wg.Add(1) + go func(w int) { + defer wg.Done() + for i := 0; i < 30; i++ { + if err := AppendTraffic(dir, "t1", note(fmt.Sprintf("w%d", w), "b", fmt.Sprint(i))); err != nil { + t.Error(err) + } + } + }(w) + } + wg.Wait() + all, _ := ReadTraffic(dir, "t1", "", 0) + if len(all) != 60 || all[59].ID != "000000000060" { + t.Fatalf("%d entries, last %+v", len(all), all[len(all)-1]) + } +} + +func texts(es []Entry) string { + var out []string + for _, e := range es { + out = append(out, e.Text) + } + return strings.Join(out, ",") +} diff --git a/internal/teams/wrap.go b/internal/teams/wrap.go new file mode 100644 index 0000000000..e2a8af3cab --- /dev/null +++ b/internal/teams/wrap.go @@ -0,0 +1,67 @@ +package teams + +import ( + "errors" + "time" +) + +// ── THE WRAP-UP CLOCK, KEPT IN THE FILE ───────────────────────────────────── +// +// A wrap-up is bounded by time (internal/session's wrapUpFor, fifteen minutes +// when the product sets it). That clock used to live only in the manager +// process, so quitting codeaf or an engine restart forgot it and the team +// never closed, or the next process started the fifteen minutes again. +// +// THE RECORD IS THIS, on the team, written through [Change] and [ChangeIf] +// like every other mutation of teams.json. Started is when the wrap-up began +// and Bound is how long it was given, so a process that finds one computes +// the time left as Bound minus how long since Started, and one already past +// Bound closes on the same road a live clock would have. Absent is none: a +// file from before this field loads with [Team.Wrap] nil, and a team with no +// wrap-up is written without the key. +// +// A SECOND REQUEST DOES NOT RESET THE CLOCK. [File.SetWrap] keeps the first +// start, the same rule the session keeps in memory. [File.ClearWrap] is the +// end: the report went out, or the bound was already past and the incomplete +// report was raised. Closing the team clears it too ([File.Close]). + +// Wrap is one team's wrap-up in progress. +type Wrap struct { + // Started is when the wrap-up began. + Started time.Time `json:"started"` + // Bound is how long it was given. It is stored as a number of nanoseconds, + // which is how a duration is written in JSON, so an old reader that does + // not know the field still leaves it alone. + Bound time.Duration `json:"bound"` +} + +// ErrWrap is [File.SetWrap] handed a start or a bound that cannot be resumed. +var ErrWrap = errors.New("teams: a wrap-up needs a start and a bound") + +// SetWrap records a wrap-up on team id, once. A wrap-up already recorded is +// left as it was, so a second request keeps the first clock. started and +// bound must both be set. +func (f *File) SetWrap(id string, started time.Time, bound time.Duration) error { + i, err := f.at(id) + if err != nil { + return err + } + if f.Teams[i].Wrap != nil { + return nil + } + if started.IsZero() || bound <= 0 { + return ErrWrap + } + f.Teams[i].Wrap = &Wrap{Started: started, Bound: bound} + return nil +} + +// ClearWrap forgets team id's wrap-up. A team with none is left as it was. +func (f *File) ClearWrap(id string) error { + i, err := f.at(id) + if err != nil { + return err + } + f.Teams[i].Wrap = nil + return nil +} diff --git a/internal/teams/wrapup.go b/internal/teams/wrapup.go new file mode 100644 index 0000000000..add703b88d --- /dev/null +++ b/internal/teams/wrapup.go @@ -0,0 +1,89 @@ +package teams + +import ( + "errors" + "strings" + "time" +) + +// ── WRAP UP FIRST, AND THE CLOSE THAT FOLLOWS A CLOSING REPORT ────────────── +// +// The ruling (c-9): when a team with running work is closed, the person's +// default is `Wrap up first`. The manager tells its members to finish and +// commit, answers what it can, and brings the person a closing report as a +// [PacketClosing] packet; the team closes only when the person accepts it. +// +// THE REQUEST IS ONE LINE OF TRAFFIC, because Traffic is the only channel +// between the interface and the session (section 5 of the design): a +// [KindDirective] from [FromYou] to [ToManager] whose State is [StateWrapUp]. +// State, not the words, is the marker, so the interface can say whatever it +// likes in Text and a reader never matches prose. [WrapUpRequest] builds it +// and [IsWrapUp] reads it; both sides use these two and nothing else. +// +// ACCEPTING THE REPORT CLOSES THE TEAM, through [AcceptClosing], which both +// the interface (on the person's click) and the manager's session (on reading +// the decision) may call: it is idempotent, so whichever runs second finds the +// team closed and does nothing. + +// StateWrapUp marks a [KindDirective] as the person's `Wrap up first`. +const StateWrapUp = "wrap-up" + +// WrapUpText is the words a wrap-up request carries when the interface gives +// none. +const WrapUpText = "Wrap up first: ask everyone to finish and commit, then bring me a closing report." + +// WrapUpRequest is the Traffic entry the interface appends to a team's log to +// ask its manager to wrap up. text may be "" for [WrapUpText]. +func WrapUpRequest(text string) Entry { + if strings.TrimSpace(text) == "" { + text = WrapUpText + } + return Entry{Kind: KindDirective, From: FromYou, To: ToManager, State: StateWrapUp, Text: text} +} + +// IsWrapUp reports whether e is the person's wrap-up request. +func IsWrapUp(e Entry) bool { + return e.Kind == KindDirective && e.From == FromYou && e.State == StateWrapUp +} + +// ErrNotClosing is [AcceptClosing] handed a packet that is not a closing +// report. +var ErrNotClosing = errors.New("teams: that packet is not a closing report") + +// AcceptClosing closes the team a decided closing packet was raised from when +// its decision is [OptionClose] or [OptionCloseNow], records the packet as the +// team's report, and appends a [KindClose] line to its Traffic. It reports +// whether this call closed the team: false for a decision to keep going, for +// a team already closed (by the other side, or by hand), and for a packet +// still waiting. +func AcceptClosing(profileDir string, p Packet) (bool, error) { + if p.Kind != PacketClosing { + return false, ErrNotClosing + } + if p.State != PacketDecided || (p.Decision != OptionClose && p.Decision != OptionCloseNow) { + return false, nil + } + closed := false + name := "" + err := Update(profileDir, func(f *File) error { + t, ok := f.Team(p.Origin) + if !ok || t.Closed() { + return nil + } + if err := f.Close(p.Origin, time.Now(), p.ID); err != nil { + return err + } + closed, name = true, t.Name + return nil + }) + if err != nil || !closed { + return false, err + } + by := FromYou + if p.DecidedBy != Person && p.DecidedBy != "" { + by = FromManager + } + _ = AppendTraffic(profileDir, p.Origin, Entry{Kind: KindClose, From: by, To: ToEveryone, + Packet: p.ID, Text: "closed " + name + " on its closing report"}) + return true, nil +} diff --git a/internal/teams/wrapup_test.go b/internal/teams/wrapup_test.go new file mode 100644 index 0000000000..5723664a3b --- /dev/null +++ b/internal/teams/wrapup_test.go @@ -0,0 +1,128 @@ +package teams + +import ( + "os" + "strings" + "testing" +) + +// THE PACKET FILE ROTATES AND LOSES NOTHING WAITING. With a tiny rotation +// size, a packet raised, one escalated and one decided, then enough raises to +// rotate twice: every packet still waiting reads back as it stood (the +// escalated one still escalated, at the team it went to), the rotated file +// exists, the current file is small again, and a packet decided just before +// the last rotation is still readable by id (its raiser is handed the answer +// from it). +func TestThePacketFileRotatesAndKeepsEveryWaitingPacket(t *testing.T) { + dir := packetTeams(t) + old := decisionsRotateBytes + decisionsRotateBytes = 4096 + t.Cleanup(func() { decisionsRotateBytes = old }) + + waiting, err := Raise(dir, conflict()) + must(t, err) + up, err := Raise(dir, conflict()) + must(t, err) + if _, err := Escalate(dir, up.ID, "lead", "aaaaaaaaaaaa", "not mine to judge"); err != nil { + t.Fatal(err) + } + var decided Packet + for i := 0; i < 12; i++ { + p, err := Raise(dir, conflict()) + must(t, err) + decided, err = Decide(dir, p.ID, "lead", "1", "matches the rest") + must(t, err) + } + path := DecisionsPath(dir, "bbbbbbbbbbbb") + if _, err := os.Stat(decisionsRotated(path)); err != nil { + t.Fatalf("the file never rotated: %v", err) + } + if info, err := os.Stat(path); err != nil || info.Size() > decisionsRotateBytes { + t.Fatalf("the current file is %v after rotating (%v)", info, err) + } + open, _, err := OpenPackets(dir, ScopeAll) + must(t, err) + got := map[string]Packet{} + for _, p := range open { + got[p.ID] = p + } + if len(open) != 2 || got[waiting.ID].State != PacketOpen { + t.Fatalf("waiting packets after rotation: %+v", open) + } + if e := got[up.ID]; e.State != PacketEscalated || e.Team != "aaaaaaaaaaaa" || len(e.Trail) != 1 { + t.Fatalf("the escalated packet lost its state across rotation: %+v", e) + } + back, err := PacketByID(dir, decided.ID) + if err != nil || back.State != PacketDecided || back.Decision != "1" { + t.Fatalf("the last decided packet: %+v %v", back, err) + } + // And a fresh process (an empty memory) folds the two files the same way. + forgetPackets(dir) + again, _, err := OpenPackets(dir, ScopeAll) + if err != nil || len(again) != 2 { + t.Fatalf("a fresh fold across rotation: %+v %v", again, err) + } + // A waiting packet can still be decided after its raise rotated away. + if _, err := Decide(dir, waiting.ID, "lead", "2", "the handler is newer"); err != nil { + t.Fatalf("a carried packet could not be decided: %v", err) + } +} + +// A QUESTION'S ANSWER READS AS ONE ON THE RAIL. +func TestAQuestionsAnswerIsLoggedAsAnswered(t *testing.T) { + dir := packetTeams(t) + p, err := Raise(dir, Packet{Team: "bbbbbbbbbbbb", Kind: PacketQuestion, RaisedBy: "web", Question: "tabs or spaces?"}) + must(t, err) + if _, err := Decide(dir, p.ID, FromManager, "tabs", "the repo uses tabs"); err != nil { + t.Fatal(err) + } + log, err := ReadTraffic(dir, "bbbbbbbbbbbb", "", 0) + must(t, err) + last := log[len(log)-1] + if last.Kind != KindPacket || last.State != PacketDecided || last.Text != "answered @web: tabs" { + t.Fatalf("the answer's line: %+v", last) + } +} + +// THE WRAP-UP MARKER IS THE STATE, NOT THE WORDS, and accepting a closing +// report closes the team once, whichever side calls it first. +func TestWrapUpMarkerAndAcceptingAClosingReport(t *testing.T) { + e := WrapUpRequest("") + if !IsWrapUp(e) || e.Text != WrapUpText || e.To != ToManager { + t.Fatalf("the request: %+v", e) + } + if IsWrapUp(Entry{Kind: KindDirective, From: FromYou, To: ToManager, Text: WrapUpText}) { + t.Fatal("words without the marker read as a wrap-up") + } + dir := packetTeams(t) + p, err := Raise(dir, Packet{Team: Person, Origin: "bbbbbbbbbbbb", Kind: PacketClosing, RaisedBy: FromManager, + Question: "close dock?", Report: &ClosingReport{Done: "the form", Files: []string{"web/form.go"}}, + Options: []Option{{ID: OptionClose, Label: "Close", Consequence: "dock closes"}, + {ID: OptionKeepGoing, Label: "Keep going", Consequence: "dock stays open"}}}) + must(t, err) + if closed, err := AcceptClosing(dir, p); closed || err != nil { + t.Fatalf("a waiting report closed the team: %v %v", closed, err) + } + p, err = Decide(dir, p.ID, Person, OptionClose, "") + must(t, err) + closed, err := AcceptClosing(dir, p) + if !closed || err != nil { + t.Fatalf("accepting did not close: %v %v", closed, err) + } + if again, err := AcceptClosing(dir, p); again || err != nil { + t.Fatalf("a second accept closed again: %v %v", again, err) + } + f, err := Load(dir) + must(t, err) + dock, _ := f.Team("bbbbbbbbbbbb") + if !dock.Closed() || dock.Report != p.ID { + t.Fatalf("dock after accepting: %+v", dock) + } + log, _ := ReadTraffic(dir, "bbbbbbbbbbbb", "", 0) + if last := log[len(log)-1]; last.Kind != KindClose || !strings.Contains(last.Text, "closed dock") { + t.Fatalf("no close line: %+v", last) + } + if _, err := AcceptClosing(dir, Packet{Kind: PacketCap}); err != ErrNotClosing { + t.Fatalf("a cap packet: %v", err) + } +} diff --git a/internal/tui3/app.go b/internal/tui3/app.go index 105239f1c7..db696bb8da 100644 --- a/internal/tui3/app.go +++ b/internal/tui3/app.go @@ -176,6 +176,10 @@ const ( // records, and rather than a note because a note is a static sentence where // this opens as a question with a clock on it. entryStanding + // entryTeam is ONE NOTE A CONVERSATION'S TEAM SENT IT, drawn as the quoted + // cards it is (teamcard.go) rather than as the session's dim lane or the + // person's own line. + entryTeam ) // toolState is where one call is in its life, and it is the whole of what the @@ -248,6 +252,10 @@ type entry struct { discussionID string discussionIndex int + // team is what a team delivery handed the conversation, line by line, on + // an [entryTeam] (teamcard.go); nil on every other entry. + team []session.TeamLine + kind entryKind text string turn int @@ -275,6 +283,10 @@ type entry struct { // ([app.noteBlock] says why, and a subharness card is the only shape that // asks for it). It is false on every other note, which is nearly all of them. block bool + // sheet says this note is a column, so a wrapped row keeps the column its + // first line already uses ([wrapSheet]). /help is the one note that asks + // for it: a continuation that started at the margin read as another key. + sheet bool // told says this note is ADDRESSED TO THE PERSON rather than narration // about the machinery, so the work chip may not swallow it (workfold.go's @@ -492,6 +504,10 @@ type entry struct { // a value it cost the idle frame seven percent, which is most of what the // memo was buying. hung *toolBlock + // thread is the memo of a thread card: what a manager's team_send row + // hangs, or the answers under a team note's quoted line + // (teamthreadcard.go). A pointer for the reason hung is one. + thread *threadMemo // demoted says THIS PROSE WAS NARRATION AND NOT THE ANSWER, and it is the // whole of THE ANSWER HIERARCHY as far as a renderer is concerned @@ -1370,6 +1386,28 @@ type app struct { // THE KEY IS THE CANONICAL TRANSCRIPT PATH ([convKey]), because that is what // home names a row by and what the flock is taken on. behind map[string]*kept + // wall is the grid of every open conversation and the teams (wallcontract.go). + wall wallState + // traffic is the Traffic log's cache, its clock and its rail + // (teamtraffic.go). + traffic trafficState + // teamsDisk is where the teams are kept and the edits not yet written + // there (teamseam.go). + teamsDisk teamsDisk + // teamMenu is the strip chip's team switcher (teammenu.go). + teamMenu teamMenu + // tp is the teams page's own state: its selection, its reading of the + // store and the targets it drew (teamspage.go). + tp teamsPage + // tsheet is a team's card: its settings, its close and its delete + // (teamsheet.go). + tsheet teamSheet + // tmove is the `Move into…` picker, and tdrag a drag in the teams page's + // rail (teammove.go, teamdrag.go); tcrew is the teams page's members card + // (teamcrew.go). + tmove teamMove + tdrag teamDrag + tcrew teamCrew // frontWaits is the engine's answer to whether the conversation in front is // stopped on a person ([session.Agent.NeedsPerson]), asked once per message // on the loop and read by every frame ([app.frontSignal]). It is the front @@ -2015,39 +2053,32 @@ type app struct { // stamp stands still for ever and this is the only thing that says a task // somebody just started belongs on the page they are looking at. railStamp uint64 - // THE ROSTER'S OWN FACTS (task.go's rail). railOpen holds the FAMILIES a - // person has folded or opened AGAINST their default — nil is the design as - // shipped, and an absent key is a family nobody has touched, which is why this - // is a map keyed by node id and not a flag on the node. railTop is the - // window's offset into the SCROLLING PART of the roster's line list — the part - // under the pinned live head ([app.railLiveHead]), because work that is still - // going never leaves this column — resolved by the same [listTop] every other - // list on this surface scrolls with. railWhere is the focused row, - // named by id rather than by index because a fold takes rows out from under a - // cursor while nobody is looking, and railHold says the roster has been GIVEN - // the keyboard (alt+t) — without it there is no cursor, and every key still - // belongs to the draft. + // THE ROSTER'S OWN FACTS (task.go's rail). railTop is the window's offset + // into the roster's line list, resolved by the same [listTop] every other + // list on this surface scrolls with. railWhere is the focused row, named by + // identity rather than by index because a fold takes rows out from under a + // cursor while nobody is looking, and railHold says the roster has been + // GIVEN the keyboard (alt+t): without it there is no cursor, and every key + // still belongs to the draft. // - // railWide is the third width tier, asked for with w and sticky until it is - // asked for again. railCramped is what earns the offer of it: the last layout - // cut a title with its own indent, and it is written where that is discovered - // ([app.railEntryRows]) and read by the footer, the way [app.railTop] is - // written by the window it resolves. + // railWide is the third width tier, asked for with alt+w and sticky until + // it is asked for again. // // railAway is the person's own standing answer to whether there is a column at - // all (ctrl+g, [app.railStow]). It outranks every width tier and the roster's - // own "one node raises it" rule alike — a column somebody put away stays away, - // through landings and new work and the next session, until they ask for it - // back — and it is the one piece of this block that survives the process, - // because it is the only one a person chose deliberately (config's - // ui.task_column). - railOpen map[uint64]bool - railTop int - railWhere railSpot - railHold bool - railWide bool - railCramped bool - railAway bool + // all (alt+l or ctrl+g, [app.railStow]). It outranks every width tier: a + // column somebody put away stays away, through landings and new work and the + // next session, until they ask for it back, and it is the one piece of this + // block that survives the process, because it is the only one a person chose + // deliberately (config's ui.task_column). + railTop int + railWhere railSpot + railHold bool + railWide bool + railAway bool + // side is the side column's own memory for the session: which of its two + // words is in front per kind of chat, what is folded, and where the + // Traffic's `new` line stands (sidecol.go). + side sideState // away is the last reading of what the project's OTHER windows have out // right now, and when it was taken (taskview.go's [app.refreshElsewhere]). // It is a CACHE and not a subscription: the reading is a readdir and a @@ -2210,15 +2241,19 @@ type app struct { // so the flags are gone and the frame, the keyboard, the pointer and the tab // bar all read this. page page - // tabs and tabRow are WHERE THE TAB BAR WAS LAST PAINTED — one span per chip - // that survived the width ladder, and the row of the terminal the bar landed - // on (-1 when a short frame cut it off). They are written by the draw - // (pages.go's [placeFrameWithBar]) and read by the press, which is the same - // bargain every hit map on this surface strikes: a click resolves against - // what was actually drawn, never against what a second computation thinks - // was drawn. + // tabs and tabRow are WHERE THE NAV WAS LAST PAINTED: one span per place's + // button that survived the width ladder, and the row of the terminal the + // nav landed on (-1 on a frame with no head). They are written by the draw + // (head.go's [app.headRows], topnav.go's [app.navLine]) and read by the + // press, which is the same bargain every hit map on this surface strikes: a + // click resolves against what was actually drawn, never against what a + // second computation thinks was drawn. tabs []placeTabSpan tabRow int + // navMemo is the nav's row as it was last laid out, and navMore is its + // fold, `more ▾`, and the menu of places behind it (topnav.go, navmore.go). + navMemo navMemo + navMore navMore // boxRow and boxRows are WHERE A PLACE'S COMPOSER WAS LAST PAINTED — the row // its first line landed on and how many lines it took — written by the same // draw and read by the same press, on [app.chatTabs]'s bargain exactly. A click @@ -2240,9 +2275,9 @@ type app struct { // answers to one question. bar barCursor // tabHover is the place whose word the POINTER is resting on, and [pageNone] - // — the zero value — is "the pointer is not on the bar at all". It is what - // lifts one word's ink by one tier and changes nothing else on the frame - // (placemouse.go's [app.placeTabHover]). + // (the zero value) is "the pointer is not on the nav at all". It is what + // puts one word on the pointer's ground and changes nothing else on the + // frame (topnav.go's [app.navHover]). tabHover page // searchArm is how the search place's QUIET INTERVAL is armed, and nil — the // real 150ms timer — everywhere but a test (place_search.go's @@ -2332,6 +2367,11 @@ type app struct { // pointer — the same arrangement the model segment and the jump chip use // (render.go's [hudSpan]). homeDoor hudSpan + // dock is where the row under the box drew its map of every open + // conversation on the last frame, and dockList the list it drew from, + // kept so the next frame refills it rather than allocating (walldock.go). + dock dockMap + dockList []chatTab // echoHome is raised around the one dispatch home makes on its own behalf // ([app.homeSlash]), and it is what tells a command's answer apart from every // other note this surface writes ([app.noteWritten] holds the argument). @@ -2872,6 +2912,7 @@ func newApp(ctx context.Context, opts Options) *app { resume: opts.Resume, shared: opts.SharedAgent, stands: opts.Standing, + teamsDisk: teamsDisk{door: opts.Teams}, link: opts.Link, conns: opts.Connections, harn: opts.Harnesses, @@ -3227,6 +3268,10 @@ var _ tea.Model = (*app)(nil) // has no wakeups; a hosted one also owns hostlink.go's separate five-second // measurement clock. func (a *app) Init() tea.Cmd { + // THE TEAMS ARE READ ONCE, HERE, so the strip's switcher is there from the + // first frame for a person who has teams (teams.go, teammenu.go). It is one + // small file, and the frame only ever reads what this loaded. + a.teamsEnsure() // EVERY PICTURE ALREADY ON SCREEN IS STAT'D HERE, before the first frame asks // about any of them. This is `open`, which is one of the two loops the fourth // law lets read the disk, and it is the only reason a RESUMED conversation @@ -3294,7 +3339,10 @@ func (a *app) Init() tea.Cmd { a.setupDemoCmd(), a.checkForUpdate(), a.launchCredits(), a.creditWake.waitRing(), titleSend(a.titleSent), // AND THE TWO DOORS INTO THE LOOP FROM ELSEWHERE, each with its one // command parked on it (doorbell.go). - a.news.waitRing(), a.leaving.waitRing()} + a.news.waitRing(), a.leaving.waitRing(), + // AND THE TEAMS' FIRST READ, when the seam held nothing to load above + // (teamseam.go); nil on every local launch. + a.teamsWrite()} if a.welcome.animating() { standing = append(standing, a.wake()) } @@ -3342,7 +3390,16 @@ func (a *app) Update(msg tea.Msg) (tea.Model, tea.Cmd) { if mode, ok := msg.(tea.ModeReportMsg); ok { a.ruler.noteModeReport(mode) } + if _, ok := msg.(trafficLandedMsg); ok { + a.touch() + return a, nil + } model, cmd := a.update(msg) + // A JUMP TO A MESSAGE WAITING FOR ITS CONVERSATION lands here, on the first + // message after that conversation is in front (teamjump.go). + if a.traffic.jump.key != "" { + cmd = tea.Batch(cmd, a.trafficLand()) + } // THE ENGINE'S ONE QUESTION ABOUT A PERSON IS ASKED HERE, once per message, // and never by a frame. It is what every held tab's watcher asks after every // event its conversation produces (keeper.go), asked of the conversation in @@ -3379,6 +3436,26 @@ func (a *app) Update(msg tea.Msg) (tea.Model, tea.Cmd) { if hold := a.takeQuestionHolds(); hold != nil { cmd = tea.Batch(cmd, hold) } + // AND THE TRAFFIC CLOCK IS ARMED HERE, for the reason the title is asked + // here: a team made, a member joined, a manager opened, each happens by some + // message, and this is the one place every one of them has happened by + // (teamtraffic.go). It costs a walk of the loaded teams when it is not + // turning and nothing when it is. + if tick := a.trafficArm(); tick != nil { + cmd = tea.Batch(cmd, tick) + } + // AND AN EDIT TO THE TEAMS IS WRITTEN HERE, off the loop, for the same + // reason: every door that edits a team has happened by now, and it costs a + // length check when nothing was edited (teamseam.go). + if write := a.teamsWrite(); write != nil { + cmd = tea.Batch(cmd, write) + } + // AND THE TEAMS PAGE SETTLES WHICH CONVERSATION ITS PANE HOSTS, after + // every message that could have moved the front (teamspagehost.go). One + // comparison on every other place. + if bring := a.teamsSync(); bring != nil { + cmd = tea.Batch(cmd, bring) + } // AND THE TERMINAL'S TITLE IS ASKED AFTER EVERY MESSAGE, because this is // the one place every change to where a person stands has already happened // by — a place entered, a name arriving, a question coming up — and it is @@ -3410,6 +3487,12 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { // not survive has news, and a person who presses a key gets it rather than // waiting for whatever repaints next. a.takeLinkNotice() + // THE TEAMS PAGE TAKES WHAT IS ITS OWN AND HANDS THE REST TO THE MANAGER'S + // CONVERSATION it hosts (teamspagehost.go). One comparison on every other + // place. + if cmd, took := a.teamsRoute(msg); took { + return a, cmd + } switch msg := msg.(type) { case tea.WindowSizeMsg: // A zero size is a terminal that could not say — a headless boot, a @@ -3502,6 +3585,12 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { return a, tea.Batch(flushed, cmd) } } + // THE TRAFFIC'S KEYS READ NEXT (teamrailpointer.go): esc while its card + // is over the body, and the two chords that show it and go to the + // manager, which carry no text and take nothing from the box. + if cmd, took := a.trafficKeyPress(msg); took { + return a, tea.Batch(flushed, cmd) + } // THE ROSTER READS NEXT, and only ever once it has been HANDED the // keyboard (alt+t, task.go). Explicit focus outranks ambient place: a room // is where a person is, the roster is what they just asked for, and esc @@ -3636,10 +3725,15 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { return a, nil } a.comp.all, a.comp.loaded, a.comp.loading = msg.paths, true, false + a.fillMentions() a.comp.rank() a.touch() return a, nil + case mentionRecentsMsg: + a.mentionRecentsLoaded(msg.rows) + return a, nil + case tasksLoadedMsg: return a, a.tasksLoaded(msg.rows, msg.known) @@ -3683,7 +3777,30 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { // window to let go of (takeover.go). return a, a.takeoverTick(msg) + case wallReadMsg: + a.wallTakeRead(msg) + return a, nil + + case wallTickMsg: + return a, a.wallTick() + + case trafficTickMsg: + // A TURN THAT FOUND NOTHING DRAWS NOTHING: the frame before it stands + // (teamtraffic.go), which is what a quiet second over ssh costs. + cmd, quiet := a.trafficTick(msg) + if quiet { + a.ptr.still = a.drawn + } + return a, cmd + + case wallNameTimeMsg: + a.wallNameTimedOut(msg.gen) + return a, nil + case behindStirMsg: + if a.wall.on { + return a, tea.Batch(a.behindStir(msg), a.wallStir(msg.key)) + } // A conversation this process holds and is not drawing has something to // say about itself. The message carries no content — the surface reads // the agent it already has a pointer to (keeper.go). @@ -3721,6 +3838,22 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { return a, a.historyPrefetched(msg) case tea.MouseWheelMsg: + // A notch, a press and a release are never a still frame, even when the + // motion spent ahead of them in the same message was one (wall.go's + // [app.wallMotion]). + a.ptr.still = false + // A wheel under the switcher puts it away: it hangs from the strip, + // and the page under it is about to move. + if a.teamMenu.on { + a.closeTeamMenu() + } + if a.tsheet.on || a.tmove.on { + return a, nil + } + if a.wall.on { + a.wallWheel(msg.Mouse().X, msg.Mouse().Y, msg.Mouse().Button == tea.MouseWheelDown) + return a, nil + } a.clearPlaceRowHover() a.placePointer.suspended = true // THE CONTEXT CHOOSER OWNS THE WHEEL WHILE IT IS UP, and it owns it over @@ -3754,11 +3887,11 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { if a.questionDialogWheel(msg) { return a, nil } - // THE TAB BAR IS READ BEFORE EVERY PLACE'S OWN ROWS, exactly as it is for - // the press: it is the router's row, drawn on all seven places in the same - // cells, so a wheel answered by the place under it would scroll a list for - // a gesture made over a row that is not that list's. Over the bar the - // wheel walks the PLACES, one room a tick (placemouse.go's + // THE NAV IS READ BEFORE EVERY PLACE'S OWN ROWS, exactly as it is for + // the press: it is the router's row, drawn on every page in the same + // cells, so a wheel answered by the place under it would scroll a list + // for a gesture made over a row that is not that list's. Over the nav on + // a place the wheel walks the PLACES, one room a tick (placemouse.go's // [app.placeTabWheel]). if cmd, took := a.placeTabWheel(msg.Mouse().Y, placeWheelDelta(msg.Mouse().Button)); took { return a, cmd @@ -3926,8 +4059,38 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { return a, nil case tea.MouseClickMsg: + a.ptr.still = false a.clearPlaceRowHover() a.sawAPerson() + // THE TEAM SWITCHER OWNS THE PRESS WHILE IT IS UP, as a menu does: + // its rows answer, and a press off it only puts it away (teammenu.go). + if a.teamMenu.on && msg.Mouse().Button == tea.MouseLeft { + return a, a.teamMenuPress(msg.Mouse().X, msg.Mouse().Y) + } + // AND THE NAV'S FOLD MENU, on the same terms (navmore.go). + if a.navMore.on && msg.Mouse().Button == tea.MouseLeft { + return a, a.navMorePress(msg.Mouse().X, msg.Mouse().Y) + } + // The move picker, over everything, and then a team's card own the + // press while they are up, on the same terms (teammove.go, + // teamsheet.go). + if a.tmove.on { + if msg.Mouse().Button == tea.MouseLeft { + return a, a.teamMovePress(msg.Mouse().X, msg.Mouse().Y) + } + return a, nil + } + if a.tsheet.on { + if msg.Mouse().Button == tea.MouseLeft { + return a, a.teamSheetPress(msg.Mouse().X, msg.Mouse().Y) + } + return a, nil + } + if a.wall.on && msg.Mouse().Button == tea.MouseLeft { + if cmd, took := a.wallPress(msg.Mouse().X, msg.Mouse().Y); took { + return a, cmd + } + } // AND IT OWNS THE PRESS, on the same terms and for a sharper reason: a // press that fell through a modal would switch a tab, open a tool call or // answer a question behind a sheet somebody is looking at @@ -3959,13 +4122,14 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { return a, nil } if msg.Mouse().Button == tea.MouseLeft { - // THE TAB BAR IS READ BEFORE EVERY PLACE'S OWN ROWS, because it is - // the router's row and not any place's: it is drawn on every one of - // them, in the same cells, and a press answered by the place under it - // would be the one row of the frame that means something different - // depending on which room you happen to be standing in - // (placemouse.go's [app.placeTabPress]). - if cmd, took := a.placeTabPress(msg.Mouse().X, msg.Mouse().Y); took { + // THE NAV IS READ BEFORE EVERY PAGE'S OWN ROWS, because it is the + // router's and not any page's: row zero is the places on every + // page, and a press answered by the page under it would be the one + // row of the frame that means something different depending on + // where you happen to be standing (topnav.go's [app.navPress]). + // The strip is a chat's row. On a place it is not drawn, so the + // row under the nav is the page's. + if cmd, took := a.navPress(msg.Mouse().X, msg.Mouse().Y); took { return a, cmd } // AND HOME'S RULE IS READ BEFORE HOME'S OWN ROWS, on the tab bar's @@ -4099,6 +4263,11 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { if cmd, took := a.harnessPickPress(msg.Mouse().Y); took { return a, cmd } + // AND THE @ LIST'S PREFIX WORDS, which are columns of its first row + // (mention.go). A press anywhere else on that list still falls through. + if cmd, took := a.mentionHeadPress(msg.Mouse().X, msg.Mouse().Y); took { + return a, cmd + } // AND THE SKILL PICKER TAKES A PRESS ON ITS OWN ROWS AND NOTHING // ELSE, on exactly the harness picker terms (skillpick.go). if cmd, took := a.skillPickPress(msg.Mouse().Y); took { @@ -4130,6 +4299,13 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { if cmd, took := a.homeDoorPress(msg.Mouse().X, msg.Mouse().Y); took { return a, cmd } + // AND THE DOCK AT THE OTHER END OF THAT ROW, column-aware for the + // same reason: `▦` opens the wall and each cell goes to its + // conversation, and the blank between them and the keys is nothing + // (walldock.go). + if cmd, took := a.dockPress(msg.Mouse().X, msg.Mouse().Y); took { + return a, cmd + } // AND THE MODEL'S NAME IS THE FOURTH, at the left end of the same // legend: the conversation's model is written on the seam and pressing // it opens the picker (foot.go's [app.legendModelPress]). @@ -4273,6 +4449,7 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { return a, nil case tea.MouseReleaseMsg: + a.ptr.still = false // A RELEASE UNDER THE CHOOSER ENDS NOTHING, because nothing under it was // started: the press it would close was taken by the sheet, and letting // this one through would end a sweep of a transcript nobody swept @@ -4308,6 +4485,29 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { case tea.MouseMotionMsg: a.sawAPerson() + // THE WALL OWNS MOTION WHILE IT IS UP, as it owns the press: its own + // targets light under the pointer, and the strip above it still does + // (wall.go). + if a.teamMenu.on { + a.teamMenuMotion(msg.Mouse().X, msg.Mouse().Y) + return a, nil + } + if a.navMore.on { + a.navMoreMotion(msg.Mouse().X, msg.Mouse().Y) + return a, nil + } + if a.tmove.on { + a.teamMoveMotion(msg.Mouse().X, msg.Mouse().Y) + return a, nil + } + if a.tsheet.on { + a.teamSheetMotion(msg.Mouse().X, msg.Mouse().Y) + return a, nil + } + if a.wall.on { + a.wallMotion(msg.Mouse().X, msg.Mouse().Y) + return a, nil + } // AND THE CHOOSER OWNS MOTION TOO, ahead of the sweep and ahead of every // place: [app.hoverTarget] already answers for the whole screen while the // sheet is up, and this branch is what keeps a drag started under it from @@ -4350,12 +4550,20 @@ func (a *app) route(msg tea.Msg) (tea.Model, tea.Cmd) { if msg.Mouse().Button == tea.MouseLeft && a.dragMotion(msg.Mouse().X, msg.Mouse().Y) { return a, nil } - // AND THE TAB BAR IS READ BEFORE EVERY PLACE'S OWN ROWS HERE TOO, for the - // press's own reason: the bar is the router's row and means the same thing - // on all seven places, so the word under the pointer lifts wherever a - // person is standing (placemouse.go's [app.placeTabHover]). + // AND THE HEAD IS READ BEFORE EVERY PAGE'S OWN ROWS HERE TOO, for the + // press's own reason: the nav and the strip are the router's rows and + // mean the same thing on every page, so the button under the pointer + // takes its ground wherever a person is standing (topnav.go's + // [app.headHover]). a.hoverDraftSeam(msg.Mouse().X, msg.Mouse().Y) - if a.placeTabHover(msg.Mouse().X, msg.Mouse().Y) { + if a.headHover(msg.Mouse().X, msg.Mouse().Y) { + // AND THE HEAD TAKES THE POINTER OFF HOME'S PROJECT NAMES, which + // underline under the pointer alone (home.go's [app.homeHover]) and + // would otherwise stay lit after it left them for the nav. + if a.home.projectHover != -1 { + a.home.projectHover = -1 + a.touch() + } return a, nil } if a.at(pageSettings) { @@ -5156,6 +5364,10 @@ func (a *app) paint() tea.Cmd { // paragraph would freeze mid-word until something unrelated asked // for a frame (reveal.go). a.liveRevealing() || + // AND THE WALL'S MOTION IS THE EIGHTEENTH: its tiles coming in row by + // row, an opened tile growing into the frame, and a working tile's + // spinner, each a function of this clock's time (wall.go). + a.wallAnimating() || // AND A PLAN PAGE ON A RUNNING TASK IS THE SEVENTEENTH, and it is the // fourth that can be the whole of what is happening: the page follows a // live edge the store writes from another process, and no turn of ours @@ -5178,6 +5390,13 @@ func (a *app) paint() tea.Cmd { } return tea.Batch(kick, surfaceTick(every, func(time.Time) tea.Msg { return frameMsg{} })) } + // A WORKING TILE ON THE WALL turns its spinner at the spinner's own + // cadence and no faster: the glyph changes once a step, and a whole wall + // drawn thirty times a second to move one glyph a quarter as often would be + // the costliest frame on this surface spent on nothing (wall.go). + if a.wallSpinning() { + return tea.Batch(kick, surfaceTick(a.frameEvery()*spinnerStep, func(time.Time) tea.Msg { return frameMsg{} })) + } a.painting = false return kick } @@ -6729,8 +6948,8 @@ func (a *app) press(x, y int) (cmd tea.Cmd) { // row's own answer: the prose it sits in has no gesture of its own, and a // reference read after the body would be a door the body had already closed // the room behind (markdown.go's [linkifyTasks]). - if a.linkPress(x, r) { - return + if took, open := a.linkPress(x, r); took { + return open } // AND THE FOOT UNDER A TABLE THAT WAS CUT IS THE OTHER ONE, resolved here for // the same reason and in the same breath: it is a phrase inside a row of the @@ -6775,6 +6994,8 @@ func (a *app) press(x, y int) (cmd tea.Cmd) { a.toggleWorkfold(r.turn) case hitMore: a.showAll(r.entry) + case hitThread: + a.trafficToggle(r.open) case hitPictureOriginal: return a.openPictureAt(r.entry, r.pictureIndex) case hitPictures: @@ -6834,33 +7055,52 @@ func (a *app) press(x, y int) (cmd tea.Cmd) { // answer, which for a paragraph is nothing at all. The gap between two links is // a sentence, not a seam, and swallowing a click on it would make the paragraph // a place where missing costs you the page. -func (a *app) linkPress(x int, r row) bool { +// +// A TEAM REFERENCE IS THE SAME KIND OF DOOR (teamlink.go): a member opens, or +// is resumed and opened, and a team's name opens the teams page on it. +func (a *app) linkPress(x int, r row) (bool, tea.Cmd) { if len(r.links) == 0 || a.welcome.open { - return false + return false, nil } for _, link := range r.links { if link.span.holds(x) { + // A HANDLE ON A THREAD CARD OPENS ITS MEMBER AT THE MESSAGE: an + // answer at the member's own post, the card's header at the message + // as the member was told it (teamjump.go). + if land := a.threadRowLand(r); land != "" && link.member != "" { + if t, ok := a.teamByID(link.team); ok { + if m, ok := t.Member(link.member); ok { + return true, a.trafficJump(m.Key, land) + } + } + } + if link.team != "" { + return true, a.teamLinkPress(link) + } + if link.member != "" && link.id == 0 { + return true, a.mentionChatPress(link.member) + } a.openRoomFor(link.id, link.title) - return true + return true, nil } } - return false + return false, nil } // linkHoverAt is which reference of this row's BLOCK the pointer is over, and -1 -// for none. It is the ordinal rather than the position on the row for the reason +// for none, with a team reference's identity for the hint line ([teamLinkKey]). It is the ordinal rather than the position on the row for the reason // [taskLink.ord] carries one (markdown.go), and it is the same test [app.linkPress] // makes so the words that light are the words that open something. -func (a *app) linkHoverAt(x int, r row) int { +func (a *app) linkHoverAt(x int, r row) (int, string) { if len(r.links) == 0 || a.welcome.open { - return -1 + return -1, "" } for _, link := range r.links { if link.span.holds(x) { - return link.ord + return link.ord, teamLinkKey(link) } } - return -1 + return -1, "" } // statusPress resolves a click on the status row's MODEL SEGMENT, and reports @@ -7028,6 +7268,9 @@ func (a *app) slash(line string) tea.Cmd { // pasted into a shell. /status still prints it whole. help := helpText(a.hostedPath(tildePath(a.file, a.tilde)), a.chords) a.noteFacts(help, columnFacts(help, true)...) + if n := len(a.entries); n > 0 && a.entries[n-1].kind == entryNote { + a.entries[n-1].sheet = true + } return nil case "budget": @@ -7232,6 +7475,14 @@ func (a *app) slash(line string) tea.Cmd { // person then keeps typing into. return a.showPage(pageSearch) + case "wall": + // EVERY OPEN CONVERSATION AT ONCE, as a grid of live tiles (wall.go). + return a.openWall() + + case "teams": + // THE TEAM-LEVEL VIEW, which is a place (place_teams.go). + return a.showPage(pageTeams) + case "spend": // AND THE WHOLE MACHINE'S BILL, which is a place and not a note. This word // was an alias of /cost until this wave, so the one guess a developer makes @@ -7800,6 +8051,9 @@ func (a *app) renewRefusing(say func(string)) (tea.Cmd, bool) { if key := a.convKey(a.file); key != "" { a.rememberOpen(key) } + // A conversation started while a team is shown is one of that team + // (teams.go's [app.teamJoinFront]). + a.teamJoinFront() return cmd, true } @@ -8673,14 +8927,16 @@ func (a *app) syncLists() tea.Cmd { return read } was := a.comp.open + a.fillMentions() a.comp.sync(&a.input) if a.comp.open && !was { // The list coming up is the proof that `@` has been found (notice.go). a.noticeEvent(eventAtOpened) // Both halves of the list are asked for at the same moment, and neither // waits for the other: the index is one small file and lands first, the - // walk lands when it lands (taskmention.go, files.go). - return tea.Batch(a.loadFiles(), a.loadTasks()) + // walk lands when it lands (taskmention.go, files.go). The recent + // conversations ride the same opening (mention.go). + return tea.Batch(a.loadFiles(), a.loadTasks(), a.loadMentionRecents()) } return nil } diff --git a/internal/tui3/attach_test.go b/internal/tui3/attach_test.go index bceec8db16..2834c70500 100644 --- a/internal/tui3/attach_test.go +++ b/internal/tui3/attach_test.go @@ -101,7 +101,7 @@ func TestTheCompletionTagsThePicturesItWouldAttach(t *testing.T) { drive(t, a, key("@"), key("s"), key("h")) drive(t, a, filesLoadedMsg{paths: []string{"shot.png", "notes.md"}}) - rows := a.comp.rows(a.width, completeRows, a.pal, -1) + rows := a.comp.rows(a.width, completeRows, a.pal, -1, "") found := "" for _, r := range rows { if strings.Contains(plain(r), "shot.png") { @@ -243,7 +243,7 @@ func TestAnImageMessageMarksItsPicturesInTheTranscript(t *testing.T) { a.pathLinks = true // Wide enough that the sentence, its two tokens and its two markers land on // one row: this test is about what is drawn, not about where it wraps. - a.width = 100 + a.width = 120 a.attach(filepath.Join(dir, "shot.png")) a.attach(filepath.Join(dir, "chart.png")) typeLine(t, a, "what is wrong here") diff --git a/internal/tui3/background_test.go b/internal/tui3/background_test.go index ca02b3c8e7..66cadde625 100644 --- a/internal/tui3/background_test.go +++ b/internal/tui3/background_test.go @@ -77,8 +77,8 @@ func TestARunningCommandIsSentToTheBackgroundWithOneKey(t *testing.T) { if got := a.hintWord(); got != wantHint { t.Fatalf("the full running-turn hint is %q, want %q", got, wantHint) } - if door := plain(a.railDoorLine()); strings.Contains(door, "ctrl+g") || !strings.HasSuffix(door, "hide") { - t.Fatalf("the column footer names a key the command owns: %q", door) + if head, _ := a.sideHeadRow(a.railRoom()); strings.Contains(plain(head), "ctrl+g") || !strings.HasSuffix(strings.TrimSpace(plain(head)), sideHideKey) { + t.Fatalf("the column header names a key the command owns: %q", plain(head)) } drive(t, a, key("ctrl+g")) diff --git a/internal/tui3/barfold_test.go b/internal/tui3/barfold_test.go index 24cabf643e..17473ece44 100644 --- a/internal/tui3/barfold_test.go +++ b/internal/tui3/barfold_test.go @@ -3,54 +3,12 @@ package tui3 import ( "strings" "testing" - - "github.com/Agent-Field/codeaf/internal/tui2/tokens" - "github.com/charmbracelet/x/ansi" ) -// A FOLD ON THE PLACE BAR WEARS THE FOLD MARK, LIKE EVERY OTHER FOLD HERE. -// -// The bar's remainder said `+3 more` while the command menu's own tail said -// `▸ 3 more` about the same idea — a navigation list with more items than fit — -// so a `+3` at the end of a row could not be told from a count, a badge or a -// door. `▸` is the half that says which, and it is on every rung: the word -// `more` gives way before the mark does. -func TestTheBarsRemainderWearsTheSameFoldMarkTheMenusDoes(t *testing.T) { - // Wide enough for the whole sentence, then narrow enough that only the - // count survives, then too narrow for either. - long := foldLine(3, "") - short := tokens.GlyphCollapsed + " 3" - for _, c := range []struct { - room int - want string - }{ - {tabPadCols + ansi.StringWidth(long), long}, - {tabPadCols + ansi.StringWidth(short), short}, - {tabPadCols + ansi.StringWidth(short) - 1, ""}, - } { - got := barMoreWord(3, c.room) - if got != c.want { - t.Fatalf("with %d cells of room the bar drew %q, want %q", c.room, got, c.want) - } - } - // AND NO RUNG OF THE LADDER IS A BARE `+`, which is what it used to be at - // both lengths. - for _, room := range []int{40, 20, 12, 9, 8} { - if got := barMoreWord(4, room); got != "" && !strings.HasPrefix(got, tokens.GlyphCollapsed) { - t.Fatalf("with %d cells of room the bar drew %q, which wears no fold mark", room, got) - } - } - // AND IT IS THE SAME SPELLER THE MENU'S FOLD USES (commands.go draws - // foldLine), which is the whole of this row: one idea, one sentence. - if want := foldLine(3, ""); barMoreWord(3, 60) != want { - t.Fatalf("the bar drew %q and the menu's fold spells it %q", barMoreWord(3, 60), want) - } -} - // AND THE MAP'S CLAUSE ABOUT `→` SAYS WHAT THE KEY DOES. // // It read `→ verbs on this row` on a line where every other clause names an act: -// `alt+1…7 go to a place`, `alt+enter send it off as a task`, `esc close`. +// `alt+1…9 go to a place`, `alt+enter send it off as a task`, `esc close`. // `verbs` is the machinery's name for the strip, not anybody's word for what // pressing the key gets them. func TestTheMapNamesWhatTheArrowDoesAndNotWhatItIsCalled(t *testing.T) { diff --git a/internal/tui3/bundle_test.go b/internal/tui3/bundle_test.go index ed31984e1f..7fef7b52f8 100644 --- a/internal/tui3/bundle_test.go +++ b/internal/tui3/bundle_test.go @@ -3375,7 +3375,7 @@ func TestTheRailStandsWhileWorkIsAliveAndGoesWhenItLands(t *testing.T) { if !a.railShowing() { t.Fatal("an empty session drew no rail") } - if a.bodyWidth() != 200-railCols { + if a.bodyWidth() != 200-sideColsFor(200) { t.Fatalf("the empty column is not charged against the conversation: body=%d", a.bodyWidth()) } // AND IT SAYS WHAT IT IS FOR. Thirty blank columns beside a paragraph read as @@ -3406,6 +3406,7 @@ func TestTheRailStandsWhileWorkIsAliveAndGoesWhenItLands(t *testing.T) { // whose branch did not come home keeps the branch name. drive(t, a, streamEventMsg{gen: a.gen, ev: update(8, "Mix audio", session.TaskQueued, session.TaskNotice{})}, + streamEventMsg{gen: a.gen, ev: update(9, "Collect sources", session.TaskRunning, session.TaskNotice{})}, streamEventMsg{gen: a.gen, ev: update(9, "Collect sources", session.TaskFailed, session.TaskNotice{ Report: "the tests did not build", Merge: mergeWordAborted, Branch: "task/collect", })}, @@ -3413,32 +3414,28 @@ func TestTheRailStandsWhileWorkIsAliveAndGoesWhenItLands(t *testing.T) { Elapsed: 130 * time.Second, Merge: mergeWordConflicted, Branch: "task/fix-nil-map", })}, ) - // A retained report expands on request, without demanding a merge. - a.railSetOpen(a.tasks[9], true) - // A BRANCH NAME IS NEVER ELLIPSIZED: the conflicted sentence wraps inside - // the rail rather than losing the one handle back to the work, so the - // assertion is on the two halves and not on one line. + // THE QUEUED WORK IS ONE FOLDED ROW UNTIL IT IS OPENED, and the two rows + // that need the person are the band's: the conflicted branch in the + // needs-you amber, the failure a ✗ in ink (sidecol.go). + a.sideToggleGroup(railIdle) rail = plain(strings.Join(a.railRows(16), "\n")) - // ONE GLYPH OPENS EVERY ROW AND IT IS THE STATE. The identity ◆ is not on this - // column: it is the same cell on every task, this column holds nothing but - // tasks, and the two cells belong to the name here (task.go's [app.railLead]). for _, want := range []string{ glyphQueued + " Mix audio", - glyphBad + " Collect sources", - glyphDone + " Fix the nil-map", - "conflicted ·", "task/fix-nil-map", - // A STOPPED NODE DID NOT CRASH. session marks its branch "aborted"; the - // rail says what that is — it stopped, and the work is still on the branch - // named beside it. - // A NODE WHOSE BRANCH NEVER CAME HOME DID NOT CRASH. session marks it - // "aborted"; the rail says the reading's own sentence about it and names - // the branch the work is still on beside it. - "task/collect"} { + a.taskStateMark(a.tasks[9]) + " Collect sources", + a.taskStateMark(a.tasks[7]) + " Fix the nil-map", + } { if !strings.Contains(rail, want) { t.Fatalf("the rail is missing %q:\n%s", want, rail) } } - if strings.Contains(rail, mergeWordAborted) { + // A BRANCH NAME IS NEVER ELLIPSIZED: the row is one line, and the hint line + // under the pointer carries the handle back to the work whole. + for id, want := range map[uint64]string{7: "task/fix-nil-map", 9: "task/collect"} { + if hint := railHint(a, id); !strings.Contains(hint, want) { + t.Fatalf("the hint over node %d does not name %q: %q", id, want, hint) + } + } + if strings.Contains(rail+railHint(a, 9), mergeWordAborted) { t.Fatalf("the rail read the engine's own word for a stopped node:\n%s", rail) } @@ -3448,6 +3445,7 @@ func TestTheRailStandsWhileWorkIsAliveAndGoesWhenItLands(t *testing.T) { drive(t, a, streamEventMsg{gen: a.gen, ev: update(8, "Mix audio", session.TaskDone, session.TaskNotice{ Elapsed: 8 * time.Second, Merge: mergeWordMerged, })}) + railOpenAll(a) if !strings.Contains(plain(strings.Join(a.railRows(12), "\n")), "Mix audio") { t.Fatal("a merged node left the roster's record") } @@ -3571,33 +3569,49 @@ func TestTheRailNamesWhatABlockedNodeWaitsOn(t *testing.T) { DependsOn: []uint64{1}, })}, ) - // A NODE WITH NO FAMILY AROUND IT IS THE FLAT ROW THIS COLUMN ALWAYS DREW, and - // the sentence under it is the only place the surface says what is in the way - // (task.go's [app.railSaysMore]). + // THE ROW IS ONE LINE UNDER ITS GROUP, and the sentence on the hint line + // over it is the only place the surface says what is in the way. + railOpenAll(a) rail := plain(strings.Join(a.railRows(10), "\n")) if !strings.Contains(rail, "Mix audio") { t.Fatalf("the blocked node is not on the roster:\n%s", rail) } - if !strings.Contains(rail, "waits: Collect sources") { - t.Fatalf("a blocked node does not say what it waits on:\n%s", rail) + if hint := railHint(a, 2); !strings.Contains(hint, "waits: Collect sources") { + t.Fatalf("a blocked node does not say what it waits on: %q", hint) } // The prerequisite finishing takes the sentence away rather than leaving a // node waiting on work that is over. drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskDone, session.TaskNotice{ Merge: mergeWordMerged, })}) - if strings.Contains(plain(strings.Join(a.railRows(10), "\n")), "waits:") { - t.Fatalf("the wait outlived the work it waited on:\n%s", plain(strings.Join(a.railRows(10), "\n"))) + if hint := railHint(a, 2); strings.Contains(hint, "waits:") { + t.Fatalf("the wait outlived the work it waited on: %q", hint) } } -// underWidth is the cells a node's under-block actually gets at a rail width: -// the column less its seam ([app.railRoom]), less the two-cell indent every -// under-row is drawn behind ([app.railNodeRows]). The telemetry tests measure -// against it rather than against the column, because a test that asserted a row -// at railCols would be asserting four cells the row never had. +// railHint is what the hint line says with the pointer on node id's row: its +// whole name and what its row used to say under it (sidecol.go). +func railHint(a *app, id uint64) string { + hot := a.hot + a.hot = hoverAt{kind: hoverRail, id: id} + words := a.sideHoverWords() + a.hot = hot + return words +} + +// underWidth is the cells a node's under-block gets at a column width: the +// column less its seam, less a two-cell indent. The block is the hint line's +// now (sidecol.go's [app.sideHoverWords] reads [app.railUnder] at a width +// that never cuts it), and its sentences keep their law at every width, which +// is what these widths measure: the column's old full, slim and wide tiers. func underWidth(cols int) int { return cols - ansi.StringWidth(railSeam) - 2 } +const ( + underCols = 30 + underSlimCols = 24 + underWideCols = 46 +) + // THE TELEMETRY ROW IS WHAT A RUNNING NODE COSTS, said under its own name: its // age, its weight, its price and its worker — richest first, and given up from // the right until the row fits the column it is in. @@ -3618,8 +3632,8 @@ func TestARunningRowSaysItsAgeWeightPriceAndModel(t *testing.T) { width int want string }{ - {underWidth(railCols), "42s · 9.9k · $0.31 · gpt-5"}, - {underWidth(railSlimCols), "42s · 9.9k · $0.31"}, + {underWidth(underCols), "42s · 9.9k · $0.31 · gpt-5"}, + {underWidth(underSlimCols), "42s · 9.9k · $0.31"}, {17, "42s · 9.9k"}, {9, "42s"}, } { @@ -3632,7 +3646,7 @@ func TestARunningRowSaysItsAgeWeightPriceAndModel(t *testing.T) { // the under-block: what the node is doing this second, then what it has spent // getting there. node.tool, node.toolBegan = "bash go test ./...", a.now().Add(-24*time.Second) - rows := a.railUnder(node, underWidth(railCols)) + rows := a.railUnder(node, underWidth(underCols)) if len(rows) != railUnderRows { t.Fatalf("a working node drew %d under-rows, want %d:\n%q", len(rows), railUnderRows, rows) } @@ -3648,14 +3662,14 @@ func TestARunningRowSaysItsAgeWeightPriceAndModel(t *testing.T) { // leaves the two figures off the row rather than claiming the node has burned // nothing and cost nothing. node.tokens, node.cost = 0, 0 - if got := plain(strings.Join(a.railUnder(node, underWidth(railCols)), "\n")); got != "42s · gpt-5" { + if got := plain(strings.Join(a.railUnder(node, underWidth(underCols)), "\n")); got != "42s · gpt-5" { t.Fatalf("an unmeasured node draws %q, want no figures at all", got) } if strings.Contains(rosterText(a, 12), "$0.00") { t.Fatalf("the roster priced a node nobody has priced:\n%s", rosterText(a, 12)) } node.model = "" - if got := plain(strings.Join(a.railUnder(node, underWidth(railCols)), "\n")); got != "42s" { + if got := plain(strings.Join(a.railUnder(node, underWidth(underCols)), "\n")); got != "42s" { t.Fatalf("a node nobody has said anything about draws %q, want its age alone", got) } } @@ -3682,7 +3696,7 @@ func TestTheRosterPricesAMergeAndLeavesTheActionableRowsAlone(t *testing.T) { Merge: mergeWordMerged, CostUSD: 0.42, })}, ) - width := underWidth(railCols) + width := underWidth(underCols) // THE MERGE WORD ALWAYS SURVIVES, and the price rides behind it only where // there is room for both. @@ -3740,7 +3754,7 @@ func TestTheRailIsChargedAgainstTheConversationOnly(t *testing.T) { } want := tc.width if tc.rail { - want -= railColsFor(tc.width) + want -= sideColsFor(tc.width) } if got := a.bodyWidth(); got != want { t.Fatalf("at %d columns the conversation is %d wide, want %d", tc.width, got, want) @@ -3754,29 +3768,16 @@ func TestTheRailIsChargedAgainstTheConversationOnly(t *testing.T) { t.Fatalf("at %d columns frame row %d is %d wide:\n%q", tc.width, i, w, line) } } - // The roster opens on the node itself — there are no headings any more, and - // a session of one node is one family of one (task.go). - // The column opens with its section label now (margin.go), so the node is - // the row under it. - // - // EACH WIDTH IS ASSERTED IN ITS OWN SPELLING rather than in the prefix they - // share. The name reaches this column WHOLE now (taskident.go's - // [taskTitleOf] stopped cutting to three words on 2026-09-03, so the ROW - // decides what it can afford), and twenty-one cells do not fit a slim - // rail's title slot — so the full column draws the name and the slim one - // draws as much of it as [railTitleFloor] leaves once the id is measured - // out. Both are the roster naming the node, which is what this row of the - // test is here to say. + // The column opens with its header, then the group the node is in, then + // the node, one line, with its whole name at every width that lends a + // column (sidecol.go). name := "Fix the nil-map crash" - if railColsFor(tc.width) < railCols { - name = "Fix the nil-ma" - } top := a.bodyTop() - if tc.rail && !strings.Contains(lines[top], railStowHint) { - t.Fatalf("at %d columns the column does not open with its hide control:\n%q", tc.width, lines[top]) + if tc.rail && !strings.Contains(lines[top], sideTasksWord+" 1") { + t.Fatalf("at %d columns the column does not open with its header:\n%q", tc.width, lines[top]) } - if tc.rail && !strings.Contains(lines[top+2], name) { - t.Fatalf("at %d columns the roster's first row is not the node:\n%q", tc.width, lines[top+2]) + if tc.rail && (!strings.Contains(lines[top+1], railHeadWords[railRunning]) || !strings.Contains(lines[top+2], name)) { + t.Fatalf("at %d columns the roster's first rows are not the group and the node:\n%q\n%q", tc.width, lines[top+1], lines[top+2]) } // AND THE STRIP IS THE ROW ABOVE IT ONLY WHERE THERE IS NO ROSTER: the two // answer the same question, and the wide frame answers it in the column. @@ -3819,10 +3820,9 @@ func rosterText(a *app, height int) string { // frame lent it, every row stays inside the column, and the window follows the // focus down rather than stopping at whatever fitted first. -func TestTheRosterKeepsCreationOrderAndCountsTheWhole(t *testing.T) { +func TestTheRosterGroupsItsWorkByStateOneLineEach(t *testing.T) { a, _, _ := taskApp(t) - // Use the wide tier so this aggregate test can see every count. - a.width, a.railWide = 160, true + a.width = 160 drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskDone, session.TaskNotice{ Merge: mergeWordMerged, @@ -3835,70 +3835,69 @@ func TestTheRosterKeepsCreationOrderAndCountsTheWhole(t *testing.T) { Report: "the merge conflicted", Merge: mergeWordConflicted, Branch: "task/render", })}, streamEventMsg{gen: a.gen, ev: update(5, "Cut the trailer", session.TaskQueued, session.TaskNotice{})}, - // A failure without a retained branch is counted as finished work. + // Seen running first, as live work is: a node whose first news is a + // failure is one a reopened conversation replayed, and that is history. + streamEventMsg{gen: a.gen, ev: update(6, "Trim silence", session.TaskRunning, session.TaskNotice{})}, streamEventMsg{gen: a.gen, ev: update(6, "Trim silence", session.TaskFailed, session.TaskNotice{ Report: "the tests did not build", })}, ) a.cost, a.tokens = 1.42, 312_000 - rail := rosterText(a, 24) - - // Creation order stays stable across every task state. - at := -1 - for _, want := range []string{"Collect sources", "Fix the nil-map", "Mix audio", "Render titles", - "Cut the trailer", "Trim silence"} { - found := strings.Index(rail, want) - if found < 0 { - t.Fatalf("the roster has no %q row:\n%s", want, rail) - } - if found < at { - t.Fatalf("%q is out of order:\n%s", want, rail) - } - at = found - } - // NO HEADINGS AT ALL. The five words live in the footer now, where they are - // counts of the whole session rather than sections of the column. - for g := railGroup(0); g < railGroupCount; g++ { - if strings.Contains(rail, glyphOpen+" "+railGroupWords[g]) || - strings.Contains(rail, glyphShut+" "+railGroupWords[g]) { - t.Fatalf("the roster still draws the %q heading:\n%s", railGroupWords[g], rail) + rows := railText(a, 24) + // THE GROUPS STAND IN ONE ORDER, each heading its count: running work open, + // everything else one folded row. What needs the person is the band's, above + // them, and is not under any of them. + want := []string{ + sideTasksWord + " 6", + a.taskStateMark(a.tasks[4]) + " Render titles", + a.taskStateMark(a.tasks[6]) + " Trim silence", + strings.Repeat(a.linearMark("─", "-"), 8), + railHeadWords[railRunning] + " 1", + "Fix the nil-map crash", + railHeadWords[railIdle] + " 1 " + glyphShut, + railHeadWords[railParked] + " 1 " + glyphShut, + railHeadWords[railDone] + " 1 " + glyphShut, + } + for i, w := range want { + if i >= len(rows) || !strings.Contains(rows[i], w) { + t.Fatalf("row %d is not %q:\n%s", i, w, strings.Join(rows, "\n")) } } - // ONE GLYPH OPENS A ROW WITH NO FAMILY AROUND IT, and it is the state — the - // same lead a family row has, so the column reads downward as one column of - // states (task.go's [app.railLead]). - if !strings.Contains(rail, glyphBad+" Render titles") { - t.Fatalf("the flat row does not lead with its state:\n%s", rail) + rail := strings.Join(rows, "\n") + // THE RUNNING WORK'S HEADING WEARS NO MARK: it does not fold, and a mark is + // a promise that a press does something. + if strings.Contains(rows[4], glyphShut) || strings.Contains(rows[4], glyphOpen) { + t.Fatalf("the running heading wears a fold mark: %q", rows[4]) } - if strings.Contains(rail, plain(a.taskMark(identFor(4)))+" Render titles") { - t.Fatalf("the identity ◆ is back on the rail, two cells from the name:\n%s", rail) + // ONE GLYPH OPENS A TASK ROW, and it is the state; no identity ◆, no id. + if lead := railSeam + " " + plain(a.railTreeGlyph(a.tasks[2])) + " Fix the nil-map"; !strings.HasPrefix(rows[5], lead) { + t.Fatalf("the task row does not lead with its state: %q, want %q", rows[5], lead) } - // THE ID IS META: the title leads the row and the handle trails it, dim. - if !strings.Contains(rail, "#2") || strings.Contains(rail, "#2 Fix") { - t.Fatalf("the node's id is not the trailing meta of its row:\n%s", rail) + if strings.Contains(rail, "#2") || strings.Contains(rail, plain(a.taskMark(identFor(2)))+" Fix") { + t.Fatalf("the row carries an id or the identity mark:\n%s", rail) } - // AND THE FOOTER SAYS THE WHOLE, in the group vocabulary. - for _, want := range []string{"1 running", "1 needs you", - "1 queued", "1 waiting", "2 done"} { - if !strings.Contains(rail, want) { - t.Fatalf("the footer does not say %q:\n%s", want, rail) - } - } - // AND IT COUNTS RATHER THAN SUMS. The `Σ` led the foot's first line while - // that line was the session's bill; the bill left for the status row and the - // sign went with it — a mathematician's mark in front of a row of counts is - // furniture claiming to be structure (task.go's [app.railFootRows]). - // AND IT COUNTS WHAT THE COLUMN HOLDS AND NOTHING ELSE. The bill and the - // token total were on this foot until 2026-09-09, and both are the SESSION's - // — the same two figures the status row two lines down already draws. One - // number drawn twice on one frame is one of them wrong the moment they - // disagree, and the second copy cost this column two of its three lines - // (task.go's [app.railFootRows]). + // AND THE COLUMN REPEATS NOTHING THE STATUS ROW SAYS. for _, gone := range []string{"$1.42", "312k tok", "Σ"} { if strings.Contains(rail, gone) { - t.Fatalf("the footer repeats the status row's %q:\n%s", gone, rail) + t.Fatalf("the column repeats the status row's %q:\n%s", gone, rail) } } + // A FOLDED GROUP OPENS ON A PRESS AND STAYS OPEN FOR THE SESSION. + for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { + if e, ok := a.railEntryAt(y); ok && e.head && e.group == railIdle { + drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) + break + } + } + if rail := rosterText(a, 24); !strings.Contains(rail, railHeadWords[railIdle]+" 1 "+glyphOpen) || !strings.Contains(rail, "Cut the trailer") { + t.Fatalf("a press on the folded heading did not open it:\n%s", rail) + } + a.dropTasks() + a.taskUpdate(update(9, "Later work", session.TaskQueued, session.TaskNotice{})) + if rail := rosterText(a, 24); !strings.Contains(rail, "Later work") { + t.Fatalf("the group did not stay open for the session:\n%s", rail) + } } func TestTheRosterTakesTheKeyboardOnlyWhenItIsHandedIt(t *testing.T) { @@ -3925,13 +3924,13 @@ func TestTheRosterTakesTheKeyboardOnlyWhenItIsHandedIt(t *testing.T) { if !strings.Contains(rosterText(a, 16), railMark) { t.Fatalf("the focused row has no marker:\n%s", rosterText(a, 16)) } - // The cursor opens on the oldest task; the session began with node 7. - if a.railWhere.id != 7 { - t.Fatalf("the cursor opened on %+v, want the first running node", a.railWhere) + // The cursor opens on the newest running task, under its heading. + if a.railWhere.id != 2 { + t.Fatalf("the cursor opened on %+v, want the newest running node", a.railWhere) } drive(t, a, key("down")) - if a.railWhere.id != 1 { - t.Fatalf("↓ walked to %+v, want the next task created", a.railWhere) + if a.railWhere.id != 7 { + t.Fatalf("↓ walked to %+v, want the next running task", a.railWhere) } // Typing still reaches the box while the roster holds the arrows: only the @@ -3950,13 +3949,13 @@ func TestTheRosterTakesTheKeyboardOnlyWhenItIsHandedIt(t *testing.T) { // The pointer's half: a press on a row is that node's door, and it does not // take the keyboard on its way past. for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - if node := a.railNodeAt(y); node != nil && node.id == 1 { + if node := a.railNodeAt(y); node != nil && node.id == 2 { drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) break } } - if !a.roomOpen() || a.room.id != 1 { + if !a.roomOpen() || a.room.id != 2 { t.Fatalf("a press on a roster row did not open its room: open=%v", a.roomOpen()) } if a.railHold { @@ -3970,23 +3969,26 @@ func TestTheRostersCursorFollowsANodeThatChangesUrgency(t *testing.T) { streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskRunning, session.TaskNotice{})}, streamEventMsg{gen: a.gen, ev: update(2, "Fix the nil-map crash", session.TaskRunning, session.TaskNotice{})}, altT(), - key("down"), // the newest running node + key("down"), // the older running node ) - if a.railWhere.id != 2 { + if a.railWhere.id != 1 { t.Fatalf("the cursor is on %+v, want the second running node", a.railWhere) } - // It finishes with its branch conflicted, which is the one outcome that needs a - // person — while both its row and the cursor keep their place. - drive(t, a, streamEventMsg{gen: a.gen, ev: update(2, "Fix the nil-map crash", session.TaskFailed, - session.TaskNotice{Merge: mergeWordConflicted, Branch: "task/fix-nil-map"})}) + // It lands in the done group, which is folded: the cursor follows it to the + // heading standing for it rather than jumping to the top of the column. + drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskDone, + session.TaskNotice{Merge: mergeWordMerged})}) entries := a.railEntries() at := a.railFocusIndex(entries) - if at < 0 || entries[at].node == nil || entries[at].node.id != 2 { - t.Fatalf("the cursor did not follow the node: %+v", entries) + if at < 0 || !entries[at].head || entries[at].group != railDone { + t.Fatalf("the cursor did not follow the node to its group: %d in %+v", at, entries) } - // Neither the row nor the cursor moves when the task needs input. - if at != 1 { - t.Fatalf("the node with a conflicted branch moved to row %d, want its original row", at) + // And opened, the cursor is on the node itself. + a.sideToggleGroup(railDone) + entries = a.railEntries() + at = a.railFocusIndex(entries) + if at < 0 || entries[at].node == nil || entries[at].node.id != 1 { + t.Fatalf("the cursor is not on the landed node: %d in %+v", at, entries) } } @@ -4000,15 +4002,14 @@ func TestTheRosterWindowsHundredsOfNodesAroundItsFocus(t *testing.T) { t.Fatalf("the roster drew %d rows into a 12-row column", len(rows)) } for i, line := range rows { - if w := ansi.StringWidth(plain(line)); w > railCols { - t.Fatalf("roster row %d is %d cells wide, want at most %d:\n%q", i, w, railCols, line) + if w := ansi.StringWidth(plain(line)); w > a.railWidth() { + t.Fatalf("roster row %d is %d cells wide, want at most %d:\n%q", i, w, a.railWidth(), line) } } - // Three hundred families of one, all equally urgent, so the column is in the - // order the session admitted them — under the section label the column opens - // with (margin.go). - if !strings.Contains(plain(rows[2]), "node 1") { - t.Fatalf("the first row is not the first node the session met:\n%q", rows[2]) + // Three hundred running nodes, newest first under their heading, which is + // under the column's header. + if !strings.Contains(plain(rows[1]), railHeadWords[railRunning]+" 300") || !strings.Contains(plain(rows[2]), "node 300") { + t.Fatalf("the first rows are not the heading and the newest node:\n%q\n%q", rows[1], rows[2]) } // Twenty rows down is past the window, so the window moves. @@ -4017,19 +4018,16 @@ func TestTheRosterWindowsHundredsOfNodesAroundItsFocus(t *testing.T) { drive(t, a, key("down")) } rail := rosterText(a, 12) - if !strings.Contains(rail, "node 21") || !strings.Contains(rail, railMark) { + if !strings.Contains(rail, "node 280") || !strings.Contains(rail, railMark) { t.Fatalf("the window did not follow the cursor down:\n%s", rail) } - // The task sequence scrolls together while the hide control stays fixed. - if strings.Contains(rail, "node 1 ") { + // The task sequence scrolls together while the header stays fixed. + if strings.Contains(rail, "node 300") { t.Fatalf("the first task did not scroll with the list:\n%s", rail) } - if rows := railText(a, 12); !strings.Contains(rows[0], railStowHint) { - t.Fatalf("the hide control scrolled away: %v", rows) - } - // And the footer still counts the whole roster rather than the window. - if !strings.Contains(rail, "300 "+railGroupWords[railRunning]) { - t.Fatalf("the footer counts the window instead of the roster:\n%s", rail) + // And the header still counts the whole roster rather than the window. + if rows := railText(a, 12); !strings.Contains(rows[0], sideTasksWord+" 300") || !strings.Contains(rows[0], sideHideKey) { + t.Fatalf("the header scrolled away or counts the window: %v", rows) } } @@ -4037,6 +4035,11 @@ func TestTheRosterWindowsHundredsOfNodesAroundItsFocus(t *testing.T) { // remains actionable; retaining a branch alone is not a request to merge it. func TestAPlainFailureIsFiledAsNewsAndNotAsADemand(t *testing.T) { a, _, _ := taskApp(t) + // Every node is seen running first, as live work is: a failure that is a + // node's first news was replayed by a reopened conversation, and is history. + for _, id := range []uint64{1, 2, 3, 4, 5, 6} { + a.taskUpdate(update(id, "work "+itoa(int(id)), session.TaskRunning, session.TaskNotice{})) + } drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskDone, session.TaskNotice{ Merge: mergeWordMerged, @@ -4091,21 +4094,32 @@ func TestAPlainFailureIsFiledAsNewsAndNotAsADemand(t *testing.T) { } } - // The footer counts two decisions and four finished reports. + // THE TWO DECISIONS ARE THE BAND'S, IN AMBER, AND SO ARE THE THREE + // FAILURES NOBODY HAS OPENED, IN INK: five items, three rows and `+2 more`, + // and none of them is drawn again under Done, which holds the one clean + // merge (sidecol.go). + band := a.sideBand() + var asks, fails []string + for _, item := range band { + if item.ask { + asks = append(asks, item.key) + } else { + fails = append(fails, item.key) + } + } + if strings.Join(asks, " ") != "task/5 task/4" || strings.Join(fails, " ") != "fail/6 fail/3 fail/2" { + t.Fatalf("the band holds asks %v and failures %v", asks, fails) + } rail := rosterText(a, 24) - for _, want := range []string{"2 needs you", "4 done"} { + for _, want := range []string{"+2 more", railHeadWords[railDone] + " 1"} { if !strings.Contains(rail, want) { t.Fatalf("the roster is missing %q:\n%s", want, rail) } } - // Demands retain their state without displacing earlier tasks. - previous := -1 - for _, title := range []string{"Collect sources", "Render titles", "Mix audio", "Port the parser", "Cut the trailer", "Write the auth"} { - at := strings.Index(rail, title) - if at <= previous { - t.Fatalf("%q moved out of creation order:\n%s", title, rail) - } - previous = at + a.sideToggleGroup(railDone) + rail = rosterText(a, 24) + if !strings.Contains(rail, "Collect sources") || strings.Count(rail, "Render titles")+strings.Count(rail, "Port the parser") != 1 { + t.Fatalf("an item of the band is drawn twice, or the clean merge is missing:\n%s", rail) } } @@ -4310,7 +4324,9 @@ func clickRail(t *testing.T, a *app, node int) { // rows are the BODY REGION's rows, and the rows the frame pins above it — the // room's focus header, the task strip — move them down by their own height // (room.go, taskstrip.go, view.go's [app.topHeight]) — so the rail's first - // row is not always the frame's first row. + // row is not always the frame's first row. Every group is opened first, so + // the rows counted are every row the list has. + railOpenAll(a) head := a.bodyTop() seen, at := 0, -1 for y := head; y < head+a.viewHeight(); y++ { diff --git a/internal/tui3/c263_rail_plan_test.go b/internal/tui3/c263_rail_plan_test.go index 0a66dc8868..9d793528f5 100644 --- a/internal/tui3/c263_rail_plan_test.go +++ b/internal/tui3/c263_rail_plan_test.go @@ -25,9 +25,10 @@ func c263PlanRows() []session.PlanTaskRow { } } -// A RUN'S ROWS ARE THE OLD TASK ROWS. Every part is its own row in the old -// tree's connectors — the finished ones included, never folded to a count — -// and the part in flight says its call the way a node row says one. +// A RUN'S ROWS ARE THE SIDE COLUMN'S TASK ROWS. Every part is its own line, +// the finished ones included, never folded to a count; what a part is doing is +// the hint line's, as it is for every task on the column (DESIGN.md, One side +// column), so no live line and no handle stand on the rows. func TestRailPlanDrawsEveryPartAsATaskRow(t *testing.T) { a, _ := planAppWith(t, c263PlanRows(), nil) a.width, a.height, a.railWide = 120, 30, true @@ -36,7 +37,7 @@ func TestRailPlanDrawsEveryPartAsATaskRow(t *testing.T) { } got := plain(strings.Join(a.railRows(a.viewHeight()), "\n")) for _, word := range []string{"rewrite the auth", "implement handler", "schema migration", - "integration tests", "old fixture", "old helper", "bash git grep", "#root", "#live"} { + "integration tests", "old fixture", "old helper"} { if !strings.Contains(got, word) { t.Fatalf("the rail lacks %q:\n%s", word, got) } @@ -88,14 +89,12 @@ func railShape(line string) string { } // EVERY TASK LOOKS THE SAME, AND THIS IS THE PROOF OF IT. One rail holds a run -// from the plan store — its own row and three parts — and a family of this -// window's own nodes built the same way: a running head, a finished child, a -// running child and a queued one, with the same clock, the same price and ids -// of the same width. The two blocks are drawn by one renderer, so with the -// words taken out they are the same bytes, line for line: the same spinner at -// the same size, the same `#id` slot, the same `time · cost` line, the same -// connectors. A run renderer of its own — a still half-circle, no handle, a -// `✓ N done` fold — fails this on its first line. +// from the plan store and a running node of this window's own with the same +// clock and a title of the same width. Both are drawn by one renderer, the +// side column's one line (DESIGN.md, One side column), so with the words taken +// out the run's row and the node's row are the same bytes: the same spinner, +// the same indent, the same time at the right. A run renderer of its own, a +// still half-circle or a `✓ N done` fold, fails this on its first line. func TestARunAndANodeFamilyDrawTheSameShapeOnTheRail(t *testing.T) { now := taskFixtureNow rows := []session.PlanTaskRow{ @@ -108,10 +107,6 @@ func TestARunAndANodeFamilyDrawTheSameShapeOnTheRail(t *testing.T) { a.width, a.height = 160, 30 running := session.TaskNotice{Elapsed: 4 * time.Minute, CostUSD: 0.02} a.taskUpdate(update(1, "Alpha work", session.TaskRunning, running)) - a.taskUpdate(update(2, "Kid one A", session.TaskDone, session.TaskNotice{})) - a.taskUpdate(update(3, "Kid two A", session.TaskRunning, running)) - a.taskUpdate(update(4, "Kid six A", session.TaskQueued, session.TaskNotice{})) - railKinship(a, 1, 2, 3, 4) a.paints = 0 readPlanRows(t, a) @@ -125,39 +120,23 @@ func TestARunAndANodeFamilyDrawTheSameShapeOnTheRail(t *testing.T) { t.Fatalf("the rail has no row for %q:\n%s", title, strings.Join(lines, "\n")) return -1 } - run, family := at("Bravo work"), at("Alpha work") - if run > family { - t.Fatalf("the run is drawn at %d and the family at %d; the run's rows stand ahead of the node rows:\n%s", - run, family, strings.Join(lines, "\n")) + run, node := at("Bravo work"), at("Alpha work") + if got, want := railShape(lines[run]), railShape(lines[node]); got != want { + t.Fatalf("the run's row is shaped\n%q\nand the node's row\n%q\n\n%s", got, want, strings.Join(lines, "\n")) } - runBlock, familyBlock := lines[run:family], lines[family:family+(family-run)] - for i := range runBlock { - if got, want := railShape(runBlock[i]), railShape(familyBlock[i]); got != want { - t.Fatalf("line %d of the run is shaped\n%q\nand the same line of the node family is\n%q\n\nrun:\n%s\n\nfamily:\n%s", - i, got, want, strings.Join(runBlock, "\n"), strings.Join(familyBlock, "\n")) - } - } - // AND THE SHAPE IS THE OLD ONE: the braille spinner on the rows that are - // working, a handle at the end of every row, the clock and the price under - // the running head, and every part its own row. spinner := tokens.Spinner(0) - if !strings.HasPrefix(strings.TrimPrefix(runBlock[0], railSeam), spinner+" Bravo work") { - t.Fatalf("the run's row does not lead with the working spinner %q:\n%s", spinner, runBlock[0]) - } - if !strings.HasSuffix(strings.TrimRight(runBlock[0], " "), "#9") { - t.Fatalf("the run's row does not end in its handle:\n%s", runBlock[0]) + if !strings.Contains(lines[run], spinner+" Bravo work") { + t.Fatalf("the run's row does not wear the working spinner %q:\n%s", spinner, lines[run]) } - if !strings.Contains(runBlock[1], "4m · $0.02") { - t.Fatalf("the run's under-row is not the clock and the price:\n%s", strings.Join(runBlock, "\n")) - } - if strings.Contains(strings.Join(runBlock, "\n"), "done") && !strings.Contains(strings.Join(runBlock, "\n"), "Kid one B") { - t.Fatalf("the run's finished part was folded into a count:\n%s", strings.Join(runBlock, "\n")) + for _, part := range []string{"Kid one B", "Kid two B", "Kid six B"} { + if at(part) <= run { + t.Fatalf("the part %q is not its own row under the run:\n%s", part, strings.Join(lines, "\n")) + } } } // A NODE ROW THAT CARRIES A RUN IS THE RUN'S ROW, and the run's parts hang under -// it in the tree's own connectors. The row keeps its node — its handle, its -// telemetry and its door — and is drawn as the head of a family. +// it a level in. The row keeps its node, and its door, and is drawn once. func TestARunsPartsHangUnderTheNodeRowThatCarriesIt(t *testing.T) { root := session.PlanTaskRow{ID: "t-6", Title: "Sweep the issues", Status: "claimed"} kid := session.PlanTaskRow{ID: "t-k3x9qa", Parent: "t-6", Title: "Check the fix", Status: "claimed", @@ -185,11 +164,8 @@ func TestARunsPartsHangUnderTheNodeRowThatCarriesIt(t *testing.T) { if head < 0 || part <= head { t.Fatalf("the part is at %d and its run at %d, want it under the run:\n%s", part, head, text) } - if !strings.HasSuffix(strings.TrimRight(lines[head], " "), "#6") || !strings.HasSuffix(strings.TrimRight(lines[part], " "), "#k3x9qa") { - t.Fatalf("the run and its part do not wear their handles:\n%s", text) - } - if !strings.Contains(lines[part], treeLast) { - t.Fatalf("the part does not hang from the tree's connector:\n%s", text) + if strings.Index(lines[part], "Check the fix") <= strings.Index(lines[head], "Sweep the issues") { + t.Fatalf("the part is not a level in under its run:\n%s", text) } } diff --git a/internal/tui3/c266_rail_row_test.go b/internal/tui3/c266_rail_row_test.go index 2b117ef737..6e64742e74 100644 --- a/internal/tui3/c266_rail_row_test.go +++ b/internal/tui3/c266_rail_row_test.go @@ -86,7 +86,8 @@ func TestANarrowRailsHeldRowKeepsItsTitle(t *testing.T) { func TestTheRailIndentsATaskUnderItsParentTask(t *testing.T) { rows := c266PlanRows() rows = append(rows, session.PlanTaskRow{ID: "kid", Parent: "held", Title: "write the fixtures", Status: "pending"}) - _, rail := c266Rail(t, rows, 150, false) + // The widened column, where both titles are drawn whole beside the wait. + _, rail := c266Rail(t, rows, 160, true) _, parent := c266RowWith(t, rail, "write the tests") _, child := c266RowWith(t, rail, "write the fi") if strings.Index(child, "write") <= strings.Index(parent, "write") { @@ -94,24 +95,22 @@ func TestTheRailIndentsATaskUnderItsParentTask(t *testing.T) { } } -// A FAMILY'S LINE IS ONE UNBROKEN STROKE. The live line under a running task and -// the task under a task both stand between two siblings, and each used to leave -// a blank in the family's column, so the tree read as loose pieces. +// A TASK UNDER A TASK STANDS A LEVEL IN, AND THE LINE A RUNNING PART WOULD +// HAVE HAD UNDER IT IS THE HINT'S. The family's connectors are gone from the +// side column (DESIGN.md, One side column): every task is one line, and a part +// shows its depth by its indent alone. func TestTheFamilysLineRunsThroughTheLinesUnderARow(t *testing.T) { rows := c266PlanRows() rows = append(rows, session.PlanTaskRow{ID: "kid", Parent: "held", Title: "write the fixtures", Status: "pending"}) rows = append(rows, session.PlanTaskRow{ID: "after", Parent: "root", Title: "update the manual", Status: "pending"}) _, rail := c266Rail(t, rows, 150, false) at, handler := c266RowWith(t, rail, "write the handler") - column := strings.Index(handler, "├") - if column < 0 { - t.Fatalf("the running row has no connector:\n%s", handler) - } - if live := plain(rail[at+1]); !strings.HasPrefix(live[column:], "│") { - t.Fatalf("the live line breaks the family's stroke:\n%s\n%s", handler, live) + if at+1 < len(rail) && strings.Contains(plain(rail[at+1]), "$ git grep") { + t.Fatalf("a live line stands under a one-line task:\n%s\n%s", handler, plain(rail[at+1])) } + _, held := c266RowWith(t, rail, "write the tests") _, kid := c266RowWith(t, rail, "write the fi") - if !strings.HasPrefix(kid[column:], "│") { - t.Fatalf("the task under a task breaks its parent's family stroke:\n%s", kid) + if strings.Index(kid, "write the fi") <= strings.Index(held, "write the tests") { + t.Fatalf("the task under a task is not a level in:\n%s\n%s", held, kid) } } diff --git a/internal/tui3/c295_rail_task_page_test.go b/internal/tui3/c295_rail_task_page_test.go index 996a5d6067..07f5c9e49a 100644 --- a/internal/tui3/c295_rail_task_page_test.go +++ b/internal/tui3/c295_rail_task_page_test.go @@ -180,11 +180,13 @@ func TestARunIsItsOwnRowWithItsPartsUnderItAndEachOpensItsPage(t *testing.T) { for i, line := range view { text := plain(line.text) switch { - case strings.Contains(text, "land the parser"): + // The second part's row names the run it waits on, so the run's own + // row is the first that carries its title. + case strings.Contains(text, "land the parser") && rootAt < 0: rootAt = i case strings.Contains(text, "write the parser"): firstAt = i - case strings.Contains(text, "cover the parser"): + case strings.Contains(text, "cover the"): secondAt = i } } diff --git a/internal/tui3/caption.go b/internal/tui3/caption.go index 30c44a38ea..fb66a95e98 100644 --- a/internal/tui3/caption.go +++ b/internal/tui3/caption.go @@ -10,6 +10,7 @@ import ( "github.com/charmbracelet/x/ansi" "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" ) // caption is the title of one discrete step of a turn's work. @@ -271,6 +272,13 @@ func composeCaption(es []entry, from, to int) string { if dominant == "reading" || dominant == "editing" { noun = captionPlural(n, "file") } + // A manager's run of team calls, said as the team work it is. + if dominant == "sending" { + noun = captionPlural(n, "message") + } + if dominant == "managing" { + return "managing the team" + } if dominant == "running" { // Never "running N calls" — that is the count twice. return "running " + strconv.Itoa(n) + " " + captionPlural(n, "command") @@ -303,6 +311,9 @@ func toolCaptionGloss(e entry) string { case "gh", "github": return "asking github" } + if gloss := teamCaptionGloss(e); gloss != "" { + return gloss + } // Fall back to the session's own hint with the tool name stripped, so // "bash gh issue list…" becomes something about the work, not the verb. _, gloss := toolWords(e.tool, e.text) @@ -316,6 +327,61 @@ func toolCaptionGloss(e entry) string { return captionWords(gloss) } +// teamCaptionGloss is a team tool's step said as the work it is. A manager's +// turn is mostly these calls, and with no gloss its fold read `▾ team_send 1 +// call … 1 call`: the tool's own name where the work should be, and the count +// said twice. "" for any other tool. +func teamCaptionGloss(e entry) string { + args := argsOf(e.detail.Args) + at := func(key string) string { + var out []string + for _, h := range strings.Fields(argString(args, key)) { + h = strings.TrimPrefix(h, "@") + if h == teamstore.ToEveryone || h == teamstore.ToRoom || h == teamstore.ToManager { + out = append(out, h) + continue + } + out = append(out, "@"+h) + } + return strings.Join(out, " ") + } + switch e.tool { + case "team_send": + if to := at("to"); to != "" { + return "messaging " + to + } + return "messaging the team" + case "team_post": + if to := at("to"); to != "" { + return "posting to " + to + } + return "posting to the team" + case "team_start": + if h := at("handle"); h != "" { + return "starting " + h + } + case "team_stop": + if h := at("handle"); h != "" { + return "stopping " + h + } + case "team_read": + if h := at("handle"); h != "" { + return "reading " + h + } + case "team_status": + return "checking the team" + case "team_raise": + return "raising a decision" + case "team_decide": + return "deciding" + case "team_escalate": + return "passing a decision up" + case "team_close_report": + return "writing the closing report" + } + return "" +} + func bashCaption(command string) string { command = strings.TrimSpace(command) if command == "" { @@ -410,6 +476,10 @@ func captionVerb(tool string) string { return "looking up" case "ls": return "listing" + case "team_send", "team_post": + return "sending" + case "team_start", "team_stop", "team_read", "team_status", "team_raise", "team_decide", "team_escalate", "team_close_report": + return "managing" default: return firstNonEmpty(tool, "working") } @@ -427,14 +497,24 @@ var captionPastVerbs = map[string]string{ "asking": "asked", "building": "built", "checking": "checked", + "deciding": "decided", "editing": "edited", "fetching": "fetched", "listing": "listed", "looking": "looked", + "managing": "managed", + "messaging": "messaged", + "passing": "passed", + "posting": "posted", + "raising": "raised", "reading": "read", "running": "ran", "searching": "searched", + "sending": "sent", + "starting": "started", + "stopping": "stopped", "working": "worked", + "writing": "wrote", } // captionPast is the one door onto that table: a floor caption composed in the diff --git a/internal/tui3/chatstart_navigation_test.go b/internal/tui3/chatstart_navigation_test.go index 457fcd9d41..b489d8f308 100644 --- a/internal/tui3/chatstart_navigation_test.go +++ b/internal/tui3/chatstart_navigation_test.go @@ -22,7 +22,7 @@ func TestNewChatTabOwnsTheSelectionAndCloseReturnsTheDraft(t *testing.T) { if plus.span.to == 0 { t.Fatal("no plus control") } - cmd, took := a.tabPress(plus.span.from, placeTabRow) + cmd, took := a.tabPress(plus.span.from, tabStripRow) if !took { t.Fatal("plus did not take click") } @@ -45,7 +45,7 @@ func TestNewChatTabOwnsTheSelectionAndCloseReturnsTheDraft(t *testing.T) { if active != 1 || close.span.to == 0 { t.Fatalf("active=%d close=%+v", active, close) } - cmd, _ = a.tabPress(close.span.from, placeTabRow) + cmd, _ = a.tabPress(close.span.from, tabStripRow) drain(t, a, cmd) if a.startingChat() || a.input.String() != "old draft" { t.Fatalf("close lost old context: %q", a.input.String()) diff --git a/internal/tui3/chattabclose_test.go b/internal/tui3/chattabclose_test.go index 87c1680660..9cd4d78603 100644 --- a/internal/tui3/chattabclose_test.go +++ b/internal/tui3/chattabclose_test.go @@ -180,7 +180,7 @@ func TestTheCloseTargetNeverFallsThroughIntoSelectingTheTab(t *testing.T) { t.Fatalf("the close target overlaps the label: label=%+v close=%+v", label, span) } for x := span.from; x < span.to; x++ { - hit, ok := a.tabAt(x, placeTabRow) + hit, ok := a.tabAt(x, tabStripRow) if !ok || hit.kind != tabClose { t.Fatalf("column %d of the close target answers as %+v", x, hit) } @@ -199,10 +199,10 @@ func TestTheSeparatorsAreInertAndTheRowIsStillTheStrips(t *testing.T) { before := a.file label := tabSpanFor(t, a, "openrouter price scrape") sep := label.from - 1 // the rule in front of the first tab - if _, ok := a.tabAt(sep, placeTabRow); ok { + if _, ok := a.tabAt(sep, tabStripRow); ok { t.Fatalf("column %d is a separator and answers as a target", sep) } - if _, took := a.tabPress(sep, placeTabRow); !took { + if _, took := a.tabPress(sep, tabStripRow); !took { t.Fatal("a press on the strip's own furniture fell through the row") } if a.file != before || a.hop.open { @@ -405,16 +405,16 @@ func headerBudgeted(t *testing.T, a *app, where string) { t.Fatalf("%s at %dx%d the header draws %d rows and is charged %d", where, size.w, size.h, drawn, a.headHeight()) } - if a.room == nil && drawn != 0 && drawn != placeHeadRows { - t.Fatalf("%s at %dx%d the head is %d rows, not the places' %d", - where, size.w, size.h, drawn, placeHeadRows) + if a.room == nil && drawn != 0 && drawn != chatHeadRows { + t.Fatalf("%s at %dx%d the head is %d rows, not the chat's %d", + where, size.w, size.h, drawn, chatHeadRows) } // AND THE ROWS CHARGED ARE THE ROWS DRAWN: the pulse on top, the rule // where the geometry says the seam is. - if a.room == nil && drawn == placeHeadRows && - (!strings.HasPrefix(plain(rows[0]), " "+plain(a.pal.wordmark(a.width))) || strings.Trim(plain(rows[placeTabRow+1]), "─") != "") { + if a.room == nil && drawn == chatHeadRows && + (!strings.HasPrefix(plain(rows[0]), " "+plain(a.pal.wordmark(a.width))) || strings.Trim(plain(rows[tabStripRow+1]), "─") != "") { t.Fatalf("%s at %dx%d the head is charged as the places' and drawn as something else:\n%q\n%q", - where, size.w, size.h, plain(rows[0]), plain(rows[placeTabRow+1])) + where, size.w, size.h, plain(rows[0]), plain(rows[tabStripRow+1])) } // A frame with no body region left answers -1 and has nothing to check // (view.go's [app.bodyTop]); everywhere else the body starts exactly under @@ -448,7 +448,7 @@ func TestEachHeaderRowAnswersForItselfAndForNoOther(t *testing.T) { if _, ok := a.tabAt(headLabelAt+1, a.roomHeadRow()); ok { t.Fatalf("at %d columns the tab row answers on the trail's row", width) } - if _, ok := a.crumbAt(headLabelAt+1, placeTabRow); ok { + if _, ok := a.crumbAt(headLabelAt+1, tabStripRow); ok { t.Fatalf("at %d columns the trail answers on the tab row", width) } if _, ok := a.crumbAt(headLabelAt+1, a.roomFactsRow()); ok { diff --git a/internal/tui3/chattabs.go b/internal/tui3/chattabs.go index bdff65158b..0f480bc63f 100644 --- a/internal/tui3/chattabs.go +++ b/internal/tui3/chattabs.go @@ -82,13 +82,19 @@ const ( tabSep = "│" tabSepASCII = "|" // tabCloseMark is the dismissal on a tab, and tabCloseCells is the room kept - // for it whether or not it is drawn. The CELLS ARE RESERVED ON EVERY TAB - // because the mark appears under the pointer: a row that grew two cells when - // a hand crossed it would re-pack every label beside it, and the tab somebody - // was reaching for would move out from under them. + // for it whether or not it is drawn: the mark and the tab's closing inset. + // The CELLS ARE RESERVED ON EVERY TAB because the mark appears under the + // pointer: a row that grew two cells when a hand crossed it would re-pack + // every label beside it, and the tab somebody was reaching for would move + // out from under them. + // + // THE AIR BEFORE THE MARK IS THE LABEL'S OWN PAD, so a tab is symmetric: the + // inset, the status slot and the pad lead the name, and the pad, the mark + // and the inset close it (` ◐ name × `). It used to carry a blank of its own + // as well, which left every tab one cell wider on the right than the left. tabCloseMark = "×" tabCloseASCII = "x" - tabCloseCells = 3 + tabCloseCells = 2 // The filled tab includes an inset before its status mark and after its close. tabInsetCells = 1 // tabWordCap is the widest a tab's label is drawn on a frame with room to @@ -154,6 +160,12 @@ type chatTab struct { start bool signal tabSignal work bool + // slot is the manager's place in a team that has none: `+ Manager`, a + // word button with no conversation behind it (teammanager.go). + slot bool + // pinned says this tab is the manager's place, held at the left of the run + // like a browser's pinned tab: it never scrolls away (teammanager.go). + pinned bool } // tabKind is what one drawn piece of the strip IS, which is what decides whether @@ -180,9 +192,21 @@ const ( // second door onto a card the legend already names a key for. tabFold tabNew - tabHome tabScrollLeft tabScrollRight + // tabTeam is the chip at the row's left end naming the team the strip is + // narrowed to; a press opens the team switcher (teammenu.go). It is kept + // out of the tabs' list, in [wallState.chip], because the run of tabs and + // its count are one thing and the chip is not one of them. + tabTeam + // tabWall is the strip's door to the conversations view, ` ▦ All ` after + // the new-chat `+` (wall.go). It is kept out of the tabs' list for the + // chip's reason, in [wallState.door]. + tabWall + // tabManager is `+ Manager`, the first place of a team shown that has no + // manager; a press starts one (teammanager.go). It has no close cells, + // because there is nothing behind it to close. + tabManager ) // tabHit is where one piece was drawn and what pressing it does. It is the @@ -202,7 +226,7 @@ func (h tabHit) door(a *app) bool { switch h.kind { case tabHere: return a.roomOpen() || a.startingChat() - case tabOther, tabClose, tabNew, tabHome, tabScrollLeft, tabScrollRight: + case tabOther, tabClose, tabNew, tabScrollLeft, tabScrollRight, tabTeam, tabWall, tabManager: return true } return false @@ -237,11 +261,21 @@ func (h tabHit) lights() bool { return h.kind != tabFold } type tabBar struct { width int ink uint64 + // team is the chip's words, "" with no team shown, and chip where it + // was drawn. + team string + chip hudSpan + // wallOn and door are the conversations view's state and where its door + // was drawn, so a reused row still lights the door right and still + // answers for it; menuOn is whether the chip's switcher is open, which + // lights the chip. + wallOn bool + menuOn bool + door hudSpan // hot is the column of the piece the pointer was on, or -1. hot int more bool newChat bool - home bool tabs []chatTab line string hits []tabHit @@ -453,8 +487,9 @@ func tabsCapped(tabs []chatTab, prev []string) []chatTab { // those numbers. // tabsHeight is what the head costs the body region DOWN TO AND INCLUDING THE -// STRIP: the pulse, and the strip under it on the bar's own row -// ([placeTabRow]). +// STRIP when a conversation is in front: the pulse, and the strip under it +// ([tabStripRow]). On a place the strip is not drawn, so this is the nav's +// one row and the page owns the row under it (head.go's [app.stripInHead]). // // IT STANDS DOWN ON THE TWO FLOORS THE CONVERSATION'S BAR STOOD DOWN ON. A frame // too narrow for a name and a way out is too narrow for this, and a terminal too @@ -473,11 +508,15 @@ func (a *app) tabsHeight(width int) int { if width < roomHeadFloor || a.breathingRows() < 2 { return 0 } - return placeTabRow + 1 + if !a.stripInHead() { + return navRow + 1 + } + return tabStripRow + 1 } -// headSealHeight is the rule and the blank under the strip — the rest of the -// head's [placeHeadRows] — in the conversation and in every room inside it. +// headSealHeight is the rule and the blank under the strip, or under the nav +// on a place. It is two rows wherever the head is drawn, so a chat's head is +// [chatHeadRows] and a place's is [placeHeadRows]. // // IT IS WHAT SEPARATES THE HEAD FROM THE TRANSCRIPT AND FROM THE ROSTER BESIDE // IT, and it is a drawn rule rather than a blank because a blank separates @@ -494,7 +533,7 @@ func (a *app) headSealHeight(width int) int { if a.tabsHeight(width) == 0 { return 0 } - return placeHeadRows - a.tabsHeight(width) + return chatHeadRows - (tabStripRow + 1) } // roomHeadRow is the frame row a room's TRAIL is drawn on — the breadcrumbs and @@ -522,6 +561,8 @@ func (a *app) roomFactsRow() int { // head's middle row, under the pulse, wherever it is drawn at all (head.go). func (a *app) tabsRow(width int) string { a.chatTabHits = nil + a.wall.chip = hudSpan{} + a.wall.door = hudSpan{} if a.tabsHeight(width) == 0 { return "" } @@ -530,6 +571,11 @@ func (a *app) tabsRow(width int) string { // this one can still see and a later one may not (a shared handle ends the // conversation it swaps away from, and its title goes with it). a.chatTabs = tabs + // A TEAM NARROWS WHAT THE ROW DRAWS AND NEVER WHAT IT REMEMBERS: the list + // above is stored whole, and only the copy drawn is cut to the team. + if _, ok := a.teamActive(); ok { + tabs = a.teamStripTabs(append([]chatTab(nil), tabs...)) + } if a.startingChat() { for i := range tabs { tabs[i].here = false @@ -543,37 +589,176 @@ func (a *app) tabsRow(width int) string { hot = a.hot.index } more := a.hopAvailable() - // Home shares the places bar's word, padding and left margin so crossing - // between the dashboard and a conversation never shifts its label or target. - homeChip := tabPad + pageHome.word() + tabPad - homeCols := ansi.StringWidth(homeChip) - home := a.homeDoorOpen() && width-tabLead >= homeCols+2+tabWordFloor+tabCloseCells+tabInsetCells - if memo := a.chatTabBar; memo.home == home && memo.newChat == a.canStart() && memo.same(width, a.inkState, hot, more, tabs) { + chipWord := a.tabTeamWord() + room := max(width-headLabelAt, 0) + // THE ORDER IS THE TEAM CHIP, THEN WHAT IT FILTERS: the chip narrows the + // tabs, so it sits right before them, with the manager's place after it. + // The chip's cells are reserved first, so a tab is never drawn under it; + // the chip goes when the row runs short, and never the tab in front. + // + // THERE IS NO `home` PIECE ON THIS ROW ANY MORE. It was the strip's way to + // home while the places were drawn only on a place; home is the nav's + // first word now, on the row over this one on every page (topnav.go). + // + // THE GAP IS ONE CELL BETWEEN ANY TWO PIECES, the chip included: every piece + // carries its own pad, so one blank between two grounds is the whole of the + // air, and it is the same between the chip and a tab, two tabs, a tab and + // `+`, and `+` and `▦ All`. The row's first ground is at [headLabelAt] + // whichever piece it is, so the strip does not step sideways when a team is + // shown or put away. + chipW, chipNeed := 0, 0 + if chipWord != "" { + chipNeed = 2*ansi.StringWidth(chipWord) + tabWordFloor + tabCloseCells + tabInsetCells + 8 + if room >= chipNeed { + chipW = ansi.StringWidth(chipWord) + } + } + if memo := a.chatTabBar; memo.newChat == a.canStart() && memo.team == chipWord && memo.wallOn == a.wall.on && memo.menuOn == a.teamMenu.on && memo.same(width, a.inkState, hot, more, tabs) { a.chatTabHits = memo.hits + a.wall.chip, a.wall.door = memo.chip, memo.door return memo.line } - room := max(width-tabLead, 0) - homeWidth := 0 - if home { - homeWidth = homeCols + 2 - } - pieces, hits := a.tabsFit(tabs, room-homeWidth) - if home { - hits = tabsAt(hits, homeWidth) - hits = append([]tabHit{{span: hudSpan{from: 0, to: homeCols}, kind: tabHome}}, hits...) - pieces = append([]tabPiece{{word: homeChip, kind: tabHome}, {word: " ", quiet: true}}, pieces...) + // The pieces lead with a gap cell of their own ([app.tabsFit]); with no chip + // in front of them that cell is taken out of the row's inset instead, so + // the first ground stands where the chip's would. + base := headLabelAt + chipW + if chipW == 0 { + base = headLabelAt - ansi.StringWidth(a.tabSepWord()) } - if len(pieces) == 0 { + room = max(width-base, 0) + pieces, hits := a.tabsFit(tabs, room, tabWallCellsAt(width)) + if len(pieces) == 0 && chipW == 0 { // An empty strip still occupies the header row charged to the layout. return strings.Repeat(" ", max(width, 0)) } - a.chatTabHits = tabsAt(hits, tabLead) - line := strings.Repeat(" ", tabLead) + a.tabsPaint(pieces) - a.chatTabBar = tabBar{width: width, ink: a.inkState, hot: hot, more: more, newChat: a.canStart(), home: home, line: line, hits: a.chatTabHits, - tabs: append([]chatTab(nil), tabs...)} + a.chatTabHits = tabsAt(hits, base) + // The door is laid out with the tabs, so it follows the new-chat `+` + // wherever that lands, and is then kept apart from them. + kept := a.chatTabHits[:0] + for _, hit := range a.chatTabHits { + if hit.kind == tabWall { + a.wall.door = hit.span + continue + } + kept = append(kept, hit) + } + a.chatTabHits = kept + line := strings.Repeat(" ", min(base, headLabelAt)) + if chipW > 0 { + line += a.tabTeamPaint(chipWord, headLabelAt) + } + line += a.tabsPaint(pieces) + // THE ROW FILLS THE FRAME, as the pulse over it does, so a door that went + // narrower leaves no cells behind it for the last frame's words. + line += strings.Repeat(" ", max(width-ansi.StringWidth(line), 0)) + a.chatTabBar = tabBar{width: width, ink: a.inkState, hot: hot, more: more, newChat: a.canStart(), line: line, hits: a.chatTabHits, + tabs: append([]chatTab(nil), tabs...), team: chipWord, chip: a.wall.chip, wallOn: a.wall.on, menuOn: a.teamMenu.on, door: a.wall.door} return line } +// The strip's door to the conversations view. It is ` ▦ All `, the glyph and +// the word, on a row at least tabWallFrom wide, and not drawn on a narrower +// one, where every cell is a tab's and the view is still alt+v and the dock's +// `▦ All`. Its cells depend on the width alone, never on the pointer, so +// nothing re-packs under the hand. +// +// THERE IS NO GLYPH-ALONE RUNG ANY MORE. Between sixty and eighty columns the +// door used to be a bare ` ▦ `, a lone mark a person had to press to learn +// about; four cells taken from the tabs is the price of it saying what it is, +// and the owner's bar is word buttons, never lone glyphs. tabWallWordFrom is +// kept equal to tabWallFrom so the two rungs cannot drift apart again. +const ( + tabWallFrom = 60 + tabWallWordFrom = tabWallFrom + tabWallWord = "All" +) + +// tabWallCellsAt is the cells the door takes on a row width wide, pads +// included: one blank either side, as the `+` has. +func tabWallCellsAt(width int) int { + switch { + case width >= tabWallWordFrom: + return 4 + len(tabWallWord) + case width >= tabWallFrom: + return 3 + } + return 0 +} + +// tabWallPaint draws the door: lit with the tab-in-front's own step while the +// view is up, on the strip's hover ground under the pointer, and otherwise the +// glyph in the shown team's colour (dim with none, as the dock's is) and the +// word muted. +func (a *app) tabWallPaint(word string, hot bool) string { + glyph := a.dockWallGlyph() + switch { + case hot: + if a.pal.profile < tokens.ANSI256 { + word = a.linearMark("·", ".") + strings.TrimPrefix(word, " ") + } + return a.tabHoverPaint(word) + case a.wall.on: + return a.tabActivePaint(word) + } + ink := a.pal.dim + if sp, ok := a.teamActive(); ok { + if pen := a.pal.teamInk(sp.HueSpec()); pen != nil && !a.linear { + ink = pen + } + } + rest := strings.TrimPrefix(word, " "+glyph) + return a.pal.dim(" ") + ink(glyph) + a.pal.muted(rest) +} + +// tabTeamWord is the team chip's words, ` ● harbor ▾ `, or with no team +// narrowing the strip a quiet ` teams ▾ ` while there are teams to switch to, +// and "" when there are none (teammenu.go says why). The dot is the team's +// colour where there is one, and its initial where there is not. +func (a *app) tabTeamWord() string { + caret := a.linearMark("▾", "v") + if a.pal.ascii { + caret = "v" + } + sp, ok := a.teamActive() + if !ok { + if len(a.wall.teams) == 0 { + return "" + } + return " teams " + caret + " " + } + name := sp.Name + if ansi.StringWidth(name) > teamNameCells { + name = ansi.Truncate(name, teamNameCells, "…") + } + return " " + a.tabTeamDot(sp) + " " + name + " " + caret + " " +} + +func (a *app) tabTeamDot(sp team) string { + if ink := a.pal.teamInk(sp.HueSpec()); ink != nil && !a.linear { + return ink("●") + } + if r := []rune(sp.Name); len(r) > 0 && ansi.StringWidth(string(r[0])) == 1 { + return a.pal.dim(strings.ToLower(string(r[0]))) + } + return a.pal.dim("?") +} + +// tabTeamPaint draws the chip at column at, on the cursor ground under the +// pointer and while its switcher is open, and records where it landed. A team +// shown sits on the selected ground; the quiet chip with none shown has no +// ground at all. +func (a *app) tabTeamPaint(word string, at int) string { + w := ansi.StringWidth(word) + a.wall.chip = hudSpan{from: at, to: at + w} + if (a.hot.kind == hoverTab && a.hot.index == at) || a.teamMenu.on { + return a.tabHoverPaint(word) + } + if _, ok := a.teamActive(); !ok { + return a.pal.muted(word) + } + return a.pal.selected(a.pal.muted(word), 0) +} + // tabPiece is one drawn segment of the strip: the word, and what it is. type tabPiece struct { word string @@ -592,13 +777,26 @@ func (a *app) tabCloseWord() string { return a.linearMark(tabCloseMark, tabClose // tabsFit keeps names readable and exposes overflow through a scrolling window. // Selection is revealed unless the person explicitly browsed away from it; the // hidden count and directional controls describe everything outside that window. -func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { +// +// door is the cells the conversations view's door asks for after the new-chat +// `+`, zero for none; it is given up whole when the tabs could not keep their +// floor beside it. +func (a *app) tabsFit(tabs []chatTab, room, door int) ([]tabPiece, []tabHit) { if room <= 0 { return nil, nil } + // THE MANAGER'S EMPTY PLACE LEAVES A NARROW STRIP. `+ Manager` is an offer, + // and under [teamManagerSlotFloor] it would take a slot a conversation + // needs; the team switcher still makes it (teammenu.go). + if len(tabs) > 0 && tabs[0].slot { + if width, _ := a.size(); width < teamManagerSlotFloor { + tabs = tabs[1:] + } + } + sepW := ansi.StringWidth(a.tabSepWord()) if len(tabs) == 0 { - if a.canStart() && room >= 3 { - return []tabPiece{{word: " + ", kind: tabNew}}, []tabHit{{span: hudSpan{from: 0, to: 3}, kind: tabNew}} + if a.canStart() && room >= sepW+3 { + return []tabPiece{{word: a.tabSepWord(), quiet: true}, {word: " + ", kind: tabNew}}, []tabHit{{span: hudSpan{from: sepW, to: sepW + 3}, kind: tabNew}} } return nil, nil } @@ -607,13 +805,23 @@ func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { if showNew { room -= 4 } + // THE DOOR STANDS ONE GAP AFTER THE `+` OR THE RIGHT ARROW, as every piece + // stands one gap after the one before it; the cell is held before the + // fitting knows whether the strip scrolls, and after a plain last tab its + // own gap is the door's. + doorGap := sepW + if door > 0 && room-door-doorGap < tabWordFloor+tabCloseCells+tabInsetCells+7 { + door = 0 + } + if door > 0 { + room -= door + doorGap + } active := 0 for at, tab := range tabs { if tab.here { active = at } } - sepW := ansi.StringWidth(a.tabSepWord()) // The count is reserved BEFORE the fitting, because a figure squeezed in // afterwards would be a figure drawn over the last tab's own cells. What it // asks for is the widest it could want — every tab but the one in front @@ -635,32 +843,56 @@ func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { cell := budget if len(tabs) > 1 { cell = min(tabWordCap, budget-2*sepW) + // THE NAMES SHRINK BEFORE THE STRIP SCROLLS, as a browser's tabs do: the + // widest share every tab can have and all of them still fit is taken, + // down to [tabReadableCells]. Only a row that cannot show every tab at + // that floor scrolls. A strip that scrolled at its widest names drew + // one tab, a hole the width of the tab it hid, and an arrow. + // + // A ROW THAT SPELLS EVERY TAB DRAWS NO COUNT, so the cells held for one + // are the names' too when every name fits in them. + fits := func(limit int) (int, bool) { + for c := min(tabWordCap, limit-2*sepW); c >= tabReadableCells; c-- { + used := 1 + for _, tab := range tabs { + _, w := a.tabCell(tab, c) + used += w + sepW + } + if used <= limit { + return c, true + } + } + return 0, false + } + if c, ok := fits(budget + reserve); ok && reserve > 0 { + cell, budget = c, budget+reserve + } else if c, ok := fits(budget); ok { + cell = c + } } words := make([]string, len(tabs)) widths := make([]int, len(tabs)) for at, tab := range tabs { - words[at] = a.tabName(tab, cell-tabCloseCells-tabInsetCells) - widths[at] = ansi.StringWidth(words[at]) + tabInsetCells + tabCloseCells + words[at], widths[at] = a.tabCell(tab, cell) } - from, to, scroll := a.tabWindow(tabs, widths, budget, active) - windowBudget := budget - if scroll { - windowBudget -= 2 * tabArrowCells + // THE MANAGER'S PLACE IS PINNED, as a browser pins a tab: it is drawn + // first, outside the window, and the window scrolls over the rest. + pin, pinW := 0, 0 + if len(tabs) > 1 && tabs[0].pinned { + pin, pinW = 1, widths[0]+sepW } - pieces := make([]tabPiece, 0, 3*(to-from)+3) - hits := make([]tabHit, 0, 2*(to-from)+1) - at := 0 + from, to, scroll := a.tabWindow(tabs[pin:], widths[pin:], budget-pinW, max(active-pin, 0)) + from, to = from+pin, to+pin + windowBudget := budget - pinW if scroll { - piece, hit := a.tabArrowPiece(false, from > 0, at) - pieces = append(pieces, piece) - if hit != nil { - hits = append(hits, *hit) - } - at += tabArrowCells + windowBudget -= tabArrowsCells(sepW) } - for i := from; i < to; i++ { + pieces := make([]tabPiece, 0, 3*(to-from+pin)+3) + hits := make([]tabHit, 0, 2*(to-from+pin)+1) + at := 0 + place := func(i int, lone bool) { word := words[i] - if to-from == 1 { + if lone && !tabs[i].slot { // The one tab that is left takes whatever the row has, cut. A name with // an ellipsis in it still says which conversation this is; a blank row // says nothing at all. @@ -668,12 +900,20 @@ func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { } width := ansi.StringWidth(word) + tabInsetCells if width == tabInsetCells { - continue + return } kind := tabOther if tabs[i].here { kind = tabHere } + if tabs[i].slot { + pieces = append(pieces, tabPiece{word: a.tabSepWord(), quiet: true}) + at += sepW + pieces = append(pieces, tabPiece{word: strings.Repeat(" ", tabInsetCells) + words[i], kind: tabManager, tab: tabs[i]}) + hits = append(hits, tabHit{span: hudSpan{from: at, to: at + width}, kind: tabManager, tab: tabs[i]}) + at += width + return + } pieces = append(pieces, tabPiece{word: a.tabSepWord(), quiet: true}) at += sepW pieces = append(pieces, tabPiece{word: word, kind: kind, tab: tabs[i]}) @@ -686,6 +926,24 @@ func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { hits = append(hits, tabHit{span: hudSpan{from: at, to: at + tabCloseCells}, kind: tabClose, tab: tabs[i]}) at += tabCloseCells } + if pin > 0 { + place(0, false) + } + if scroll { + // THE LEFT ARROW STANDS ONE GAP AFTER WHAT IS IN FRONT OF IT, as a tab + // does; the right one is pinned to the window's end. + pieces = append(pieces, tabPiece{word: a.tabSepWord(), quiet: true}) + at += sepW + piece, hit := a.tabArrowPiece(false, from > pin, at) + pieces = append(pieces, piece) + if hit != nil { + hits = append(hits, *hit) + } + at += tabArrowCells + } + for i := from; i < to; i++ { + place(i, to-from == 1) + } if len(pieces) > 0 { pieces = append(pieces, tabPiece{word: a.tabSepWord(), quiet: true}) at += sepW @@ -709,12 +967,27 @@ func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { hits = append(hits, tabHit{span: hudSpan{from: at, to: at + 3}, kind: tabNew}) at += 3 } + // The conversations view's door stands one gap after it, each wearing its + // own blank either side, as every piece of the row does. + if door > 0 { + if showNew || scroll { + pieces = append(pieces, tabPiece{word: a.tabSepWord(), quiet: true}) + at += sepW + } + word := " " + a.dockWallGlyph() + " " + if door > 3 { + word += tabWallWord + " " + } + pieces = append(pieces, tabPiece{word: word, kind: tabWall}) + hits = append(hits, tabHit{span: hudSpan{from: at, to: at + door}, kind: tabWall}) + at += door + } // AND THE COUNT OF WHAT DID NOT FIT, WHICH IS THE WHOLE OF THE ROW'S RIGHT // END NOW. It has no ladder to walk down any more: `+3` is three cells that // are all fact, so it is drawn whole or it is not drawn — which is the same // answer the old control's ladder arrived at one rung later, having first // spent its mark and its count to keep a word that no longer exists. - hidden := len(tabs) - (to - from) + hidden := len(tabs) - (to - from) - pin if word := a.tabsFoldWord(hidden); word != "" { if width := ansi.StringWidth(word); at+tabsMoreGap+width <= fullRoom { pieces = append(pieces, tabPiece{word: strings.Repeat(" ", tabsMoreGap), quiet: true}) @@ -726,6 +999,19 @@ func (a *app) tabsFit(tabs []chatTab, room int) ([]tabPiece, []tabHit) { return pieces, hits } +// tabCell is one tab's word and the cells it takes at a share of cell cells. +func (a *app) tabCell(tab chatTab, cell int) (string, int) { + if tab.slot { + // The manager's empty place is a word button: its word whole where + // it fits, one pad either side as every word button has, and no + // close cells, since nothing is behind it. + word := fitTabTitle(tab.word, max(cell-2*tabInsetCells, 1)) + strings.Repeat(" ", tabInsetCells) + return word, ansi.StringWidth(word) + tabInsetCells + } + word := a.tabName(tab, cell-tabCloseCells-tabInsetCells) + return word, ansi.StringWidth(word) + tabInsetCells + tabCloseCells +} + // tabsMoreGap is the least space between the last tab and the count, so the // figure never reads as the next tab along. const tabsMoreGap = 2 @@ -739,19 +1025,53 @@ func (a *app) tabsFoldWord(hidden int) string { return tabHiddenLead + itoa(hidden) } +// tabHoverPaint is a word button of the strip under the pointer: ink on the +// ground ladder's mark step, which is one step above the selected ground the +// idle tabs stand on. It is the ground a hovered tab takes ([app.tabsPaint]), +// so everything on the row that answers the hand answers it the same way; the +// cursor step it used to take is one BELOW the idle tabs, and read as a +// hovered thing sinking. Linear mode draws no pointer's ground, as +// [palette.cursor] says. +func (a *app) tabHoverPaint(word string) string { + if a.pal.linear { + return a.pal.ink(word) + } + return a.pal.background(a.pal.ink(word), 0, a.pal.ramp.mark) +} + // tabLabel gives each tab a padded target. Brackets identify the selected // conversation even with NO_COLOR, where both tint and underline are absent. func tabLabel(tab chatTab, width int) string { if width < 2 { - return fitConversationTitle(tab.word, width) + return fitTabTitle(tab.word, width) } - word := fitConversationTitle(tab.word, width-2) + word := fitTabTitle(tab.word, width-2) if tab.here { return "[" + word + "]" } return " " + word + " " } +// fitTabTitle is a conversation's name cut to width for a tab, AT A WORD +// BOUNDARY where one is near: `Refactor the rail...` rather than `Refactor the +// rail scop...`, because a tab is recognised by its words and half a word is +// a word nobody said. A name with no space late enough is cut where it +// lands, as [fitConversationTitle] cuts it; the suffix is that function's. +func fitTabTitle(s string, width int) string { + cut := fitConversationTitle(s, width) + if cut == s || width < 12 { + return cut + } + dots := strings.Repeat(".", 3) + head := strings.TrimSuffix(cut, dots) + // A SPACE IN THE LATER HALF of what survived is a word boundary worth + // cutting at; one earlier throws away more of the name than it saves. + if at := strings.LastIndex(head, " "); at > 0 && ansi.StringWidth(head[:at]) >= width/2 && s[len(head)] != ' ' { + return strings.TrimRight(head[:at], " ,;:-") + dots + } + return cut +} + // A reserved status slot keeps labels stable across work transitions. The start // page has no agent and makes no status claim. func (a *app) tabName(tab chatTab, width int) string { @@ -779,37 +1099,37 @@ func (a *app) tabsPaint(pieces []tabPiece) string { hot, lit := a.hotTab() line := "" for _, piece := range pieces { - on := lit && hot.tab.key == piece.tab.key && hot.tab.start == piece.tab.start && hot.kind != tabFold && hot.kind != tabNew && hot.kind != tabHome && hot.kind != tabScrollLeft && hot.kind != tabScrollRight + on := lit && hot.tab.key == piece.tab.key && hot.tab.start == piece.tab.start && hot.kind != tabFold && hot.kind != tabNew && hot.kind != tabScrollLeft && hot.kind != tabScrollRight && hot.kind != tabTeam && hot.kind != tabWall && hot.kind != tabManager switch { case piece.quiet: line += a.pal.dim(piece.word) + case piece.kind == tabWall: + line += a.tabWallPaint(piece.word, lit && hot.kind == tabWall) case piece.kind == tabClose: line += a.tabClosePaint(piece, hot, lit, on) case piece.kind == tabHere: - word := a.tabActivePaint(a.tabWordPaint(piece, a.pal.ink)) + word := a.tabActivePaint(a.tabWordPaintLead(piece, a.pal.ink, a.tabPointerLead(on))) if on { word = a.pal.underline(word) } line += word - case piece.kind == tabFold || piece.kind == tabNew || piece.kind == tabHome || piece.kind == tabScrollLeft || piece.kind == tabScrollRight: + case piece.kind == tabFold || piece.kind == tabNew || piece.kind == tabScrollLeft || piece.kind == tabScrollRight || piece.kind == tabManager: if lit && hot.kind == piece.kind { word := piece.word if a.pal.profile < tokens.ANSI256 { switch piece.kind { - case tabHome: - word = a.linearMark("·", ".") + pageHome.word() + tabPad case tabNew: word = a.linearMark("·", ".") + "+ " case tabScrollLeft, tabScrollRight: word = a.linearMark("·", ".") + strings.TrimSpace(word) + " " } } - line += a.pal.cursor(a.pal.ink(word), 0) + line += a.tabHoverPaint(word) continue } line += a.pal.dim(piece.word) case on: - line += a.pal.background(a.tabWordPaint(piece, a.pal.ink), 0, a.pal.ramp.mark) + line += a.pal.background(a.tabWordPaintLead(piece, a.pal.ink, a.tabPointerLead(on)), 0, a.pal.ramp.mark) default: line += a.pal.selected(a.tabWordPaint(piece, a.pal.muted), 0) } @@ -817,9 +1137,27 @@ func (a *app) tabsPaint(pieces []tabPiece) string { return line } +// tabPointerLead is a tab's leading inset: a blank, or WHERE COLOUR CANNOT +// SHOW A GROUND the linear mark on the tab under the pointer, exactly where +// and when a nav word wears it (topnav.go's [app.navHoverPaint]), beside the +// `×` that appears with it. +func (a *app) tabPointerLead(on bool) string { + if !on || a.pal.profile >= tokens.ANSI256 { + return strings.Repeat(" ", tabInsetCells) + } + if a.pal.ascii || a.linear { + return "." + } + return "·" +} + // Navigation tint belongs to the name; the small status mark keeps its meaning. func (a *app) tabWordPaint(piece tabPiece, ink func(string) string) string { - pad := strings.Repeat(" ", tabInsetCells) + return a.tabWordPaintLead(piece, ink, strings.Repeat(" ", tabInsetCells)) +} + +// tabWordPaintLead is [app.tabWordPaint] with pad as the leading inset. +func (a *app) tabWordPaintLead(piece tabPiece, ink func(string) string, pad string) string { // Color carries selection as a filled tab; plain terminals keep brackets. // Replace the two furniture cells only, preserving every hit coordinate. if piece.tab.here && a.pal.profile >= tokens.ANSI256 { @@ -855,14 +1193,7 @@ func (a *app) tabClosePaint(piece tabPiece, hot tabHit, lit, on bool) string { if !piece.tab.here && !on { return a.pal.selected(a.pal.dim(piece.word), 0) } - mark := " " + a.tabCloseWord() + strings.Repeat(" ", tabInsetCells) - if on && a.pal.profile == tokens.NoColor { - pointer := "·" - if a.pal.ascii { - pointer = "." - } - mark = pointer + a.tabCloseWord() + strings.Repeat(" ", tabInsetCells) - } + mark := a.tabCloseWord() + strings.Repeat(" ", tabInsetCells) if piece.tab.here { painted := a.tabActivePaint(mark) if on && hot.kind == tabClose { @@ -888,6 +1219,12 @@ func (a *app) hotTab() (tabHit, bool) { if a.hot.kind != hoverTab { return tabHit{}, false } + if a.wall.door.pressable() && a.hot.index == a.wall.door.from { + return tabHit{span: a.wall.door, kind: tabWall}, true + } + if a.wall.chip.pressable() && a.hot.index == a.wall.chip.from { + return tabHit{span: a.wall.chip, kind: tabTeam}, true + } for _, hit := range a.chatTabHits { if hit.span.from == a.hot.index && hit.lights() { return hit, true @@ -914,12 +1251,12 @@ func tabsAt(hits []tabHit, from int) []tabHit { // ── THE POINTER ───────────────────────────────────────────────────────────── // tabAt is the piece under a pointer, and whether there is one. It answers only -// for the strip's own row, which is the bar's row ([placeTabRow]) wherever the +// for the strip's own row, which is the bar's row ([tabStripRow]) wherever the // strip is drawn at all — [app.view] draws it under the pulse and // [app.headHeight] charges for both. func (a *app) tabAt(x, y int) (tabHit, bool) { width, _ := a.size() - if y != placeTabRow || a.tabsHeight(width) == 0 { + if y != tabStripRow || a.tabsHeight(width) == 0 { return tabHit{}, false } for _, hit := range a.chatTabHits { @@ -927,6 +1264,12 @@ func (a *app) tabAt(x, y int) (tabHit, bool) { return hit, true } } + if a.wall.chip.pressable() && a.wall.chip.holds(x) { + return tabHit{span: a.wall.chip, kind: tabTeam}, true + } + if a.wall.door.pressable() && a.wall.door.holds(x) { + return tabHit{span: a.wall.door, kind: tabWall}, true + } return tabHit{}, false } @@ -955,7 +1298,7 @@ func (a *app) tabPress(x, y int) (tea.Cmd, bool) { if y < 0 || y >= a.tabsHeight(width) { return nil, false } - if y != placeTabRow { + if y != tabStripRow { return nil, true } hit, ok := a.tabAt(x, y) @@ -969,10 +1312,22 @@ func (a *app) tabPress(x, y int) (tea.Cmd, bool) { case tabScrollRight: a.tabScroll(1) return nil, true - case tabHome: - return a.openHome(), true case tabNew: return a.openChatStart(), true + case tabManager: + // The team's empty manager's place: a new conversation, made the + // manager (teammanager.go). + return a.teamManagerStart(), true + case tabTeam: + // The chip is the team switcher (teammenu.go). + a.openTeamMenu() + return nil, true + case tabWall: + if a.wall.on { + a.closeWall() + return nil, true + } + return a.openWall(), true case tabClose: return a.tabDismiss(hit.tab), true case tabHere: @@ -1147,9 +1502,14 @@ func (a *app) tabShutKey(key string) { // tabActivePaint gives the chosen tab a full contrasting surface, including // its close target. Plain terminals retain the existing bracket selection. -func (a *app) tabActivePaint(word string) string { - if a.pal.profile < tokens.ANSI256 { - return a.pal.bold(word) - } - return a.pal.background(a.pal.bold(a.pal.paint(ansi.Strip(word), a.pal.ramp.selected)), 0, a.pal.ramp.ink) +func (a *app) tabActivePaint(word string) string { return activeGround(a.pal, word) } + +// activeGround is the current item's ground on the one top bar: the chat +// strip's tab in front and the place you are standing in wear the same one. +// Plain terminals keep the bold. +func activeGround(pal palette, word string) string { + if pal.profile < tokens.ANSI256 { + return pal.bold(word) + } + return pal.background(pal.bold(pal.paint(ansi.Strip(word), pal.ramp.selected)), 0, pal.ramp.ink) } diff --git a/internal/tui3/chattabs_test.go b/internal/tui3/chattabs_test.go index cb1787928e..a2cf845691 100644 --- a/internal/tui3/chattabs_test.go +++ b/internal/tui3/chattabs_test.go @@ -35,7 +35,7 @@ func tabWords(a *app) []string { for _, hit := range a.chatTabHits { // The close cells are a target of their own on every tab (chattabs.go), // so a walk of the hit map that counted them would count every tab twice. - if hit.kind == tabFold || hit.kind == tabClose || hit.kind == tabNew || hit.kind == tabHome || hit.kind == tabScrollLeft || hit.kind == tabScrollRight { + if hit.kind == tabFold || hit.kind == tabClose || hit.kind == tabNew || hit.kind == tabScrollLeft || hit.kind == tabScrollRight { continue } words = append(words, hit.tab.word) @@ -46,7 +46,7 @@ func tabWords(a *app) []string { // clickTab presses one column of the frame's first row, which is the strip's. func clickTab(t *testing.T, a *app, x int) { t.Helper() - if cmd, took := a.tabPress(x, placeTabRow); took { + if cmd, took := a.tabPress(x, tabStripRow); took { _ = cmd return } @@ -74,8 +74,8 @@ func TestTheStripNamesEveryConversationAndKeepsItsOrderAcrossASwitch(t *testing. a, _, _ := tabApp(t) strip := plain(a.tabsRow(a.width)) // The names as a tab spells them: a tab is a label somebody recognises, so a - // long one is cut to [tabWordCap] rather than given the whole row. - for _, want := range []string{"openrouter price scrape", "Refactor the rail scop...", "Shipping the parser"} { + // long one is cut to [tabWordCap], at a word, rather than given the whole row. + for _, want := range []string{"openrouter price scrape", "Refactor the rail scope...", "Shipping the parser"} { if !strings.Contains(strip, want) { t.Fatalf("the strip is missing %q:\n%q", want, strip) } @@ -289,10 +289,10 @@ func TestEveryTabIsRecordedOnTheCellsItWasDrawnOn(t *testing.T) { t.Fatalf("at %d columns a tab was recorded past the end of the row: %+v\n%q", width, hit.span, line) } - if _, ok := a.tabAt(hit.span.from, placeTabRow); !ok { + if _, ok := a.tabAt(hit.span.from, tabStripRow); !ok { t.Fatalf("at %d columns the strip does not answer for its own cell %d", width, hit.span.from) } - if _, ok := a.tabAt(hit.span.from, placeTabRow+1); ok { + if _, ok := a.tabAt(hit.span.from, tabStripRow+1); ok { t.Fatalf("at %d columns the strip answers for the row under it", width) } } @@ -309,13 +309,13 @@ func TestTheStripIsChargedToTheBodyRegionAndMovesTheHeaderUnderIt(t *testing.T) if got := plain(rows[0]); !strings.HasPrefix(got, " "+plain(a.pal.wordmark(a.width))) { t.Fatalf("the frame's first row is not the pulse: %q", got) } - if got := plain(rows[placeTabRow]); !strings.Contains(got, a.chatDisplayName()) { + if got := plain(rows[tabStripRow]); !strings.Contains(got, a.chatDisplayName()) { t.Fatalf("the row under the pulse is not the strip: %q", got) } // THE ROOM'S TRAIL IS THE FIRST ROW UNDER THE WHOLE HEAD — the rule and the // blank under the strip are drawn in a room too (head.go). - if a.roomHeadRow() != placeHeadRows { - t.Fatalf("the room's header is on row %d, not under the %d-row head", a.roomHeadRow(), placeHeadRows) + if a.roomHeadRow() != chatHeadRows { + t.Fatalf("the room's header is on row %d, not under the %d-row head", a.roomHeadRow(), chatHeadRows) } if got := plain(rows[a.roomHeadRow()]); !strings.Contains(got, "Write the tree") { t.Fatalf("the trail is not on the row under the head: %q", got) @@ -396,3 +396,162 @@ func TestASharedSwitchKeepsTheUnsentSentenceOfTheConversationItLeaves(t *testing t.Fatalf("the composer left no record under its own identity: how=%v keep=%+v", how, keep) } } + +// THE STRIP'S PIECES STAND ONE GAP APART, AND A TAB IS AS WIDE ON ITS RIGHT AS +// ON ITS LEFT. Every button on the row carries its own pad, so the air between +// two of them is exactly one blank cell: the chip and the first tab, two tabs, +// a tab and `+`, `+` and `▦ All`, and the left arrow and what stands before it. +// The row's first ground is at [headLabelAt] with a chip or without one. And a +// tab at rest leads its name with as many blank cells as it closes it with. +func TestTheStripsPiecesStandOneGapApart(t *testing.T) { + for _, team := range []bool{false, true} { + for _, width := range []int{80, 110, 160} { + var a *app + if team { + a, _, _, _ = trafficApp(t) + } else { + a, _, _ = tabApp(t) + } + a.width = width + a.touch() + row := plain(a.tabsRow(width)) + type piece struct { + from, to int + pinned bool + } + var pieces []piece + if a.wall.chip.pressable() { + pieces = append(pieces, piece{from: a.wall.chip.from, to: a.wall.chip.to}) + } + for _, hit := range a.chatTabHits { + switch hit.kind { + case tabClose: + // The close cells are the tab's own closing cells. + pieces[len(pieces)-1].to = hit.span.to + case tabFold: + // The count is a fact at the row's end, not a packed piece. + case tabScrollRight: + // The right arrow is pinned to the window's end, so the air in + // front of it is the window's; what follows it is packed. + pieces = append(pieces, piece{hit.span.from, hit.span.to, true}) + default: + pieces = append(pieces, piece{from: hit.span.from, to: hit.span.to}) + } + } + if a.wall.door.pressable() { + pieces = append(pieces, piece{from: a.wall.door.from, to: a.wall.door.to}) + } + if len(pieces) < 3 { + t.Fatalf("team=%v at %d the strip drew %d pieces: %q", team, width, len(pieces), row) + } + if pieces[0].from != headLabelAt { + t.Fatalf("team=%v at %d the first ground is at %d, want %d: %q", team, width, pieces[0].from, headLabelAt, row) + } + for i := 1; i < len(pieces); i++ { + // A right arrow with nowhere to go is drawn dim and answers nothing, + // so it has no hit; it is still the window's pinned end. + between := ansi.Cut(row, pieces[i-1].to, pieces[i].from) + if strings.Contains(between, "›") || strings.Contains(between, "‹") { + continue + } + if gap := pieces[i].from - pieces[i-1].to; gap != 1 && !pieces[i].pinned { + t.Fatalf("team=%v at %d pieces %d and %d are %d cells apart, want 1:\n%q\n%+v", team, width, i-1, i, gap, row, pieces) + } + } + for _, hit := range a.chatTabHits { + if hit.kind != tabOther || hit.tab.signal != tabIdle { + continue + } + var close hudSpan + for _, c := range a.chatTabHits { + if c.kind == tabClose && c.tab.key == hit.tab.key { + close = c.span + } + } + tab := ansi.Cut(row, hit.span.from, close.to) + lead := len(tab) - len(strings.TrimLeft(tab, " ")) + tail := len(tab) - len(strings.TrimRight(tab, " ")) + if lead != tail { + t.Fatalf("team=%v at %d the tab %q leads with %d blanks and closes with %d", team, width, tab, lead, tail) + } + } + } + } +} + +// A LONG NAME IS CUT AT A WORD, not through one, where a word boundary is near. +func TestATabNameIsCutAtAWord(t *testing.T) { + for _, c := range []struct { + name string + width int + want string + }{ + {"Refactor the rail scope model", 25, "Refactor the rail..."}, + {"Refactor the rail scope model", 29, "Refactor the rail scope model"}, + {"Refactor the rail scope model", 27, "Refactor the rail scope..."}, + {"abcdefghijklmnopqrstuvwxyz", 12, "abcdefghi..."}, + {"Refactor the rail scope model", 14, "Refactor..."}, + {"openrouter price scrape", 13, "openrouter..."}, + } { + if got := fitTabTitle(c.name, c.width); got != c.want || ansi.StringWidth(got) > c.width { + t.Fatalf("%q at %d is %q, want %q", c.name, c.width, got, c.want) + } + } +} + +// EVERY DOOR ON THE STRIP SAYS WHAT IT DOES while the pointer rests on it: a +// tab its dock square's sentence, `×` that the work keeps running, `+` its key, +// the arrows which way. A SCROLLING STRIP DRAWS BOTH ARROWS, the one with +// nowhere to go dim and answering nothing, so the cells it holds never read as +// a gap nobody meant. +func TestEveryDoorOnTheStripSaysWhatItDoes(t *testing.T) { + a := manyTabApp(t) + a.start = nil + said := map[tabKind]bool{} + for _, width := range []int{80, 120, 160} { + a.width = width + a.hot = hoverAt{} + a.chatTabBar = tabBar{} + row := plain(a.tabsRow(width)) + hits := append([]tabHit(nil), a.chatTabHits...) + scrolls := false + for _, hit := range hits { + if hit.kind == tabScrollLeft || hit.kind == tabScrollRight { + scrolls = true + } + } + if scrolls && (!strings.Contains(row, "‹") || !strings.Contains(row, "›")) { + t.Fatalf("at %d a scrolling strip does not draw both arrows: %q", width, row) + } + for _, hit := range hits { + a.hot = hoverAt{kind: hoverTab, index: hit.span.from} + a.chatTabBar = tabBar{} + a.tabsRow(width) + words := a.dockHoverWords() + want := "" + switch hit.kind { + case tabOther: + want = dockCellHint(hit.tab) + case tabClose: + want = "Close this tab" + hintSegment + "the work keeps running" + case tabNew: + want = "New chat" + hintSegment + case tabScrollLeft: + want = "More tabs to the left" + case tabScrollRight: + want = "More tabs to the right" + default: + continue + } + if !strings.HasPrefix(words, want) { + t.Fatalf("at %d the pointer on %v says %q, want %q", width, hit.kind, words, want) + } + said[hit.kind] = true + } + } + for _, kind := range []tabKind{tabOther, tabClose, tabScrollRight} { + if !said[kind] { + t.Fatalf("no frame drew a %v to point at", kind) + } + } +} diff --git a/internal/tui3/chords.go b/internal/tui3/chords.go index 7a34852e88..0a4b96ce86 100644 --- a/internal/tui3/chords.go +++ b/internal/tui3/chords.go @@ -225,12 +225,12 @@ func (a *app) placeHint() string { return a.chords.say(a.placeHintSaid()) } // chordCtrlJumpWords is the alias clause the map grows where the terminal can // send it, and [chordSpelling.mapLine] is the only thing that adds it. -const chordCtrlJumpWords = " or " + chordCtrlWord + "1…7" +const chordCtrlJumpWords = " or " + chordCtrlWord + "1…9" // chordJumpWords is the map's own name for the jump class, and it is spelled // here so [chordSpelling.mapLine] and [placeMapWords] cannot drift apart about // where the alias clause goes. -const chordJumpWords = chordAltWord + "1…7" +const chordJumpWords = chordAltWord + "1…9" // chordMapAlias is `alt+.`'s second encoding, on the same terms as the digits: // live only where the terminal answered the keyboard query. @@ -291,7 +291,7 @@ func chordCtrlDigit(key string) (page, bool) { return placeDigitAt(chordCtrlWord // a place's composer draws one dim line, once, that the next real chord retires. var chordDeadKeys = map[rune]string{ '¡': "alt+1", '™': "alt+2", '£': "alt+3", '¢': "alt+4", - '∞': "alt+5", '§': "alt+6", '¶': "alt+7", + '∞': "alt+5", '§': "alt+6", '¶': "alt+7", '•': "alt+8", 'ª': "alt+9", '≥': "alt+.", '©': "alt+g", 'œ': "alt+q", 'ß': "alt+s", 'π': "alt+p", '¥': "alt+y", @@ -447,6 +447,6 @@ func (c chordSpelling) chordSetupWords() string { if c.meta != chordMetaWord { return "" } - return "the seven places answer " + chordMetaWord + "1…" + chordMetaWord + - "7 · if " + chordMetaBare + " types a character instead, " + c.chordFixWords() + return "the places answer " + chordMetaWord + "1…" + chordMetaWord + + "9 · if " + chordMetaBare + " types a character instead, " + c.chordFixWords() } diff --git a/internal/tui3/chords_test.go b/internal/tui3/chords_test.go index 81599920fa..30504665a6 100644 --- a/internal/tui3/chords_test.go +++ b/internal/tui3/chords_test.go @@ -166,16 +166,16 @@ func TestTheCtrlDigitAliasIsClaimedOnlyWhereTheTerminalSaidItCan(t *testing.T) { } a.keysDisambiguated = true - a.placeKeyPress(ctrlKey('3')) - if want := pages()[2]; a.page != want { - t.Fatalf("ctrl+3 went to %s and the third place is %s", a.page.word(), want.word()) + a.placeKeyPress(ctrlKey('4')) + if want := placeOrder[3]; a.page != want { + t.Fatalf("ctrl+4 went to %s and the fourth place is %s", a.page.word(), want.word()) } // AND IT IS THE SAME PLACE THE alt SPELLING REACHES. One digit reading behind // both encodings is what makes that true by construction. a.showPage(pageHome) - a.placeKeyPress(tea.KeyPressMsg{Code: '3', Mod: tea.ModAlt}) - if want := pages()[2]; a.page != want { - t.Fatalf("alt+3 went to %s and the third place is %s", a.page.word(), want.word()) + a.placeKeyPress(tea.KeyPressMsg{Code: '4', Mod: tea.ModAlt}) + if want := placeOrder[3]; a.page != want { + t.Fatalf("alt+4 went to %s and the fourth place is %s", a.page.word(), want.word()) } a.showPage(pageHome) a.placeKeyPress(ctrlKey('.')) @@ -199,18 +199,18 @@ func TestTheMapNamesTheCtrlAliasExactlyWhenItIsBound(t *testing.T) { a.mapShowing = true a.keysDisambiguated = false - if line := a.placeHint(); strings.Contains(line, "ctrl+1…7") { + if line := a.placeHint(); strings.Contains(line, "ctrl+1…9") { t.Fatalf("the map offers a chord this terminal cannot send:\n%s", line) } a.keysDisambiguated = true line := a.placeHint() - if !strings.Contains(line, "alt+1…7 or ctrl+1…7 go to a place") { + if !strings.Contains(line, "alt+1…9 or ctrl+1…9 go to a place") { t.Fatalf("the map hides an alias that is bound:\n%s", line) } // AND ON A MAC IT IS THE MAC'S SPELLING OF THE FIRST AND THE PLAIN ONE OF THE // SECOND: `ctrl` is `ctrl` on every keyboard there is. a.chords = detectChords("darwin", envOf(map[string]string{"TERM_PROGRAM": "kitty"})) - if mac := a.placeHint(); !strings.Contains(mac, "opt+1…7 or ctrl+1…7 go to a place") { + if mac := a.placeHint(); !strings.Contains(mac, "opt+1…9 or ctrl+1…9 go to a place") { t.Fatalf("the mac map reads wrong:\n%s", mac) } } @@ -280,7 +280,7 @@ func TestTheOptionAsMetaNoteIsNeitherDrawnOffAMacNorInAConversation(t *testing.T func TestTheFirstRunLineNamesTheChordsAndTheSettingOnAMacOnly(t *testing.T) { mac := detectChords("darwin", envOf(map[string]string{"TERM_PROGRAM": "Apple_Terminal"})) words := mac.chordSetupWords() - for _, want := range []string{"opt+1…opt+7", "if opt types a character instead", "use option as meta", "Terminal: Profiles › Keyboard › Use Option as Meta key"} { + for _, want := range []string{"opt+1…opt+9", "if opt types a character instead", "use option as meta", "Terminal: Profiles › Keyboard › Use Option as Meta key"} { if !strings.Contains(words, want) { t.Fatalf("the first-run line lost %q:\n%s", want, words) } @@ -303,9 +303,9 @@ func TestTheOptionCharacterTableIsExactlyTheBoundChords(t *testing.T) { t.Fatalf("%q is filed under %q, which is not a chord this surface binds", r, chord) } } - // The seven places, the map, and the letters the composer and the two places + // The nine places, the map, and the letters the composer and the two places // that have a view actually take. - for _, chord := range []string{"alt+1", "alt+7", "alt+.", "alt+g", "alt+q", "alt+s", "alt+w", "alt+p", "alt+y", "alt+o", "alt+b", "alt+f"} { + for _, chord := range []string{"alt+1", "alt+7", "alt+9", "alt+.", "alt+g", "alt+q", "alt+s", "alt+w", "alt+p", "alt+y", "alt+o", "alt+b", "alt+f"} { found := false for _, have := range chordDeadKeys { if have == chord { diff --git a/internal/tui3/commands.go b/internal/tui3/commands.go index 6cc3bfe2ee..6858f72fb5 100644 --- a/internal/tui3/commands.go +++ b/internal/tui3/commands.go @@ -146,6 +146,11 @@ var commands = []command{ // own row which question it is answering, so nobody who typed either word // lands nowhere. {name: "search", desc: "everything said on this machine · " + placeChord(pageSearch)}, + {name: "wall", desc: "every open conversation, live, and your teams · alt+v or ▦ below the box"}, + // THE TEAMS PAGE, beside the wall it opens onto: the wall is the open + // conversations big, and this is the team-level view, every member open or + // not, the manager's conversation and what waits on you (place_teams.go). + {name: "teams", desc: "your teams, their managers and what waits on you · " + placeChord(pageTeams)}, {name: "spend", desc: "what this machine has cost, by the day · " + placeChord(pageSpend)}, // It sits AFTER /compact and before /help because those two are the pair a // person reads together when a conversation has gone wrong: compacting is @@ -524,7 +529,7 @@ func (c command) aliasNote() string { // AND IT IS WHERE A ROW'S CHORD IS SPELLED FOR THIS KEYBOARD. Two of these // descriptions carry a place's own chord ([placeChord]), baked in at init where // no terminal has been detected yet — so on a Mac the list said `/spend … alt+3` -// while the map two keystrokes away said `opt+1…opt+7`. The substitution has to +// while the map two keystrokes away said `opt+1…opt+8`. The substitution has to // happen HERE rather than at either paint, because `⌘` is one cell where `cmd+` // is four and [menu.fit] counts the lines this string will take before // [menu.rows] draws it: measuring one spelling and drawing the other is a list @@ -1009,7 +1014,7 @@ func helpText(file string, chords chordSpelling) string { // know how to open, which is a help sheet behind the thing it explains. // // The three rows are spelled through [chordSpelling.say] like the - // `alt+enter` row above them, so a Mac reads `opt+1…opt+7` and a Linux box + // `alt+enter` row above them, so a Mac reads `opt+1…opt+8` and a Linux box // reads what is authored here — one substitution, one door (chords.go). helpKeyRow(chords.say(chordJumpWords), "go to a place · in the tab bar's own order: "+placeWordList()), helpKeyRow(chords.say(placeMapKey), "on a place: what else is here · every key that place has, drawn"), @@ -1074,8 +1079,13 @@ func helpText(file string, chords chordSpelling) string { // answer to the question that test asks). The card is named by what it is // instead. helpKeyRow(closeTabChord, "close this tab · select the last open chat · keep your draft"), + // THE TEAM'S TWO CHORDS (teamrail.go). They do something only in a team + // with a manager, and the rows say so rather than leaving a person to + // find out by pressing them anywhere else. + helpKeyRow(chords.say(trafficKey), "with a team's manager in front: show or hide its Traffic"), + helpKeyRow(chords.say(teamManagerKey), "in a team with a manager: go to the manager"), helpKeyRow(reopenTabChord, "reopen the last closed tab · when the terminal sends this distinct chord"), - helpKeyRow(chords.say(railHoldChord), "the task roster · ↑↓ move · →← fold · enter opens · esc back"), + helpKeyRow(chords.say(railHoldChord), "the task roster · ↑↓ move · ←→ tasks/traffic · enter opens · esc back"), "ctrl+. every task this project has run · /history · type to filter", "ctrl+g close the roster's column, or bring it back · remembered", "ctrl+l back to the latest · the chip above the box says so too", @@ -1107,6 +1117,11 @@ func helpText(file string, chords chordSpelling) string { "ctrl+, open settings", "d in /permissions: drop the line under the cursor · press it twice", "p s n in /standing: pause one · stop it · keep it out of here", + // THE TEAMS PAGE'S LETTERS, each the button of the same word on the + // selected team, and the chord that puts the keyboard on those buttons + // while the manager's conversation has the box (teamspagehost.go). + "s c w n o in /teams: settings · close · open on the wall · new team · organize", + helpKeyRow(chords.say("alt+↑↓"), "in /teams: onto the page's buttons while the manager has the box · esc back"), "ctrl+r ctrl+y in /files: reveal the folder it is in · copy it somewhere", ) if file != "" { diff --git a/internal/tui3/consent.go b/internal/tui3/consent.go index 0c27722c62..5a207a7f1c 100644 --- a/internal/tui3/consent.go +++ b/internal/tui3/consent.go @@ -133,7 +133,7 @@ func (a *app) consentQuestion(ev session.Event) session.Question { Ask: session.AskPermission, Form: session.FormLine, Asker: session.Asker{Kind: session.AskerEngine}, - Head: consentHead(ev.Tool), + Head: consentHead(ev.Tool, ev.Args), Reason: reason, Subject: session.SubjectRef{Kind: session.SubjectCall, CallID: ev.CallID, Name: ev.Tool}, Options: options, @@ -145,8 +145,11 @@ func (a *app) consentQuestion(ev session.Event) session.Question { // consentHead is the question's own sentence, and it is the line another window // already answers from (session's [Agent.ask] writes the same one). -func consentHead(tool string) string { - return "needs your ok to run " + strings.TrimSpace(tool) +func consentHead(tool, args string) string { + // THE SESSION'S ONE BUILDER, so the card here and the question home answers + // are the same sentence: `◆ manager wants to start @lexer` for a manager's + // start, and the ordinary line for everything else. + return session.ConsentHead(tool, args) } // consentShown is that question dressed with the three things the object cannot diff --git a/internal/tui3/depthfade_test.go b/internal/tui3/depthfade_test.go index 2b8b5a8383..40fda2d7f9 100644 --- a/internal/tui3/depthfade_test.go +++ b/internal/tui3/depthfade_test.go @@ -268,6 +268,8 @@ func fadeColumnApp(t *testing.T, count int) *app { for i := 0; i < count; i++ { a.taskUpdate(update(uint64(i+1), "The "+fadeWord(i)+" errand", session.TaskDone, session.TaskNotice{})) } + // The finished work opened, so it is longer than the frame. + railOpenAll(a) a.paints = 0 return a } diff --git a/internal/tui3/eschint_test.go b/internal/tui3/eschint_test.go new file mode 100644 index 0000000000..3c95c8c16c --- /dev/null +++ b/internal/tui3/eschint_test.go @@ -0,0 +1,135 @@ +package tui3 + +import ( + "go/ast" + "go/parser" + "go/token" + "strconv" + "strings" + "testing" +) + +// HINT LINES SPELL esc ONE WAY. The majority of them say `esc cancel`, the +// imperative, and a few said `esc cancels`. The same split on any other verb +// is the same defect: one key reading as two gestures. This walks the hint +// word constants, and the hint functions that inline the same words, and +// fails on the form the majority does not use. +func TestHintWordsSpellEscTheWayTheMajorityDoes(t *testing.T) { + fset := token.NewFileSet() + pkgs, err := parser.ParseDir(fset, ".", nil, 0) + if err != nil { + t.Fatal(err) + } + var lits []string + for _, pkg := range pkgs { + for name, file := range pkg.Files { + if strings.HasSuffix(name, "_test.go") { + continue + } + ast.Inspect(file, func(n ast.Node) bool { + switch n := n.(type) { + case *ast.ValueSpec: + if n.Names == nil { + return true + } + hint := false + for _, id := range n.Names { + if hintWordName(id.Name) { + hint = true + } + } + if !hint { + return true + } + for _, v := range n.Values { + if s, ok := stringLit(v); ok && strings.Contains(s, "esc ") { + lits = append(lits, s) + } + } + case *ast.FuncDecl: + if n.Name == nil || !hintWordName(n.Name.Name) || n.Body == nil { + return true + } + ast.Inspect(n.Body, func(m ast.Node) bool { + if s, ok := stringLit(m); ok && strings.Contains(s, "esc ") { + lits = append(lits, s) + } + return true + }) + return false + } + return true + }) + } + } + if len(lits) == 0 { + t.Fatal("no hint word mentioned esc, so the scan is looking in the wrong place") + } + count := map[string]int{} + for _, lit := range lits { + for _, verb := range escVerbs(lit) { + count[verb]++ + } + } + odd := map[string]string{} + for verb, n := range count { + if !strings.HasSuffix(verb, "s") || len(verb) < 2 { + continue + } + bare := strings.TrimSuffix(verb, "s") + if count[bare] > n { + odd[verb] = bare + } + } + if len(odd) == 0 { + return + } + for _, lit := range lits { + for _, verb := range escVerbs(lit) { + bare, bad := odd[verb] + if !bad { + continue + } + t.Errorf("a hint says %q, and the majority of hint lines say %q:\n %s", + "esc "+verb, "esc "+bare, lit) + } + } +} + +// hintWordName reports whether a Go name is one of the hint-word constants or +// the functions that return a hint line. +func hintWordName(name string) bool { + return strings.Contains(name, "Hint") || strings.Contains(name, "Keys") +} + +func stringLit(n ast.Node) (string, bool) { + lit, ok := n.(*ast.BasicLit) + if !ok || lit.Kind != token.STRING { + return "", false + } + s, err := strconv.Unquote(lit.Value) + if err != nil { + return "", false + } + return s, true +} + +// escVerbs is every word standing immediately after `esc ` in s. +func escVerbs(s string) []string { + var out []string + rest := s + for { + i := strings.Index(rest, "esc ") + if i < 0 { + return out + } + rest = rest[i+len("esc "):] + word := rest + if cut := strings.IndexAny(word, " ·\t"); cut >= 0 { + word = word[:cut] + } + if word != "" { + out = append(out, word) + } + } +} diff --git a/internal/tui3/files.go b/internal/tui3/files.go index b8041935bc..5cf7d567bc 100644 --- a/internal/tui3/files.go +++ b/internal/tui3/files.go @@ -119,6 +119,21 @@ type completion struct { // the count the "older" rule carries when the cap left no room to draw them. older int + // teams and chats are the catalogs this list ranks, copied from memory on + // the update loop (mention.go). recents is the recent-conversation snapshot + // loaded once, off the loop, because that list can touch the disk. + teams []mentionTeam + chats []mentionChat + recents []mentionChat + // teamHits and chatHits are what this query kept, already capped. + teamHits []mentionTeam + chatHits []mentionChat + // scope is which section a prefix narrowed to: "team", "chat", "file", or + // "" for every section at once. + scope string + // recentsHeld says a read of the recent list is already in flight. + recentsHeld bool + // lines is what the overlay DRAWS, section rules included, and sel is the // line each selectable row sits on, in cursor order. The split is what lets // a list with headings in it keep one cursor that cannot land on a heading: @@ -130,12 +145,21 @@ type completion struct { top int } -// compLine is one drawn row: a section rule, a task, or a file. Exactly one of -// the three is set — header non-empty, or task >= 0, or file >= 0. +// compLine is one drawn row: a section rule, the prefix words, a team, a +// conversation, a task, or a file. Exactly one of those is set. The index +// fields are -1 when they are not the row. type compLine struct { - header string - task int - file int + header string + filters bool + task int + file int + team int + chat int +} + +// deadLine is a row that is not a team, a chat, a task or a file. +func deadLine() compLine { + return compLine{task: -1, file: -1, team: -1, chat: -1} } // sync opens, narrows or closes the completion from the draft and the caret. It @@ -171,7 +195,11 @@ func (c *completion) sync(e *editor) { c.open = false return } - if at == c.at && query == c.done { + // done == "" is the zero value, and it is also a team insertion, which + // takes the "@" out. Matching it here closed a list on the first "@" of + // a draft, because that token sits at rune 0 with an empty query and the + // zero at is 0 too. + if c.done != "" && at == c.at && query == c.done { c.open = false return } @@ -250,27 +278,38 @@ func atToken(value []rune, cursor int) (int, string, bool) { return start, string(value[start+1 : cursor]), true } -// rank scores every path and every task against the query, keeps what matched, -// and lays the two out as one list. +// rank scores every path, team, conversation and task against the query, keeps +// what matched, and lays them out as one list. func (c *completion) rank() { if cap(c.score) < len(c.all) { c.score = make([]int, len(c.all)) } - needle := strings.ToLower(c.query) + scope, needle := mentionScope(c.query) + c.scope = scope + needle = strings.ToLower(needle) c.hits = c.hits[:0] - for i, path := range c.all { - score, ok := pathScore(path, needle) - if !ok { - continue + // A prefix that is not "file" hides the paths. The argument list is only + // ever paths, so it never takes a prefix. + if c.arg || c.scope == "" || c.scope == scopeFile { + for i, path := range c.all { + score, ok := pathScore(path, needle) + if !ok { + continue + } + c.score[i] = score + c.hits = append(c.hits, i) + } + sort.SliceStable(c.hits, func(a, b int) bool { return c.score[c.hits[a]] < c.score[c.hits[b]] }) + if len(c.hits) > completeRows*4 { + c.hits = c.hits[:completeRows*4] } - c.score[i] = score - c.hits = append(c.hits, i) } - sort.SliceStable(c.hits, func(a, b int) bool { return c.score[c.hits[a]] < c.score[c.hits[b]] }) - if len(c.hits) > completeRows*4 { - c.hits = c.hits[:completeRows*4] + c.rankMentions(needle) + if c.arg || c.scope != "" { + c.taskHits, c.taskSection, c.older = c.taskHits[:0], c.taskSection[:0], 0 + } else { + c.rankTasks() } - c.rankTasks() c.layout() c.cursor = moveCursor(c.cursor, 0, len(c.sel)) c.follow(c.rowsWanted()) @@ -284,17 +323,34 @@ func (c *completion) rank() { // the one thing on screen would be a label saying what a person can already see. func (c *completion) layout() { c.lines, c.sel = c.lines[:0], c.sel[:0] + if !c.arg { + line := deadLine() + line.filters = true + c.lines = append(c.lines, line) + } + c.lines = c.layoutMentions(c.lines) + above := len(c.teamHits) > 0 || len(c.chatHits) > 0 || len(c.taskHits) > 0 if len(c.taskHits) > 0 { c.lines = c.layoutTasks(c.lines) - if len(c.hits) > 0 { - c.lines = append(c.lines, compLine{header: compFilesRule, task: -1, file: -1}) - } + } + if len(c.hits) > 0 && above { + line := deadLine() + line.header = compFilesRule + c.lines = append(c.lines, line) } for _, at := range c.hits { - c.lines = append(c.lines, compLine{task: -1, file: at}) + line := deadLine() + line.file = at + c.lines = append(c.lines, line) + } + selectable := len(c.teamHits) > 0 || len(c.chatHits) > 0 || len(c.taskHits) > 0 || len(c.hits) > 0 + if !c.arg && !selectable && c.loaded { + line := deadLine() + line.header = c.emptyWord() + c.lines = append(c.lines, line) } for at, line := range c.lines { - if line.header == "" { + if line.header == "" && !line.filters { c.sel = append(c.sel, at) } } @@ -304,7 +360,7 @@ func (c *completion) layout() { // screenful, or the taller screenful a sectioned list needs to show both halves // of itself. [app.overlayHeight] is what actually decides, and it clamps. func (c *completion) rowsWanted() int { - if len(c.taskHits) > 0 { + if len(c.taskHits) > 0 || len(c.teamHits) > 0 || len(c.chatHits) > 0 { return completeTall } return completeRows @@ -486,8 +542,12 @@ func isFolderPath(path string) bool { return strings.HasSuffix(path, "/") } func (c *completion) lineNote(at int) string { line := c.lines[at] switch { - case line.header != "": + case line.header != "" || line.filters: return "" + case line.team >= 0: + return mentionCount(c.teamHits[line.team]) + case line.chat >= 0: + return c.chatHits[line.chat].note case line.task >= 0: return taskNoteWord(c.taskHits[line.task]) case isFolderPath(c.all[line.file]): @@ -502,7 +562,7 @@ func (c *completion) lineNote(at int) string { } } -func (c *completion) rows(width, n int, pal palette, hover int) []string { +func (c *completion) rows(width, n int, pal palette, hover int, headKey string) []string { if n <= 0 { return nil } @@ -510,7 +570,7 @@ func (c *completion) rows(width, n int, pal palette, hover int) []string { if !c.loaded { return []string{pal.dim(" looking…")} } - return []string{pal.dim(" no file matches")} + return []string{pal.dim(" " + c.emptyWord())} } c.follow(overlayItems(n, width)) fill := newOverlayFill(width, n, pal, hover) @@ -518,8 +578,14 @@ func (c *completion) rows(width, n int, pal palette, hover int) []string { line := c.lines[at] var ok bool switch { + case line.filters: + ok = fill.plain(mentionHeadLine(pal, c.scope, headKey, width)) case line.header != "": ok = fill.plain(pal.dim(" " + fit(line.header, width-2))) + case line.team >= 0: + ok = fill.add(at, mentionTeamLabel(c.teamHits[line.team], pal), c.lineNote(at), at == c.selLine(), false) + case line.chat >= 0: + ok = fill.add(at, mentionChatLabel(c.chatHits[line.chat]), c.lineNote(at), at == c.selLine(), false) case line.task >= 0: ok = fill.add(at, taskRowLabel(c.taskHits[line.task], pal), c.lineNote(at), at == c.selLine(), false) default: diff --git a/internal/tui3/firstrun.go b/internal/tui3/firstrun.go index f28ce5156e..28c02d97ba 100644 --- a/internal/tui3/firstrun.go +++ b/internal/tui3/firstrun.go @@ -951,7 +951,7 @@ func (a *app) setupKeysWord() string { return a.setupControlsKeys(max(width-2*setupMargin, 1)) } if s.authStarting || s.authFlow != nil { - return "esc cancels" + return "esc cancel" } if strings.TrimSpace(s.text) == "" { if a.routerConnect != nil { diff --git a/internal/tui3/focus_test.go b/internal/tui3/focus_test.go index f16fcf95e4..0d9eaa0bd9 100644 --- a/internal/tui3/focus_test.go +++ b/internal/tui3/focus_test.go @@ -40,7 +40,7 @@ func headPanel(a *app) string { return headRow(a) + "\n" + headFactsRow(a) } // tabsRowOf reads the tab labels inside the header's optional vertical padding. func tabsRowOf(a *app) string { rows := strings.Split(frame(a), "\n") - at := placeTabRow + at := tabStripRow if at >= len(rows) { return "" } @@ -91,7 +91,7 @@ func TestARoomPinsAFocusHeader(t *testing.T) { // What is left over a conversation is the places' head — the pulse, the // strip, the rule and the blank — which is the seam between the head and the // transcript (head.go). - if a.headHeight() != placeHeadRows || !strings.Contains(head, a.chatDisplayName()) { + if a.headHeight() != chatHeadRows || !strings.Contains(head, a.chatDisplayName()) { t.Fatalf("the conversation's strip is %d rows and reads:\n%q", a.headHeight(), head) } for _, gone := range []string{"Fix the nil-map", roomBackWord, roomCrumbSep} { @@ -163,20 +163,20 @@ func TestTheRailIsStillTheDoorUnderTheHeader(t *testing.T) { a, _, _ := roomApp(t) drive(t, a, streamEventMsg{gen: a.gen, ev: update(9, "Mix the audio", session.TaskRunning, session.TaskNotice{})}) - // TWO FAMILIES OF ONE, EQUALLY URGENT, so the column is in the order the - // session admitted them (task.go): node 7 first, node 9 under it. Which is - // which is not what this test owns — it owns the OFFSET — but naming them in - // the roster's own order is what keeps it about that. + // TWO RUNNING TASKS, so the column is newest first under one heading: + // node 9, then node 7. Which is which is not what this test owns (it owns + // the OFFSET), but naming them in the roster's own order is what keeps it + // about that. clickRail(t, a, 0) - if a.room == nil || a.room.id != 7 { - t.Fatalf("the first rail row did not open node 7: %+v", a.room) + if a.room == nil || a.room.id != 9 { + t.Fatalf("the first rail row did not open node 9: %+v", a.room) } - // Node 9 is drawn under node 7, and the header is above both: a click on the + // Node 7 is drawn under node 9, and the header is above both: a click on the // rail's second row has to land a row further down the screen than it did // before the room opened. clickRail(t, a, 1) - if a.room == nil || a.room.id != 9 { - t.Fatalf("the second rail row did not open node 9 through the header: %+v", a.room) + if a.room == nil || a.room.id != 7 { + t.Fatalf("the second rail row did not open node 7 through the header: %+v", a.room) } } diff --git a/internal/tui3/foot.go b/internal/tui3/foot.go index 0a8eb44b18..0a23e0626b 100644 --- a/internal/tui3/foot.go +++ b/internal/tui3/foot.go @@ -529,6 +529,14 @@ func (a *app) seamPieces(width int) seamPieces { // deck take the same word from the same function. pieces := seamPieces{host: a.host, model: a.modelWord(), project: a.seamProjectWord()} + // AND IN A MANAGED TEAM THE SLOT SAYS WHERE THE WORDS GO, once there are + // words: the empty box says it as its placeholder (teamrailpointer.go's + // [app.trafficHint]), and the first keystroke took the placeholder away with + // the one fact a person typing to a team needs. `to ◆ manager`, or + // `to @web` with a member in front. + if !a.input.empty() { + pieces.name = a.trafficHint() + } if pieces.model != "" { // A rung with no model beside it has nothing to be about, and the ladder // it belongs to is reached by name (`/effort`) rather than from a cell diff --git a/internal/tui3/footswap.go b/internal/tui3/footswap.go index a67f9ce603..3628ddd5dd 100644 --- a/internal/tui3/footswap.go +++ b/internal/tui3/footswap.go @@ -227,11 +227,19 @@ func (a *app) seamTelemetryLabel(ledger, alive []hudPart) (string, string) { // the keys leave, cut on the right where they leave it too little, gone // where they leave it less than a word. It came down off the seam so the // two feet a person moves between most read the same way, and it is still -// a door — onto the folder chooser ([app.seamProjectPress]) — so its columns +// a door, onto the folder chooser ([app.seamProjectPress]), so its columns // are recorded here, as the row is laid out ([app.seamProjectSpan]). +// +// THE DOCK IS LAID OUT LAST, in what the keys and the right end left +// (walldock.go): it narrows to fewer cells, then goes, before the keys lose a +// clause or the project a cell. While the pointer rests on it, the keys' own +// cells say what is under the pointer instead, and the dock does not move, +// because it was fitted against the keys and not against the words standing +// in for them. func (a *app) hintRow(width int) string { a.homeDoor = hudSpan{} a.seamProjectSpan = hudSpan{} + a.dockClear() hint := a.footHint(width) right, rightPlain := "", "" if !a.seamShowing() { @@ -256,57 +264,86 @@ func (a *app) hintRow(width int) string { } else { hint = "" } - if offset := strings.Index(hint, homeDoorWord); offset >= 0 { - from := 1 + ansi.StringWidth(hint[:offset]) - a.homeDoor = hudSpan{from: from, to: from + ansi.StringWidth(homeDoorWord)} - } - // THE ROW FILLS THE FRAME, as every foot row does: a row shorter than the - // frame would leave the cells behind it to whatever the last frame drew. - line := "" - if hint != "" { - line = " " + paintHint(hint, a.pal, a.pal.dim) - } - used := ansi.StringWidth(hint) - if used > 0 { - used++ + keys := ansi.StringWidth(hint) + if keys > 0 { + keys++ } // THE LOW-CREDIT LINE STANDS JUST LEFT OF WHATEVER HOLDS THE RIGHT EDGE // (credits.go, #1439): the aliveness on a frame with no seam, the project on // every other. It is drawn whole or not at all, so the project is fitted to // what the keys AND the line leave, and gives way before the line does. + // The right end is settled first, as one run starting at column from, so + // the dock can be fitted into what is left between it and the keys. warned := "" if warning != "" { warned = a.pal.warn(warning) } - if rightPlain != "" { + tail, from := "", width + switch { + case rightPlain != "": + tail, from = right, width-ansi.StringWidth(rightPlain) if warned != "" { - pad := max(1, width-used-ansi.StringWidth(warning)-hudGap-ansi.StringWidth(rightPlain)) - return line + strings.Repeat(" ", pad) + warned + strings.Repeat(" ", hudGap) + right + tail = warned + strings.Repeat(" ", hudGap) + tail + from -= ansi.StringWidth(warning) + hudGap } - return line + strings.Repeat(" ", max(1, width-used-ansi.StringWidth(rightPlain))) + right - } - before := used - if warned != "" { - before += 1 + ansi.StringWidth(warning) - } - // THE PROJECT, in what the keys leave — never inside a room, whose page - // carries the node's own identity (roomseam.go). - if project := a.seamProjectWord(); project != "" && !a.roomOpen() { - if text, span, ok := projectAtRight(project, before, width); ok { - a.seamProjectSpan = span - painted := a.paintSeamProject(text, - hudSpan{from: ansi.StringWidth(targetProjectLead), to: ansi.StringWidth(text)}, - a.hot.kind == hoverSeamProject) - if warned != "" { - pad := width - 1 - used - ansi.StringWidth(warning) - hudGap - ansi.StringWidth(text) - return line + strings.Repeat(" ", max(1, pad)) + warned + strings.Repeat(" ", hudGap) + painted + " " + default: + before := keys + if warned != "" { + before += 1 + ansi.StringWidth(warning) + } + // THE PROJECT, in what the keys leave, never inside a room, whose page + // carries the node's own identity (roomseam.go). + if project := a.seamProjectWord(); project != "" && !a.roomOpen() { + if text, span, ok := projectAtRight(project, before, width); ok { + a.seamProjectSpan = span + tail = a.paintSeamProject(text, + hudSpan{from: ansi.StringWidth(targetProjectLead), to: ansi.StringWidth(text)}, + a.hot.kind == hoverSeamProject) + " " + from = width - 1 - ansi.StringWidth(text) + if warned != "" { + tail = warned + strings.Repeat(" ", hudGap) + tail + from -= ansi.StringWidth(warning) + hudGap + } + break } - pad := width - 1 - used - ansi.StringWidth(text) - return line + strings.Repeat(" ", pad) + painted + " " } + if warned != "" { + tail, from = warned+" ", width-1-ansi.StringWidth(warning) + } + } + // The dock finishes one cell short of the frame's edge, the keys' inset + // mirrored, or a gap short of whatever holds the right end. + end := width - 1 + if tail != "" { + end = from - hudGap + } + dock, dockW := a.dockRow(width, end, ansi.StringWidth(hint)) + paint := func(s string) string { return paintHint(s, a.pal, a.pal.dim) } + // THE WORDS UNDER THE POINTER ARE THE HINT LINE'S OWN DIM, with the key + // they name stepped up as every key on this line is: they stand in for the + // keys, so they are painted as the keys are rather than louder than them. + if words := a.dockHoverWords(); words != "" { + hint = fit(words, max(0, end-1-dockW-hudGap)) + } else if offset := strings.Index(hint, homeDoorWord); offset >= 0 { + at := 1 + ansi.StringWidth(hint[:offset]) + a.homeDoor = hudSpan{from: at, to: at + ansi.StringWidth(homeDoorWord)} + } + // THE ROW FILLS THE FRAME, as every foot row does: a row shorter than the + // frame would leave the cells behind it to whatever the last frame drew. + line := "" + if hint != "" { + line = " " + paint(hint) + } + used := ansi.StringWidth(hint) + if used > 0 { + used++ + } + if dockW > 0 { + line += strings.Repeat(" ", max(0, end-dockW-used)) + dock + used = end } - if warned != "" { - return line + strings.Repeat(" ", max(1, width-1-used-ansi.StringWidth(warning))) + warned + " " + if tail != "" { + return line + strings.Repeat(" ", max(1, from-used)) + tail } return line + strings.Repeat(" ", max(0, width-used)) } diff --git a/internal/tui3/framedisk_law_test.go b/internal/tui3/framedisk_law_test.go index c514783b2c..b4152b28ca 100644 --- a/internal/tui3/framedisk_law_test.go +++ b/internal/tui3/framedisk_law_test.go @@ -163,6 +163,18 @@ var frameForbidden = map[string]map[string]bool{ "filepath": {"Glob": true, "Walk": true, "WalkDir": true, "EvalSymlinks": true}, "net": {"*": true}, "http": {"*": true}, + // The team store (internal/teams) is another package, so its bodies are + // leaves to this walk; its doors that touch the disk are named here so a + // frame that reached one would still be seen. + "teamstore": { + "Load": true, "LoadHued": true, "Save": true, "Update": true, "SetAside": true, + "AppendTraffic": true, "ReadTraffic": true, + // The delegation store's doors (DESIGN.md section 8), every one a read + // or a write of a file. + "DefaultsAt": true, "Raise": true, "Decide": true, "Escalate": true, + "OpenPackets": true, "Packets": true, "PacketByID": true, "PacketsStamp": true, + "TeamSpend": true, "TeamSpendIn": true, "TeamSpendStamp": true, "Delete": true, + }, } // processForbidden is the narrower question the update loop is asked: not diff --git a/internal/tui3/head.go b/internal/tui3/head.go index b03ebc21a9..436e1a7dc4 100644 --- a/internal/tui3/head.go +++ b/internal/tui3/head.go @@ -2,41 +2,84 @@ package tui3 // THE HEAD: ONE SET OF ROWS OVER EVERY FRAME. // -// codeaf 2 want you · 1 moving · $0.14 / $20.00 · thu 9:49am -// home Parsing the logs Porting the picker -// ────────────────────────────────────────────────────────────────────────────── +// >● codeaf home teams chats sessions spend settings 2 want you · $1.20 thu 10:31pm +// ● harbor ▾ ◆ Manager × Refactor the rail… × + ▦ All +// ─────────────────────────────────────────────────────────────────────────────────────────── // -// The pulse, then the row that says where you are — the bar of places on a -// place, the strip of chats in a conversation — then the rule, then a blank. -// Four rows ([placeHeadRows]), the bar and the strip on the same one -// ([placeTabRow]). +// The wordmark with the places after it and the machine's pulse on the far +// end (topnav.go) is row zero on every page, and it never moves. The strip of +// chats (chattabs.go) is the next row ONLY while a conversation is in front: +// a chat, a room inside one, the grid of open tabs, the run's work tab. On a +// place the strip is not drawn, so the head is the nav, the rule and a blank +// ([placeHeadRows]) and the body starts one row higher. In a chat the strip +// sits between the nav and the rule ([chatHeadRows]). +// +// THE STRIP USED TO BE DRAWN ON EVERY PAGE, including places, where it repeated +// the teams rail and home's sessions and offered a jump from a place to one +// chat that is not a journey anyone takes. `chats` on row zero, `alt+k` and +// home's sessions list are the ways between them (owner, 2026-09-25). +// +// THE PLACES AND THE STRIP USED TO SHARE ROW ONE AND TAKE TURNS ON IT. A place +// drew its bar there and a conversation drew its strip there, so the words a +// hand was reaching for changed under it on every walk (owner, 2026-09-24). +// Row zero is the places on every page. The strip, when it is drawn, is only +// the chats. // // THE TWO FRAMES SHARE ONE HEAD BECAUSE A PERSON WALKS BETWEEN THEM ALL DAY. // The conversation's head used to be two to four rows of its own with no pulse, // padded by two ladders of floors, so `esc` from home to a chat moved the strip -// up a row and took the machine's vital signs off the screen — the one line -// that says two things are waiting on you went away exactly where you were -// least likely to go and look for them (DESIGN.md's law 11). One function now -// draws the head for both, and the middle row is the only thing a frame hands -// it. +// up a row and took the machine's vital signs off the screen (DESIGN.md's law +// 11). One function draws the head for every frame. // // A ROOM WEARS THE WHOLE HEAD TOO, and its trail and facts are the first rows -// under it — the room's own heading, where a place's heading is. Inside a -// node's page they used to take the place of the rule and the blank, which put -// the rule a row lower in a room than in the conversation it opened from, and -// two rows lower in the roomy layout: walking into a task moved the one line a -// person's eye uses to find where the head ends (PLACES-AUDIT.md, lane K). +// under it, where a place's heading is (PLACES-AUDIT.md, lane K). -// headRows is the head, drawn at `width` in `pal`, with `middle` on its second -// row. It is always [placeHeadRows] rows; a frame that draws fewer — a terminal -// under the strip's floors, which draws none of it — takes a prefix of it, so -// the rows a frame draws and the rows it charges are one count. -func (a *app) headRows(width int, middle string, pal palette) []string { - // HOME'S LINE LEAVES ITS COUNTS TO THE PANELS UNDER IT, and every other - // frame's carries them (pulse.go's [pulseBudget]). - mode := pulseWhole - if a.at(pageHome) { - mode = pulseBudget +// headRows is the head, drawn at `width` in `pal`. While a conversation is in +// front, `strip` (the frame's [app.tabsRow]) is the second row and the head is +// [chatHeadRows] rows. On a place `strip` is ignored and the head is +// [placeHeadRows]: the nav, the rule, a blank. A frame that draws fewer, a +// terminal under the strip's floors, takes a prefix of it, so the rows a frame +// draws and the rows it charges are one count. +// +// THE STRIP IS HANDED IN RATHER THAN LAID OUT HERE because the conversation +// lays it out first to learn whether it has a head at all, and laying the +// strip out twice a frame would spend the scroll's allocation budget on a row +// that did not change (PERF.md's scroll law). A place does not lay it out at +// all: an undrawn strip that still owned hit spans would take a click meant +// for the page. +func (a *app) headRows(width int, strip string, pal palette) []string { + // WHILE A TEAM IS SHOWN THE RULE IS DRAWN IN ITS COLOUR, so every frame + // says the strip above it is narrowed (teams.go). On a place there is no + // strip, and the rule stays dim. + ruleInk := pal.dim + if a.stripInHead() { + if sp, ok := a.teamActive(); ok { + if ink := pal.teamInk(sp.HueSpec()); ink != nil { + ruleInk = ink + } + } } - return []string{a.pulseLine(width, pal, mode), middle, pal.dim(rule(width)), ""} + // THE NAV IS ON ROW ZERO AND THE POINTER IS TOLD SO HERE, by the one + // function every frame's head goes through: a press arrives as a row of + // the terminal, and the only honest way to know the nav is on it is to + // record it where it was drawn ([app.navPress]). + a.tabRow = navRow + nav := a.navLine(width, pal) + line := ruleInk(rule(width)) + if !a.stripInHead() { + a.chatTabHits = nil + a.wall.chip, a.wall.door = hudSpan{}, hudSpan{} + return []string{nav, line, ""} + } + return []string{nav, strip, line, ""} +} + +// stripInHead reports whether this frame draws the chat strip. A conversation +// in front does, a room inside one does, and so do the grid and the work tab, +// which are the chats with something drawn over them. A place does not, and +// neither does the teams page's hosted pane: that pane is drawn as a chat so +// its rows answer, then the place's own head is put over it (teamspagehost.go), +// and a strip in the pane would be a second strip the place does not show. +func (a *app) stripInHead() bool { + return !a.pageShowing() && !a.tp.forwarding } diff --git a/internal/tui3/head_test.go b/internal/tui3/head_test.go index edc1486a0e..c88d49564d 100644 --- a/internal/tui3/head_test.go +++ b/internal/tui3/head_test.go @@ -10,10 +10,10 @@ import ( // ── THE ONE HEAD ──────────────────────────────────────────────────────────── // -// A conversation and every place draw the same four rows at the top of the -// frame — the pulse, the strip or the bar, the rule, a blank (head.go) — so a -// person walking from home into a chat and back sees the head stay still and -// only its middle row change. +// Row zero is the same on a conversation and on every place. A conversation +// then draws the strip, the rule and a blank ([chatHeadRows]). A place draws +// the rule and a blank and no strip ([placeHeadRows]), so its body starts one +// row higher. // headSizes are the three frames the one head is pinned at: the classic // terminal, a tall one, and a wide one. @@ -40,14 +40,19 @@ func seedHeadFacts(a *app) { a.machine = machineFacts{wants: 2, hands: 1, spent: 0.14, ceiling: 20} } -// headOf is the first [placeHeadRows] rows of the frame, as a reader sees them. +// headOf is the first rows of the frame, as a reader sees them: [chatHeadRows] +// in a conversation, [placeHeadRows] on a place. func headOf(t *testing.T, a *app) []string { t.Helper() + n := placeHeadRows + if !a.pageShowing() { + n = chatHeadRows + } rows := strings.Split(frame(a), "\n") - if len(rows) < placeHeadRows { + if len(rows) < n { t.Fatalf("a %d-row frame has no room for the head", len(rows)) } - head := make([]string, placeHeadRows) + head := make([]string, n) for i := range head { head[i] = strings.TrimRight(plain(rows[i]), " ") } @@ -60,27 +65,36 @@ func headPulseWhole() string { return "2 want you · 1 moving · $0.14 / " + railFigure(20) + " · thu 9:49am" } -// THE CONVERSATION WEARS THE PLACES' HEAD, AT EVERY SIZE THE STRIP IS DRAWN. -// The pulse on row 0, the strip on the bar's row, the rule, a blank — and the -// body starts under exactly those four rows. +// THE CONVERSATION'S HEAD IS THE NAV, THE STRIP, THE RULE AND A BLANK. +// The body starts under exactly those four rows. At eighty columns the pulse +// has given up the clock, the moving count and the words of `2 want you`, whose +// count stays as `2 ?`, to keep every place on the row (topnav.go's ladder); +// wider, it says everything. func TestTheConversationWearsThePlacesHead(t *testing.T) { a := headLab(t) for _, size := range headSizes { a.width, a.height = size.w, size.h a.touch() head := headOf(t, a) - if !strings.HasPrefix(head[0], " "+plain(a.pal.wordmark(a.width))) || !strings.HasSuffix(head[0], headPulseWhole()) { - t.Fatalf("at %dx%d the chat's first row is not the pulse with its counts and budget:\n%q", size.w, size.h, head[0]) + pulse := headPulseWhole() + if size.w == 80 { + pulse = "2 ? · $0.14 / " + railFigure(20) + } + if !strings.HasPrefix(head[0], " "+plain(a.pal.wordmark(a.width))) || !strings.HasSuffix(head[0], pulse) { + t.Fatalf("at %dx%d the chat's first row is not the nav with the pulse at its end:\n%q", size.w, size.h, head[0]) + } + if !placeWordsInOrder(head[0], "home", "teams", "chats", "sessions", "spend", "settings") { + t.Fatalf("at %dx%d the chat's first row does not carry the places:\n%q", size.w, size.h, head[0]) } - if !strings.Contains(head[placeTabRow], "home") || !strings.Contains(head[placeTabRow], a.chatDisplayName()) { - t.Fatalf("at %dx%d the strip is not under the pulse:\n%q", size.w, size.h, head[placeTabRow]) + if strings.Contains(head[tabStripRow], " home ") || !strings.Contains(head[tabStripRow], a.chatDisplayName()) { + t.Fatalf("at %dx%d the strip is not under the nav, on its own:\n%q", size.w, size.h, head[tabStripRow]) } if head[2] != strings.Repeat("─", size.w) || head[3] != "" { t.Fatalf("at %dx%d the head does not close with a rule and a blank:\n%q\n%q", size.w, size.h, head[2], head[3]) } - if a.headHeight() != placeHeadRows || a.bodyTop() != placeHeadRows+a.stripHeight() { + if a.headHeight() != chatHeadRows || a.bodyTop() != chatHeadRows+a.stripHeight() { t.Fatalf("at %dx%d the head draws %d rows and is charged %d, body at %d", - size.w, size.h, placeHeadRows, a.headHeight(), a.bodyTop()) + size.w, size.h, chatHeadRows, a.headHeight(), a.bodyTop()) } if size.w == 80 && size.h == 24 || size.w == 120 { t.Logf("the chat head at %dx%d:\n%s", size.w, size.h, strings.Join(head, "\n")) @@ -94,12 +108,11 @@ func TestTheConversationWearsThePlacesHead(t *testing.T) { // (roompanel.go's [app.roomOrganized]). var headFrameSizes = []struct{ w, h int }{{80, 24}, {120, 45}, {180, 45}} -// A TASK ROOM SPENDS THE PLACES' HEAD ABOVE ITS BODY, as the conversation it -// opened from does and as every place does: the pulse, the strip, the rule and -// a blank, and the room's own trail on the first row under them — where a -// place's heading is. It used to lay the trail where the rule stands and its -// facts where the blank does, so walking into a task moved the rule down a row, -// and two in the roomy layout (PLACES-AUDIT.md, lane K). +// A TASK ROOM SPENDS THE CONVERSATION'S HEAD ABOVE ITS BODY: the nav, the +// strip, the rule and a blank, and the room's own trail on the first row under +// them. A place spends three rows and no strip, so its body starts where the +// chat's strip is. The room used to lay the trail where the rule stands +// (PLACES-AUDIT.md, lane K). func TestATaskRoomSpendsThePlacesHeadAboveItsBody(t *testing.T) { room, chat := crumbApp(t), headLab(t) for _, size := range headFrameSizes { @@ -114,9 +127,13 @@ func TestATaskRoomSpendsThePlacesHeadAboveItsBody(t *testing.T) { } f.a.touch() head := headOf(t, f.a) - if !strings.HasPrefix(head[0], " "+plain(f.a.pal.wordmark(f.a.width))) || head[2] != strings.Repeat("─", size.w) || head[3] != "" { - t.Fatalf("at %dx%d %s's head is not the pulse, a row, the rule and a blank:\n%s", - size.w, size.h, f.where, strings.Join(head, "\n")) + ruleAt := 2 + if f.to != pageNone { + ruleAt = 1 + } + if !strings.HasPrefix(head[0], " "+plain(f.a.pal.wordmark(f.a.width))) || head[ruleAt] != strings.Repeat("─", size.w) || strings.TrimSpace(head[ruleAt+1]) != "" { + t.Fatalf("at %dx%d %s's head is not the nav, then %s:\n%s", + size.w, size.h, f.where, map[bool]string{true: "the rule and a blank", false: "the strip, the rule and a blank"}[f.to != pageNone], strings.Join(head, "\n")) } if f.to != pageNone { f.a.showPage(pageNone) @@ -125,11 +142,11 @@ func TestATaskRoomSpendsThePlacesHeadAboveItsBody(t *testing.T) { // The room's heading is the first row under the head, and the rows the // frame drew there are the rows the geometry charged for. rows := strings.Split(plain(frame(room)), "\n") - if room.roomHeadRow() != placeHeadRows || !strings.Contains(rows[placeHeadRows], "Write the tree") { + if room.roomHeadRow() != chatHeadRows || !strings.Contains(rows[chatHeadRows], "Write the tree") { t.Fatalf("at %dx%d the room's trail is on row %d, not under the %d-row head:\n%q", - size.w, size.h, room.roomHeadRow(), placeHeadRows, rows[placeHeadRows]) + size.w, size.h, room.roomHeadRow(), chatHeadRows, rows[chatHeadRows]) } - if room.bodyTop() != room.headHeight()+room.stripHeight() || room.headHeight() < placeHeadRows+room.roomHeadCount() { + if room.bodyTop() != room.headHeight()+room.stripHeight() || room.headHeight() < chatHeadRows+room.roomHeadCount() { t.Fatalf("at %dx%d the room's head is charged %d rows, body at %d", size.w, size.h, room.headHeight(), room.bodyTop()) } @@ -222,8 +239,16 @@ func TestThePulseOverAChatIsThePulseOverAPlace(t *testing.T) { if place[0] != chat { t.Fatalf("the pulse over the tasks place is not the pulse over the chat:\n%q\n%q", place[0], chat) } - if !strings.Contains(place[placeTabRow], "home") || !strings.Contains(place[placeTabRow], "sessions") { - t.Fatalf("the bar is not on the strip's row: %q", place[placeTabRow]) + if !strings.Contains(place[navRow], "home") || !strings.Contains(place[navRow], "sessions") { + t.Fatalf("the nav is not on the first row: %q", place[navRow]) + } + if strings.Contains(place[tabStripRow], a.chatDisplayName()) || !strings.HasPrefix(place[1], "─") { + t.Fatalf("the tasks place drew a strip under the nav: %q", place[tabStripRow]) + } + a.showPage(pageNone) + chatHead := headOf(t, a) + if !strings.Contains(chatHead[tabStripRow], a.chatDisplayName()) { + t.Fatalf("the strip is not under the nav in the chat: %q", chatHead[tabStripRow]) } } @@ -241,41 +266,35 @@ func TestHomesPulseIsTheBudgetAndTheClock(t *testing.T) { } } -// THE STRIP AND THE BAR ANSWER THE POINTER ON THE SAME ROW, and the pulse above -// them answers nothing. A press resolved against the old head — the strip on -// row zero, or on row one only on tall terminals — would open a chat for a -// click on the pulse. -func TestTheStripAndTheBarAnswerOnTheSameRow(t *testing.T) { +// THE NAV ANSWERS ON ROW ZERO AND THE STRIP ON ROW ONE, on a chat and on a +// place alike. A press resolved against the old head, where the places and +// the strip took turns on row one, would open a chat for a click on a place. +func TestTheNavAndTheStripAnswerOnTheirOwnRows(t *testing.T) { a := headLab(t) for _, size := range headSizes { a.width, a.height = size.w, size.h a.touch() - frame(a) - home := headerHomeTarget(t, a) - if _, ok := a.tabAt(home.span.from, placeTabRow); !ok { - t.Fatalf("at %dx%d the strip does not answer on row %d", size.w, size.h, placeTabRow) + home := headerHome(t, a) + if a.tabRow != navRow { + t.Fatalf("at %dx%d the nav was drawn on row %d", size.w, size.h, a.tabRow) + } + if _, ok := a.tabAt(home.from, navRow); ok { + t.Fatalf("at %dx%d the strip answers on the nav's row", size.w, size.h) } - if cmd, took := a.tabPress(home.span.from, 0); !took || cmd != nil || a.at(pageHome) { - t.Fatalf("at %dx%d a press on the pulse leaked into the strip", size.w, size.h) + if cmd, took := a.tabPress(home.from, navRow); !took || cmd != nil || a.at(pageHome) { + t.Fatalf("at %dx%d a press on the nav leaked into the strip", size.w, size.h) } } walkTo(t, a, pageTasks) - frame(a) - if a.tabRow != placeTabRow { - t.Fatalf("the bar was drawn on row %d, the strip on row %d", a.tabRow, placeTabRow) + home := headerHome(t, a) + if a.tabRow != navRow { + t.Fatalf("the place drew its nav on row %d", a.tabRow) } - for _, span := range a.tabs { - if span.id != pageHome { - continue - } - cmd, took := a.placeTabPress(span.from, placeTabRow) - runCmd(cmd) - if !took || !a.at(pageHome) { - t.Fatal("a press on the bar's `home` did not open home") - } - return + cmd, took := a.navPress(home.from, navRow) + runCmd(cmd) + if !took || !a.at(pageHome) { + t.Fatal("a press on the nav's `home` did not open home") } - t.Fatal("the bar drew no `home`") } // INSIDE A CHAT THE COUNTS COME OFF THE PULSE'S OWN BEAT. No home is open to diff --git a/internal/tui3/header_home_test.go b/internal/tui3/header_home_test.go index 25fa978e92..927102254a 100644 --- a/internal/tui3/header_home_test.go +++ b/internal/tui3/header_home_test.go @@ -10,16 +10,18 @@ import ( "github.com/charmbracelet/x/ansi" ) -func headerHomeTarget(t *testing.T, a *app) tabHit { +// headerHome is where the nav drew `home` on the last frame: the head's first +// row, on every page (topnav.go). +func headerHome(t *testing.T, a *app) placeTabSpan { t.Helper() - _ = a.tabsRow(a.width) - for _, hit := range a.chatTabHits { - if hit.kind == tabHome { - return hit + frame(a) + for _, span := range a.tabs { + if span.id == pageHome { + return span } } - t.Fatal("Home is missing from navigation") - return tabHit{} + t.Fatal("home is missing from the nav") + return placeTabSpan{} } func TestHeaderHomePreservesBothConversationAndNewChatDrafts(t *testing.T) { @@ -30,11 +32,11 @@ func TestHeaderHomePreservesBothConversationAndNewChatDrafts(t *testing.T) { a.input.setText("existing chat draft") openStart(t, a) a.input.setText("new chat draft") - home := headerHomeTarget(t, a) - if home.span.from != tabLead { - t.Fatal("Home is not first in navigation") + home := headerHome(t, a) + if home.from != ansi.StringWidth(" "+plain(a.pal.wordmark(a.width)))+navLead { + t.Fatalf("home is not the nav's first word: %+v", home) } - cmd, took := a.tabPress(home.span.from, placeTabRow) + cmd, took := a.navPress(home.from, navRow) if !took || !a.at(pageHome) { t.Fatal("Home click did not open the home page") } @@ -52,31 +54,31 @@ func TestHeaderHomePreservesBothConversationAndNewChatDrafts(t *testing.T) { } } -// THE ROWS AROUND THE STRIP ARE THE HEAD'S AND ANSWER NOTHING. The pulse above -// it is a reading, and the rule and the blank under it are the seam; a press on -// any of the three stays where it landed rather than opening a tab. +// THE ROWS UNDER THE STRIP ARE THE HEAD'S AND ANSWER NOTHING, and neither does +// the air on the nav's row. The rule and the blank are the seam, and the cells +// between the wordmark and `home` are furniture; a press on any of them stays +// where it landed. `home` itself answers the pointer over its pads too, and a +// plain terminal shows that with the linear mark. func TestTheHeadAroundTheStripIsInertAndHomeHasPlainHover(t *testing.T) { a, _, _ := tabApp(t) a.resume = func(string) (Agent, error) { return nil, nil } a.pal = newPalette(tokens.NoColor, false) - home := headerHomeTarget(t, a) + home := headerHome(t, a) before := a.file - for _, y := range []int{0, placeTabRow + 1, placeHeadRows - 1} { - if _, ok := a.tabAt(home.span.from, y); ok { - t.Fatalf("row %d of the head advertises a button", y) + for _, at := range []struct{ x, y int }{{home.from - 1, navRow}, {home.from, tabStripRow + 1}, {home.from, placeHeadRows - 1}} { + if _, ok := a.tabAt(at.x, at.y); ok { + t.Fatalf("cell %d,%d of the head advertises a button", at.x, at.y) } - drive(t, a, tea.MouseClickMsg{X: home.span.from, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseClickMsg{X: at.x, Y: at.y, Button: tea.MouseLeft}) if a.file != before || a.at(pageHome) { - t.Fatalf("a press on row %d of the head navigated", y) + t.Fatalf("a press on cell %d,%d of the head navigated", at.x, at.y) } } - for x := home.span.from; x < home.span.to; x++ { - hot, ok := a.tabHoverAt(x, placeTabRow) - if !ok { + for x := home.from; x < home.to; x++ { + if !a.navHover(x, navRow) || a.tabHover != pageHome { t.Fatal("Home padding is not part of the target") } - a.hot = hot - if !strings.Contains(plain(a.tabsRow(a.width)), "·home ") { + if !strings.Contains(plain(a.navLine(a.width, a.pal)), "·home ") { t.Fatal("Home has no plain-terminal hover feedback") } } @@ -108,9 +110,9 @@ func TestTheStripKeepsItsActiveTabAndTheHeadItsShapeAtEverySize(t *testing.T) { if active != 1 { t.Fatalf("lost active tab at %dx%d: %q", width, height, plain(line)) } - if a.tabsHeight(width) != placeTabRow+1 || a.headHeight() != placeHeadRows { + if a.tabsHeight(width) != tabStripRow+1 || a.headHeight() != chatHeadRows { t.Fatalf("at %dx%d the head is %d rows with the strip on row %d; it is %d, strip on %d", - width, height, a.headHeight(), a.tabsHeight(width)-1, placeHeadRows, placeTabRow) + width, height, a.headHeight(), a.tabsHeight(width)-1, chatHeadRows, tabStripRow) } } } @@ -134,7 +136,7 @@ func TestPlainHeaderHoverChangesEveryActionWithoutMovingItsTarget(t *testing.T) rest := a.tabsRow(a.width) hits := append([]tabHit(nil), a.chatTabHits...) for _, hit := range hits { - hot, ok := a.tabHoverAt(hit.span.from, placeTabRow) + hot, ok := a.tabHoverAt(hit.span.from, tabStripRow) if !ok { continue } @@ -143,7 +145,7 @@ func TestPlainHeaderHoverChangesEveryActionWithoutMovingItsTarget(t *testing.T) if hovered == rest { t.Fatalf("target %v has no plain hover", hit.kind) } - after, ok := a.tabAt(hit.span.from, placeTabRow) + after, ok := a.tabAt(hit.span.from, tabStripRow) if !ok || after.span != hit.span || after.kind != hit.kind { t.Fatal("hover moved its target") } @@ -163,8 +165,8 @@ func TestHeaderAirDoesNotShrinkReadingWhenTerminalGrows(t *testing.T) { for height := airyFloor; height <= 45; height++ { a.height = height a.touch() - if pinned && a.headHeight() != placeHeadRows { - t.Fatalf("%s at %d rows the head is %d rows, not the places' %d", where, height, a.headHeight(), placeHeadRows) + if pinned && a.headHeight() != chatHeadRows { + t.Fatalf("%s at %d rows the head is %d rows, not the chat's %d", where, height, a.headHeight(), chatHeadRows) } available := height - a.headHeight() if previous > available { @@ -178,42 +180,32 @@ func TestHeaderAirDoesNotShrinkReadingWhenTerminalGrows(t *testing.T) { grows("in the conversation", true) } -// The label and its padded mouse target stay in the same cells when Home -// replaces the conversation strip, including terminals with plain hover marks. +// HOME KEEPS ITS WORD AND ITS CELLS BETWEEN A CONVERSATION AND THE DASHBOARD. +// Dev's #1424 asked it of the strip's home chip; here home is the nav's first +// word on every page (topnav.go), so the same promise is asked of the nav: +// lowercase, and its target in the same columns on both, on every profile. func TestHomeTabKeepsItsSpellingAndPositionAcrossViews(t *testing.T) { for _, profile := range []tokens.Profile{tokens.NoColor, tokens.ANSI256, tokens.TrueColor} { - for _, width := range []int{24, 40, 80, 160} { + for _, width := range []int{80, 120, 160} { t.Run(itoa(int(profile))+"/"+itoa(width), func(t *testing.T) { a := newStartLab(t).app() a.resume = func(string) (Agent, error) { t.Fatal("home must not resume a conversation"); return nil, nil } a.showPage(pageNone) a.width, a.height = width, 40 a.pal = newPalette(profile, false) - home := headerHomeTarget(t, a) - chat := plain(a.tabsRow(width)) - column := strings.Index(chat, "home") - if column != tabLead+len(tabPad) || strings.Contains(chat, "Home") { - t.Fatalf("conversation home label is misplaced or capitalized: %q", chat) - } - hot, ok := a.tabHoverAt(home.span.from, placeTabRow) - if !ok { - t.Fatal("home has no hover target") - } - a.hot = hot - hovered := plain(a.tabsRow(width)) - at := strings.Index(hovered, "home") - if at < 0 || ansi.StringWidth(hovered[:at]) != column || strings.Contains(hovered, "Home") { - t.Fatalf("hover changed home's word or position: %q", hovered) + chat := headerHome(t, a) + nav := plain(a.navLine(width, a.pal)) + if !strings.Contains(nav, " home ") || strings.Contains(nav, "Home") { + t.Fatalf("the nav's home is misspelled: %q", nav) } - cmd, took := a.tabPress(home.span.from, placeTabRow) + cmd, took := a.navPress(chat.from, navRow) if !took || !a.at(pageHome) { t.Fatal("clicking home did not open Home") } drain(t, a, cmd) - bar := plain(a.placeTabBar(width, false, a.pal)) - span := barWordSpan(t, a, pageHome) - if strings.Index(bar, "home") != column || span.from != home.span.from || span.to != home.span.to { - t.Fatalf("home moved between views: chat=%q dashboard=%q chat target=%+v dashboard target=%+v", chat, bar, home.span, span) + dash := headerHome(t, a) + if dash.from != chat.from || dash.to != chat.to { + t.Fatalf("home moved between views: chat target=%+v dashboard target=%+v", chat, dash) } }) } diff --git a/internal/tui3/helpdoors_test.go b/internal/tui3/helpdoors_test.go index c1848a2b75..acc627e31c 100644 --- a/internal/tui3/helpdoors_test.go +++ b/internal/tui3/helpdoors_test.go @@ -39,7 +39,7 @@ func TestTheKeySheetNamesTheWayToEveryPlace(t *testing.T) { // THE CHORDS ARE SPELLED THROUGH THE ONE DOOR, so a Mac sheet says opt+ and this // one does not (chords.go). mac := helpText("", chordSpelling{meta: chordMetaWord}) - if strings.Contains(mac, chordJumpWords) || !strings.Contains(mac, "opt+1…7") { + if strings.Contains(mac, chordJumpWords) || !strings.Contains(mac, "opt+1…9") { t.Errorf("the place rows are not spelled through chords.say — a Mac sheet still reads alt+:\n%s", mac) } } diff --git a/internal/tui3/helpwrap_test.go b/internal/tui3/helpwrap_test.go new file mode 100644 index 0000000000..f19b30c158 --- /dev/null +++ b/internal/tui3/helpwrap_test.go @@ -0,0 +1,71 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" +) + +// A WRAPPED /help ROW KEEPS THE COLUMN ITS SENTENCE STARTED IN. At a narrow +// width the old wrap put the rest of the sentence at column 0, which read as +// another key. The column is the leading spaces when the row already hangs, +// and otherwise the cell after the gap that pads the key. +func TestHelpWrappedLinesKeepTheirColumn(t *testing.T) { + help := helpText("", chordSpelling{meta: chordAltWord}) + for _, width := range []int{60, 80, 110} { + room := width - noteLead - workIndentCols(width) + wrapped := false + for _, line := range strings.Split(help, "\n") { + if strings.TrimSpace(line) == "" { + continue + } + col := sheetColumn(line) + pieces := wrapSheetLine(line, room) + if len(pieces) < 2 { + continue + } + wrapped = true + for i, piece := range pieces { + if i == 0 || col == 0 { + continue + } + got := 0 + for _, r := range piece { + if r != ' ' { + break + } + got++ + } + if got != col { + t.Fatalf("at %d columns a wrapped row starts at %d, want the first line's column %d:\n %q\n %q", + width, got, col, line, piece) + } + } + } + if !wrapped { + t.Fatalf("at %d columns no /help row wrapped, so the column was never checked", width) + } + + a := newTestApp(&fakeAgent{model: "m"}) + a.width, a.height = width, 80 + a.railAway = true + a.slash("/help") + var note *entry + for i := range a.entries { + if a.entries[i].kind == entryNote && strings.Contains(a.entries[i].text, "/help") { + note = &a.entries[i] + } + } + if note == nil || !note.sheet { + t.Fatal("/help did not land as a column sheet") + } + body := a.bodyWidth() + for _, row := range a.renderEntry(0, note, body) { + plainRow := plain(row) + if ansi.StringWidth(plainRow) > body { + t.Fatalf("at %d columns a /help row is wider than the column:\n%q", width, plainRow) + } + } + } +} diff --git a/internal/tui3/home.go b/internal/tui3/home.go index 9f764e3ca7..15d6f66090 100644 --- a/internal/tui3/home.go +++ b/internal/tui3/home.go @@ -2539,7 +2539,7 @@ func (a *app) homeKey(msg tea.KeyPressMsg) tea.Cmd { a.pageMsg = "" // THE ROUTER IS READ FIRST, AND IT IS ONE FUNCTION FOR EVERY PLACE // (placekeys.go). It claims the chords that mean the same thing wherever you - // are standing — alt+1…7, tab, alt+enter, alt+., the shift arrows, and `→` + // are standing, alt+1…9, tab, alt+enter, alt+., the shift arrows, and `→` // when the row has verbs — and hands everything else straight back, so this // handler keeps its right of first refusal over its own keys. if cmd, took := a.placeKey(msg); took { @@ -5230,16 +5230,37 @@ func homeGlyph(row session.SessionRow, ascii bool) string { return homeIdleGlyph } -// homeName is what a conversation is CALLED on this surface's lists, through -// [listName]: the title it gave itself, then the folder it lives in when that -// folder reads as words, and then — rather than the id it usually is — the -// plain word for a conversation nothing has named yet. +// homeName is what a conversation is CALLED on this surface's lists: home's +// sessions rows and the sessions place, through one rule. // -// IT NEVER HAD THE PICKER'S MIDDLE RUNG. [humanName] can fall back to the first -// thing the person said because the resume picker has read the transcript; a -// [session.SessionRow] carries no opening line, so this call passed a title and -// a path and got a title-cased hex id whenever the title was empty. +// A TITLE THAT IS ONLY THE SESSION'S ID IS NOT A NAME. The id arrives as the +// raw folder stem, or already title-cased (`D53cceead3f99593` for +// `d53cceead3f99593`), because [listName] raises the first letter of a stem +// that happens to read as letters. EqualFold is the comparison that catches +// both. The word is returned as itself, so a later pass that stored it back +// onto the row does not title-case it into `New Conversation`. +// +// A TITLELESS ROW KEEPS [listName]'s ladder. A brand new launch has no title +// yet; calling every empty title the word put that launch on home as a saved +// chat. The sessions place fills an empty title with this function and then +// asks again, so a stem that came back as the id is caught on that second pass. func homeName(row session.SessionRow) string { + title := strings.TrimSpace(row.Title) + // A launch nobody has spoken in is not a saved chat. Open is not enough: + // the window sitting in that shell marks it in use. A live row, or one + // someone has spoken in, is the chat the sessions list and the sessions + // place both call by the word. + spoken := !row.At.IsZero() || row.Live + if !spoken { + return listName(row.Title, row.Transcript) + } + if strings.EqualFold(title, unnamedConversationWord) { + return unnamedConversationWord + } + id := strings.TrimSpace(row.ID) + if id != "" && title != "" && strings.EqualFold(title, id) { + return unnamedConversationWord + } return listName(row.Title, row.Transcript) } diff --git a/internal/tui3/home_test.go b/internal/tui3/home_test.go index ab434cca77..6da7868872 100644 --- a/internal/tui3/home_test.go +++ b/internal/tui3/home_test.go @@ -257,6 +257,17 @@ func homeText(a *app) string { return ansi.Strip(strings.Join(lines, "\n")) } +// homeBodyText is [homeText] under the head. THE STRIP OF CHATS IS ON EVERY +// PAGE (head.go), so a conversation's name stands on it over home as well as +// on home's own rows, and a test about what home's rows list reads these. +func homeBodyText(a *app) string { + lines := strings.Split(homeText(a), "\n") + if len(lines) > placeHeadRows { + lines = lines[placeHeadRows:] + } + return strings.Join(lines, "\n") +} + // homeCardNow is the detail column exactly as it stands, without moving the // cursor and without widening anything. // @@ -651,7 +662,7 @@ func TestTypingFiltersLiveWhileTheActionRowStaysTheDefault(t *testing.T) { for _, r := range "pricing" { a.homeKey(key(string(r))) } - text := homeText(a) + text := homeBodyText(a) if !strings.Contains(text, "Pricing Research") { t.Fatalf("the query lost the conversation it should have found:\n%s", text) } @@ -1391,7 +1402,7 @@ func TestAQueryMatchesWhatATaskCameTo(t *testing.T) { for _, r := range "postgres" { a.homeKey(key(string(r))) } - text := homeText(a) + text := homeBodyText(a) if !strings.Contains(text, "Wednesday") { t.Fatalf("a query over what the work came to found nothing:\n%s", text) } @@ -1602,7 +1613,7 @@ func TestHomeMarksARowWhoseFolderIsGoneWhereverItsAddressIsDrawn(t *testing.T) { a.openHome() // AT REST: THE ROW'S OWN MARGIN. - for _, line := range strings.Split(homeText(a), "\n") { + for _, line := range strings.Split(homeBodyText(a), "\n") { if strings.Contains(line, "A Project That Moved") && !strings.Contains(line, homeGoneShort) { t.Fatalf("the resting row does not say %q:\n%s", homeGoneShort, homeText(a)) } diff --git a/internal/tui3/homeband_answer_test.go b/internal/tui3/homeband_answer_test.go index 5772e0c879..ba6191743e 100644 --- a/internal/tui3/homeband_answer_test.go +++ b/internal/tui3/homeband_answer_test.go @@ -326,10 +326,9 @@ func TestHomeAnswersItsOwnWindowThroughItsOwnResolver(t *testing.T) { // SAYING NO FROM HOME, IN ONE KEYSTROKE. // // The standing card is the one question whose no lives on a key home cannot -// spare: `esc` in the conversation is the outright no, and `esc` on home closes -// home. So the engine's list carries `0 not set up` and this band draws it like -// any other chip — a card met at home can now be answered all three ways -// without walking to the window it is in. +// spare: `esc` on home closes home. The engine's list carries the kind's own +// no, and this band draws it like any other chip. A card met at home can be +// answered all three ways without walking to the window it is in. func TestHomeCanSayNoToAStandingCard(t *testing.T) { watch := standing.Item{ Words: "tell me when ci goes red", @@ -338,7 +337,7 @@ func TestHomeCanSayNoToAStandingCard(t *testing.T) { } lab := newAnswerLab(t, standingQuestion(9, watch, "wants to keep an eye on: tell me when ci goes red"), time.Now()) text := homeText(lab.a) - for _, chip := range []string{"1 yes", "3 just once", "0 not set up"} { + for _, chip := range []string{"1 Watch for it", "3 Check once now", "0 Don't watch"} { if !strings.Contains(text, chip) { t.Fatalf("the card does not offer %q:\n%s", chip, text) } @@ -357,7 +356,7 @@ func TestHomeCanSayNoToAStandingCard(t *testing.T) { if typed := lab.a.home.box.String(); typed != "" { t.Fatalf("the decline also typed %q into the box", typed) } - if !strings.Contains(homeText(lab.a), answerSentWord+"not set up") { + if !strings.Contains(homeText(lab.a), answerSentWord+"Don't watch") { t.Fatalf("home did not say what it just answered:\n%s", homeText(lab.a)) } } @@ -373,10 +372,10 @@ func TestHomeCanSayNoToAReminderThatOffersNoOnce(t *testing.T) { } lab := newAnswerLab(t, standingQuestion(9, reminder, "wants to keep an eye on: remind me at 6 to leave"), time.Now()) text := homeText(lab.a) - if strings.Contains(text, "3 just once") { + if strings.Contains(text, "Check once now") || strings.Contains(text, "Only now") { t.Fatalf("a one-off reminder was offered `once` from home:\n%s", text) } - if !strings.Contains(text, "0 not set up") { + if !strings.Contains(text, "0 Don't remind me") { t.Fatalf("a one-off reminder was offered no way to say no:\n%s", text) } lab.a.homeKey(key(session.StandingNoKey)) diff --git a/internal/tui3/homebridge_test.go b/internal/tui3/homebridge_test.go index fa8e9911fd..20df7d8673 100644 --- a/internal/tui3/homebridge_test.go +++ b/internal/tui3/homebridge_test.go @@ -224,7 +224,16 @@ func TestEnterOnTheBarOpensThePlaceUnderTheCursor(t *testing.T) { if !a.bar.on { t.Fatal("the bar did not rise") } - // One word along the bar, which opens nothing by itself... + // Three words along the bar, past teams and the way back to the chats, + // which opens nothing by itself... + drive(t, a, key("right")) + if a.bar.at != pageTeams { + t.Fatalf("→ landed the bar cursor on %q, want teams", a.bar.at.word()) + } + drive(t, a, key("right")) + if a.bar.at != pageChats { + t.Fatalf("→ landed the bar cursor on %q, want chats", a.bar.at.word()) + } drive(t, a, key("right")) if !a.at(pageHome) { t.Fatalf("walking the bar opened %q by itself", a.page.word()) diff --git a/internal/tui3/homeexchange.go b/internal/tui3/homeexchange.go index cbd178fe64..db8fdb5bb9 100644 --- a/internal/tui3/homeexchange.go +++ b/internal/tui3/homeexchange.go @@ -693,7 +693,7 @@ func (a *app) answerExchangeCard(ex *homeExchange, notice *session.StandingNotic func (a *app) changeExchangeCard(ex *homeExchange, notice *session.StandingNotice, words string) tea.Cmd { ex.box.reset() ex.changing = false - ex.settle(standChangedWord, standChangeWord) + ex.settle(standChangedWord, session.StandingChangeWord(ex.view.item)) ex.rows = append(ex.rows, exchangeRow{kind: exchangeSaid, text: words}) ex.said = a.now() // THE CORRECTION IS A TURN LIKE ANY OTHER from the pane's point of view: the @@ -2195,7 +2195,7 @@ func exchangeHint(ex *homeExchange) string { // `change when or where`, which the card itself says on the row it // settles into; here it is the one word every question spells it with. if verb, ok := questionVerbFor(questionCommentKey); ok { - parts = append(parts, verb.key+" "+verb.word) + parts = append(parts, verb.key+" "+questionVerbWord(*ex.ask, verb)) } } } diff --git a/internal/tui3/homeexchange_test.go b/internal/tui3/homeexchange_test.go index 850fdfd7c3..1668a3d712 100644 --- a/internal/tui3/homeexchange_test.go +++ b/internal/tui3/homeexchange_test.go @@ -380,7 +380,7 @@ func TestTheCardInThePaneIsAnsweredWithOne(t *testing.T) { drive(t, a, key("up"), key("enter")) frame := homeText(a) - for _, want := range []string{"remind me at 6 to leave", "at 6 today", "about $0.02, once", "1 yes, set it up"} { + for _, want := range []string{"remind me at 6 to leave", "at 6 today", "about $0.02, once", "1 Remind me"} { if !strings.Contains(frame, want) { t.Fatalf("the card does not say %q:\n%s", want, frame) } @@ -452,10 +452,10 @@ func TestTheErrandHintNamesOnlyTheAnswersTheCardDrew(t *testing.T) { // A one-off reminder. "Do it once, now" says the wrong thing at the // wrong moment for a line that was meant for six o'clock, so the card // draws two numbered chips and the hint may name two digits. - {"a one-off reminder", standReminder(), "1 yes, set it up · 0 no · o other", 2}, - // A watch is a thing a person may reasonably want done once, now — the - // third answer is drawn, so the third digit is named. - {"a watch", standItem(), "1 yes, set it up · 3 just once · 0 no · o other", 3}, + {"a one-off reminder", standReminder(), "1 Remind me in 1 minute — 07:35 · 0 Don't remind me · o Change…", 2}, + // A repeating check is a thing a person may reasonably want done once, now. + // The third answer is drawn, so the third digit is named. + {"a repeating check", standItem(), "1 Set it up · Mondays at 9am · 3 Only now, don't repeat · 0 Don't set it up · o Change…", 3}, } { lab := newErrandLab(t) mine := lab.session("-tmp-alpha", "aaaa000000000001", "pricing research", "/tmp/alpha", time.Now()) @@ -516,8 +516,8 @@ func TestTheErrandHintNamesOnlyTheAnswersTheCardDrew(t *testing.T) { // that hands the keyboard back to the list, and a card left standing on the // column is not an answer — so a person who asked for a reminder from home and // then thought better of it had nothing to press. The decline is the engine's -// own `0 not set up` ([session.StandingNoKey]), which is the same key on this -// pane, on home's answer band and in the conversation. +// own `0` ([session.StandingNoKey]), in the kind's own words, which is the same +// key on this pane, on home's answer band and in the conversation. func TestTheCardInThePaneIsDeclinedWithZero(t *testing.T) { lab := newErrandLab(t) mine := lab.session("-tmp-alpha", "aaaa000000000001", "pricing research", "/tmp/alpha", time.Now()) @@ -535,7 +535,7 @@ func TestTheCardInThePaneIsDeclinedWithZero(t *testing.T) { // THE HINT NAMES IT, because this is the only way out of the question that // answers it. - if frame := homeText(a); !strings.Contains(frame, "0 no") { + if frame := homeText(a); !strings.Contains(frame, "0 Don't remind me") { t.Fatalf("the pane does not name the decline:\n%s", frame) } drive(t, a, key(session.StandingNoKey)) @@ -1623,7 +1623,7 @@ func TestANarrowWindowStacksTheExchangeOverTheList(t *testing.T) { if _, ok := a.homeStacked(); !ok { t.Fatal("a narrow frame did not stack the exchange over the list") } - frame := homeText(a) + frame := homeBodyText(a) if !strings.Contains(frame, homeAskHereWord) || !strings.Contains(frame, "› remind me at 6 to leave") { t.Fatalf("the stacked pane is not on the screen:\n%s", frame) } diff --git a/internal/tui3/homepanel_sessions_test.go b/internal/tui3/homepanel_sessions_test.go index 965ea0dd2e..f541bd9778 100644 --- a/internal/tui3/homepanel_sessions_test.go +++ b/internal/tui3/homepanel_sessions_test.go @@ -9,6 +9,45 @@ import ( "github.com/Agent-Field/codeaf/internal/session" ) +// An untitled chat on home used to read as its session id with the first +// letter raised (`D53cceead3f99593`). The sessions place already calls that +// row `new conversation`. Home reads the name from the same [homeName]. +func TestHomeSessionsCallsAnUntitledChatNewConversation(t *testing.T) { + now := time.Date(2026, 9, 21, 12, 0, 0, 0, time.UTC) + id := "d53cceead3f99593" + transcript := "/chat/" + id + "/transcript.jsonl" + titled := session.SessionRow{ + ID: "927d303242f9d00e", Transcript: "/chat/927d303242f9d00e/transcript.jsonl", + Title: "Porting the Picker", At: now.Add(-time.Hour), + } + for _, title := range []string{id, "D53cceead3f99593"} { + row := session.SessionRow{ID: id, Transcript: transcript, Title: title, At: now, Live: true} + in := homeGridInput{now: now, rows: []switcherRow{ + {kind: switcherConversation, session: row, title: homeName(row)}, + {kind: switcherConversation, session: titled, title: homeName(titled)}, + }} + got := (sessionsPanel{homePanelBase{panelSessions}}).rows(&in) + var untitledTitle, titledTitle string + for _, line := range got.lines { + if line.cell == nil { + continue + } + switch line.row.ID { + case id: + untitledTitle = line.cell.title + case titled.ID: + titledTitle = line.cell.title + } + } + if untitledTitle != unnamedConversationWord { + t.Fatalf("title %q reads %q, want %q", title, untitledTitle, unnamedConversationWord) + } + if titledTitle != "Porting the Picker" { + t.Fatalf("a titled chat reads %q", titledTitle) + } + } +} + func TestHomeSessionsShowsFifteenMostRecentConversations(t *testing.T) { now := time.Date(2026, 9, 21, 12, 0, 0, 0, time.UTC) in := homeGridInput{now: now} diff --git a/internal/tui3/homepanel_test.go b/internal/tui3/homepanel_test.go index fa103d8a63..e4d7424a7e 100644 --- a/internal/tui3/homepanel_test.go +++ b/internal/tui3/homepanel_test.go @@ -135,8 +135,11 @@ func TestWhereYouWereLeadsWithThisWindowsOwnConversation(t *testing.T) { if quiet := lines[own+3]; !strings.Contains(quiet, "Quiet Chat a") { t.Fatalf("the quiet rows do not follow in recency order:\n%s", frame) } - // AND THE TWO ROWS THAT ARE ON OTHER PANELS ARE NOT HERE A SECOND TIME. - if strings.Count(frame, "Swarm Task Splitting") != 1 || strings.Count(frame, "Bounty Reward Companies") > 1 { + // AND THE TWO ROWS THAT ARE ON OTHER PANELS ARE NOT HERE A SECOND TIME. The + // head is not counted: the strip of chats over home carries the tabs this + // window has open, which is a different list from home's panels. + body := strings.Join(lines[placeHeadRows:], "\n") + if strings.Count(body, "Swarm Task Splitting") != 1 || strings.Count(body, "Bounty Reward Companies") > 1 { t.Fatalf("a conversation is drawn on two panels:\n%s", frame) } } diff --git a/internal/tui3/homeslash.go b/internal/tui3/homeslash.go index aeff45f401..12a32ccbcb 100644 --- a/internal/tui3/homeslash.go +++ b/internal/tui3/homeslash.go @@ -188,7 +188,7 @@ func homeFate(word, rest string) string { // /project IS THE PIN AND /folder IS NOT, since 2026-09-22 // (projectcmd.go says what the two used to share). return fateTargetFolder - case "settings", "search", "spend", "history", "home": + case "settings", "search", "spend", "history", "home", "wall", "teams": return fatePlace case "resume": return fateResume diff --git a/internal/tui3/host.go b/internal/tui3/host.go index 8b8209a56f..6de13ad331 100644 --- a/internal/tui3/host.go +++ b/internal/tui3/host.go @@ -64,16 +64,31 @@ import ( // waits on a loopback port, and the browser is here while the // port is there. See [app.hostedBrowserSignIn] for why that is // the exact line. +// teams and a team's manager +// WORK, against the FAR machine's store. The teams file and +// each team's Traffic live in the profile of the machine the +// SESSION runs on, because its team tools write them there, +// and the door hands a seam that reads and writes those over +// the wire (teamseam.go, internal/remote's wire_teams.go): +// the rail is the team's own log, a manager made here is the +// one the far session follows, and this machine's teams.json +// is never read or written. An engine from before those +// doors (its welcome has no Teams) gets no seam, and then +// the writes, `+ Manager`, the switcher's row and the Teams +// popover's row say [teamHostedWord] and do nothing, and +// there is no Traffic rail and no clock, rather than a list +// kept here that the far session would never see. // a key sign-in WORKS, unchanged. The person pastes a secret into a box on // this screen and it travels on the wire like every other // answer; nothing about it needs a browser or a port. -// /settings says [settingsRemoteWord] as it opens, and opens anyway. -// Half these rows are this surface's own (the mouse, the -// timestamps, the draft) and genuinely apply; the other half -// govern the SESSION, which reads them from the far machine's -// profile. A panel that closed itself would take working rows -// away; one that said nothing would let a person turn a gate -// off and watch it stay on. +// /settings says [settingsHostNote] as it opens, and again when the +// tab changes whose disk the rows are, and opens anyway. +// Every tab but Teams writes this machine. The Teams tab +// writes the far machine when the seam can take the change, +// and the note on that tab says only that. A panel that +// closed itself would take working rows away; one that said +// nothing would let a person turn a gate off and watch it +// stay on. // the always key the consent card's "always" writes nothing (the door hands // no save seams over a connection), so the row says "allowed" // rather than "saved" — which is the truth: the answer holds @@ -373,12 +388,39 @@ const ( // row and shares it with nothing. It says WHAT and leaves the why to the // command, which is the trade every row in a frame makes. connectAskRemoteWord = "connecting an account is not available over --host yet" - // settingsRemoteWord opens the panel on a remote session. - settingsRemoteWord = "these rows and changes belong to this machine — this conversation reads its profile on the other one" // exportHereWord follows the path a remote session's /export landed on. exportHereWord = " · on this machine" + // settingsLocalWord is /settings over a connection, on every tab but Teams, + // when the Teams tab can be saved on the far machine. The rows on show are + // this machine's. The second sentence is the one tab that is not. + settingsLocalWord = "these rows belong to this machine; the Teams tab is saved on the other one." + // settingsLocalUnreadWord is the same opening when the Teams tab cannot be + // written over this connection. It does not claim that tab is saved there. + settingsLocalUnreadWord = "these rows belong to this machine; this conversation reads its profile on the other one." ) +// settingsHostNote is the sentence /settings says over a connection. onTeams +// is the tab on show. savedThere means the seam can write that machine's +// teams defaults. shownThere means those defaults have been read and are what +// the tab is drawing, even when the write is refused. +// +// THE TEAMS TAB SAYS ONLY WHAT IS TRUE THERE. The other tabs write this +// machine, and they name the Teams tab as the exception when that exception +// is real. A note that said "these rows belong to this machine" on the Teams +// tab would be the panel lying about the disk it just wrote. +func settingsHostNote(onTeams bool, host string, savedThere, shownThere bool) string { + if onTeams && host != "" && savedThere { + return "these rows are saved on " + host + "." + } + if onTeams && host != "" && shownThere { + return "these rows are on " + host + ". changing them is not available over this connection." + } + if savedThere { + return settingsLocalWord + } + return settingsLocalUnreadWord +} + // remoteProfileWord is the honest floor for commands whose setting or store // belongs to the session's machine but has no wire door yet. The machine is // named because "another machine" makes a destructive refusal needlessly @@ -420,9 +462,10 @@ func (a *app) remoteProfileWord(thing string) string { // spend THE FAR MACHINE'S, through Places.Ledger and a held cache. // search THE FAR MACHINE'S, one call from the search command's goroutine. // memory THE FAR MACHINE'S, all seven readings and writes together. -// settings SPLIT, AND CORRECTLY: half its rows are this surface's own and -// half are read from the far machine's profile, which is what -// [settingsRemoteWord] says as it opens. +// settings SPLIT, AND CORRECTLY: every tab but Teams writes this machine. +// The Teams tab writes the far machine when the seam can take the +// change, which is what [settingsHostNote] says, for the tab on +// show. // // A PLACE THAT HAS NOT LEARNED SAYS SO, in one dim line where its rows would be // ([place.remote], pages.go). The sentence is the place's own because the noun in @@ -433,9 +476,9 @@ func (a *app) remoteProfileWord(thing string) string { // CLAUDE.md states about the manual said about the code. // // AND THE FRAME SAYS WHOSE MACHINE IT IS. A room whose rows quietly changed which -// disk they describe would be the same fault walked backwards, so the tab bar -// carries the machine's name at its right end and nothing at all on a local -// session ([app.placeBarMachine]). It is [app.host], the same field the status +// disk they describe would be the same fault walked backwards, so the nav +// carries the machine's name at its far end and nothing at all on a local +// session (topnav.go's [app.navTails]). It is [app.host], the same field the status // line's place segment, /status and the legend under the input all read, because // the connection is shown as the place and is shown nowhere else. const ( diff --git a/internal/tui3/hover.go b/internal/tui3/hover.go index 9ffb5a2236..fae2d93595 100644 --- a/internal/tui3/hover.go +++ b/internal/tui3/hover.go @@ -128,13 +128,12 @@ const ( // NODE's (task.go). Every row of that column is a door into a node's room, so // every row of it reacts — which is this file's own law read the other way // round: the set that lights is the set [app.press] acts on, and in the - // roster that is all of it. What the hover buys beyond the background step is - // the disclosure triangle a family root reveals in its glyph cell — and that - // cell is a fold ONLY on the frames where the triangle is drawn in it, which - // is this law read strictly: the press reads the span the layout recorded - // (task.go's [app.railLead]), so a state cell nobody is pointing at is the - // row's, and the row is the node's door. + // roster that is all of it. hoverRail + // hoverRailGroup is a folding group's heading in the roster (`Done 7 ▸`), + // index its group. The whole row lights because a press anywhere on it + // opens the group or folds it. + hoverRailGroup // hoverRailArea is the roster's non-node space. The rail remains one // pointer target even between rows, because its footer offer follows the // hand across the whole column. @@ -149,11 +148,6 @@ const ( // there to be an area of: everything that asks about the rail's rows would // answer about a column that is not on the frame. hoverRailGrip - // hoverRailDoor is the STANDING column's own door — the footer line carrying - // the `❯` and `ctrl+g hide` (task.go's [railStowHint]). It is the other half - // of [hoverRailGrip]: one control in two states, so the right edge lights the - // same way whether the column is up or away. - hoverRailDoor // hoverMarginDoor is one of the margin's two `+` rows, held by the SLASH WORD // it types (margin.go): there are two of them and they type two different // things, so the word is what tells them apart — and it is what the paint @@ -166,12 +160,12 @@ const ( hoverMarginStand // hoverRailMore is the footer's OTHER door — the one line that leaves the // column for the task page (taskview.go's [taskSheetPastHint]). It is a kind - // of its own for [hoverRailDoor]'s reason: it belongs to no node, and it does - // something different from every other line of the footer. + // of its own because it belongs to no node, and it does something different + // from every other line of the footer. hoverRailMore // hoverRailStanding is the footer's standing count — `◦ 2 standing orders`, // a door onto /standing (standdoor.go). It is a kind of its own for - // [hoverRailDoor]'s reason and one more: it was a segment of the status row + // [hoverRailMore]'s reason and one more: it was a segment of the status row // until 2026-09-09, and what lights has to be what the press acts on // wherever the line is drawn. hoverRailStanding @@ -315,6 +309,24 @@ const ( // the person's own notes, and a paragraph that brightened would be // promising a door on every sentence of it. hoverQuestionOption + // hoverDockLabel is the dock's door, `▦ All`, glyph and word as one + // button, and hoverDockWall the `▦` alone on a row too narrow for the + // word (walldock.go). Either lights the whole door. hoverDockCell is + // one conversation's cell after them, held by the conversation's key + // rather than by its column (walldock.go): the dock narrows as the keys + // beside it change, and a hover stored as a column would follow the + // packing instead of the conversation. + hoverDockLabel + hoverDockWall + hoverDockCell + // hoverSide is one of the side column's own rows or doors (sidecol.go): + // key is the row's identity and index the door on it, -1 for the row as a + // whole. A row is held by its key and not by its place because the band + // and the Traffic re-lay as things arrive. + hoverSide + // hoverThread is a line of a thread card in the conversation, held by its + // entry and the message it shows (teamthreadcard.go). + hoverThread ) // hoverAt is what the pointer is over, as an identity rather than as a screen @@ -468,12 +480,10 @@ func (a *app) hoverTarget(x, y int) hoverAt { if a.railSeamAt(x, y) { return hoverAt{kind: hoverRailSeam} } - // AND THE STANDING COLUMN'S OWN DOOR, which is asked before the rows for the - // reason the seam is: it is a line of the footer and belongs to no node, so a - // question about which node is under the pointer would answer about the empty - // space beside it (task.go's [app.railDoorAt]). - if a.railDoorAt(x, y) { - return hoverAt{kind: hoverRailDoor} + // THE SIDE COLUMN'S OWN ROWS AND DOORS, before the roster's nodes: its + // header, its band, its Traffic, and a group's heading (sidecol.go). + if at, ok := a.sideHoverAt(x, y); ok { + return at } // AND THE FOOTER'S STANDING COUNT, on exactly those terms: it is a line of // the footer, it belongs to no node, and it answers to a click @@ -527,8 +537,8 @@ func (a *app) hoverTarget(x, y int) hoverAt { // before it: the prose it sits in has no gesture of its own, and a paragraph // that lit as a whole would promise a door on every word of it (markdown.go's // [linkifyTasks]). - if at := a.linkHoverAt(x, r); at >= 0 { - return hoverAt{kind: hoverLink, entry: r.entry, index: at} + if at, key := a.linkHoverAt(x, r); at >= 0 { + return hoverAt{kind: hoverLink, entry: r.entry, index: at, key: key} } switch { case r.foot.span.holds(x): @@ -553,6 +563,8 @@ func (a *app) hoverTarget(x, y int) hoverAt { return hoverAt{kind: hoverPictures, entry: r.entry, index: r.pictureIndex} case r.hit == hitBrief: return hoverAt{kind: hoverBrief, entry: r.entry} + case r.hit == hitThread: + return hoverAt{kind: hoverThread, entry: r.entry, key: r.open} case r.hit == hitTool, r.hit == hitMore, r.hit == hitTask, r.hit == hitDone, r.hit == hitHarness: // THE ONES THAT WERE MISSING FROM THIS LIST, and every one of them is @@ -602,6 +614,14 @@ func (a *app) hoverTarget(x, y int) hoverAt { return hoverAt{kind: hoverPaste, index: n} } case chromeOverlay: + // THE @ LIST'S PREFIX WORDS ARE COLUMNS OF ITS FIRST ROW. A press on + // "team" is not a press on the row, so the word rides the key + // (mention.go). + if a.comp.open && !a.comp.arg && a.comp.top == 0 && mark.index == 0 { + if word, ok := mentionHeadAt(x); ok { + return hoverAt{kind: hoverOverlay, index: mark.index, key: word} + } + } // EVERY LIST DOWN HERE IS ROWS, AND THE FOLDER SHEET IS COLUMNS. Its // three columns do three different things to a press — walk out, move // the cursor, walk in — so a band across the row would offer to do one @@ -678,9 +698,14 @@ func (a *app) hoverTarget(x, y int) hoverAt { if a.seamProjectSpan.holds(x) { return hoverAt{kind: hoverSeamProject} } - // THE LAST ROW IS THE KEYS and lights nothing: the home door on it - // answers through its own reading (home.go's [app.homeDoorPress]), - // and the numbers' doors are on the seam (footswap.go). + // THE LAST ROW IS THE KEYS and lights nothing but the dock beside + // its right end, whose cells were recorded where the row drew them + // (walldock.go): the home door on it answers through its own + // reading (home.go's [app.homeDoorPress]), and the numbers' doors + // are on the seam (footswap.go). + if at, ok := a.dockAt(x); ok && !a.wall.on && !a.rew.on { + return at + } } } return hoverAt{} @@ -701,6 +726,18 @@ func (a *app) markStale(i int) { // longer exists is a highlight on somebody else's row. func (a *app) dropHover() { a.hot = hoverAt{} } +// dropResizeHover forgets hover that pointed at a door the new layout may +// not draw. [app.dropHover] covers the body. The nav's own hover is separate: +// [app.tabHover] is the place word, and [navMore.hot] is `more ▾`. Both feed +// the hint line ([app.headHint]), which does not ask whether the last frame +// still drew the door. +func (a *app) dropResizeHover() { + a.dropHover() + a.barHover(pageNone) + a.navMoreHot(false) + a.navMore.hover = -1 +} + // The four questions the renderers ask. // hoveringEntry reports whether the pointer is on this entry's rows. @@ -740,7 +777,7 @@ func (a *app) hoveringRailMore() bool { return a.hot.kind == hoverRailMore } // hoveringRailArea reports whether the pointer is anywhere over the roster. func (a *app) hoveringRailArea() bool { switch a.hot.kind { - case hoverRail, hoverRailArea, hoverRailSeam, hoverRailMore, hoverRailStanding: + case hoverRail, hoverRailArea, hoverRailSeam, hoverRailMore, hoverRailStanding, hoverSide, hoverRailGroup: return true } return false @@ -752,10 +789,6 @@ func (a *app) hoveringRailSeam() bool { return a.hot.kind == hoverRailSeam } // hoveringRailGrip reports whether the pointer is over the closed column's edge. func (a *app) hoveringRailGrip() bool { return a.hot.kind == hoverRailGrip } -// hoveringRailDoor reports whether the pointer is over the standing column's own -// door line, which is the same control in its other state. -func (a *app) hoveringRailDoor() bool { return a.hot.kind == hoverRailDoor } - // hoveringStatusModel reports whether the pointer is on the status row's model // segment (render.go's [app.paintIdentity] is what it changes). func (a *app) hoveringStatusModel() bool { return a.hot.kind == hoverStatusModel } diff --git a/internal/tui3/hoverpressable_test.go b/internal/tui3/hoverpressable_test.go index 798794e0f4..89725518da 100644 --- a/internal/tui3/hoverpressable_test.go +++ b/internal/tui3/hoverpressable_test.go @@ -303,6 +303,10 @@ func TestTheTaskRecordCardLightsTheEdgeUnderThePointer(t *testing.T) { if !a.taskSheet.detailOn { t.Fatal("enter did not go inside the card") } + // THE POINTER RESOLVES AGAINST THE LAST FRAME, and the program draws one + // between the key and the next motion. The card draws no nav, so its first + // row is the card's own title, not the nav's. + frame(a) drive(t, a, motionTo(2, 0)) if !a.hoveringTaskCard(int(taskCardHitHead)) { diff --git a/internal/tui3/input.go b/internal/tui3/input.go index ce7d70a19e..5064cdfd8a 100644 --- a/internal/tui3/input.go +++ b/internal/tui3/input.go @@ -359,6 +359,31 @@ func (a *app) key(msg tea.KeyPressMsg) tea.Cmd { } return cmd } + // A key ends an opened tile's zoom, so what it types is drawn whole. + a.wallZoomDone() + // The team switcher is a menu, and a menu has the keyboard while it is up + // (teammenu.go). + if a.teamMenu.on && !door { + return a.teamMenuKey(msg) + } + // And so does the nav's fold menu (navmore.go). + if a.navMore.on && !door { + return a.navMoreKey(msg) + } + // The move picker, over everything, and then a team's card have the + // keyboard while they are up (teammove.go, teamsheet.go). + if a.tmove.on && !door { + return a.teamMoveKey(msg) + } + if a.tsheet.on && !door { + return a.teamSheetKey(msg) + } + if a.wall.on && !door { + return a.wallKey(msg) + } + if !door && wallOpenPressed(msg) { + return a.openWall() + } if a.workTabOn { return a.workTabKey(msg) } @@ -462,7 +487,7 @@ func (a *app) key(msg tea.KeyPressMsg) tea.Cmd { // five (pages.go). Each of the seven takes the whole frame, so there is // nothing under it a key could mean anything to — and the six classes of the // grammar are read before the place's own keys, on every place, which is what - // makes `tab`, `alt+1…7` and `→` mean one thing wherever a person is standing + // makes `tab`, `alt+1…9` and `→` mean one thing wherever a person is standing // ([app.placeKeyPress]). // // IT USED TO BE FIVE ARMS AT THREE DIFFERENT RUNGS. The settings panel and @@ -766,7 +791,7 @@ func (a *app) key(msg tea.KeyPressMsg) tea.Cmd { return cmd } - // AND alt+1…7 IS READ HERE, ON THE CONVERSATION'S ROAD. It is the one class + // AND alt+1…9 IS READ HERE, ON THE CONVERSATION'S ROAD. It is the one class // of the place grammar that belongs to no place — it is how a person GETS to // a room — and every claim above has already had its say, so a modal overlay // that wants the chord still gets it first and nothing below has taken a diff --git a/internal/tui3/keeper.go b/internal/tui3/keeper.go index 44c35f5890..7c90119d68 100644 --- a/internal/tui3/keeper.go +++ b/internal/tui3/keeper.go @@ -1068,7 +1068,11 @@ func (a *app) startBeside(workspace string) (tea.Cmd, string) { if err != nil { return nil, err.Error() } - return a.takeBeside(conv), "" + cmd := a.takeBeside(conv) + // A conversation started while a team is shown is one of that team + // (teams.go's [app.teamJoinFront]). + a.teamJoinFront() + return cmd, "" } // takeBeside is the two lines both doors above end in: the conversation on diff --git a/internal/tui3/managercolumn_test.go b/internal/tui3/managercolumn_test.go new file mode 100644 index 0000000000..949a531fcc --- /dev/null +++ b/internal/tui3/managercolumn_test.go @@ -0,0 +1,170 @@ +package tui3 + +import ( + "fmt" + "strings" + "testing" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// managerColumnApp is the manager in front on a wide frame, with the column +// remembered open. +func managerColumnApp(t *testing.T) *app { + t.Helper() + a, _, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.railAway = false + a.welcome.open = false + if a.sideKind() != sideKindManager { + t.Fatal("the manager is not in front") + } + return a +} + +// managerTasks gives the manager n running tasks of its own. +func managerTasks(a *app, n int) { + if a.tasks == nil { + a.tasks = map[uint64]*taskNode{} + } + for i := 1; i <= n; i++ { + id := uint64(900 + i) + a.tasks[id] = &taskNode{id: id, title: fmt.Sprintf("Task %d", i), label: fmt.Sprintf("Task %d", i), state: session.TaskRunning} + a.taskOrder = append(a.taskOrder, id) + } + a.touch() +} + +// sideWordAt is the screen cell of the header's word that brings view to the +// front. +func sideWordAt(t *testing.T, a *app, view int) (int, int) { + t.Helper() + lines, _ := a.railDrawnView(a.viewHeight()) + if len(lines) == 0 || lines[0].side == nil { + t.Fatal("the column has no header") + } + for _, d := range lines[0].side.doors { + if d.act.kind == sideActView && d.act.view == view { + return a.railLeft() + len([]rune(railSeam)) + d.span.from, a.topHeight() + } + } + t.Fatalf("the header has no word for view %d", view) + return 0, 0 +} + +// WITH THE MANAGER IN FRONT THE ONE COLUMN OPENS ON THE TRAFFIC, and its +// header offers the manager's own tasks as the other word, with its count, +// even at zero. A press on the word lays the tasks in the same column at the +// same width with the header where it was, and a press on the Traffic word +// takes it back. There is no second column and no special case. +func TestManagerColumnOpensOnTheTrafficAndOffersItsTasks(t *testing.T) { + a := managerColumnApp(t) + rows := railLines(t, a) + head := railRowOf(rows, sideTasksWord+" 0"+sideWordSep+sideTrafficWord) + if head < 0 || a.sideView() != sideTraffic { + t.Fatalf("the manager's column does not open on the Traffic with both words:\n%s", strings.Join(rows, "\n")) + } + managerTasks(a, 2) + rows = railLines(t, a) + if railRowOf(rows, sideTasksWord+" 2"+sideWordSep) != head || railRowOf(rows, "Task 1") >= 0 { + t.Fatalf("the Tasks word does not count the work behind it:\n%s", strings.Join(rows, "\n")) + } + body, cols := a.bodyWidth(), a.railWidth() + + x, y := sideWordAt(t, a, sideTasks) + a.setHover(x, y) + if a.hot.kind != hoverSide || a.hot.key != sideHeadKey || a.hot.index < 0 { + t.Fatalf("the Tasks word does not answer the pointer: %+v", a.hot) + } + if words := a.dockHoverWords(); !strings.Contains(words, "tasks") || !strings.Contains(words, "click") { + t.Fatalf("the Tasks word's hint says %q", words) + } + a.dropHover() + sideClick(t, a, x, y) + if a.sideView() != sideTasks { + t.Fatal("a press on Tasks did not bring the tasks to the front") + } + rows = railLines(t, a) + if a.bodyWidth() != body || a.railWidth() != cols || railRowOf(rows, sideTasksWord+" 2") != head || railRowOf(rows, "Task 1") <= head { + t.Fatalf("the tasks are not in the same column under the same header (body %d->%d, cols %d->%d):\n%s", body, a.bodyWidth(), cols, a.railWidth(), strings.Join(rows, "\n")) + } + x, y = sideWordAt(t, a, sideTraffic) + sideClick(t, a, x, y) + if a.sideView() != sideTraffic || a.bodyWidth() != body { + t.Fatal("a press on Traffic did not take the column back, or moved the body") + } +} + +// THE WORD IN FRONT IS REMEMBERED PER KIND OF CHAT, for the session: a +// manager opens on the Traffic, a member and a chat in no team on the tasks, +// and a word the person chose in one kind of chat is what that kind opens on +// next, whatever the other kind was left on. A chat in no team has only the +// one word. +func TestTheColumnsWordIsRememberedPerKindOfChat(t *testing.T) { + a := managerColumnApp(t) + harbor := a.wall.teams[0].ID + manager := a.frontTabKey() + _, priceKey := trafficHandle(t, a, harbor, "openrouter") + if a.sideView() != sideTraffic { + t.Fatal("a manager does not open on the Traffic") + } + a.sideSetView(sideTasks) + + spend(t, a, a.trafficGo(priceKey)) + if a.sideKind() != sideKindMember || a.sideView() != sideTasks { + t.Fatalf("a member opens on view %d", a.sideView()) + } + a.sideSetView(sideTraffic) + + spend(t, a, a.trafficGo(manager)) + if a.sideKind() != sideKindManager || a.sideView() != sideTasks { + t.Fatalf("the manager forgot its word: kind %d view %d", a.sideKind(), a.sideView()) + } + spend(t, a, a.trafficGo(priceKey)) + if a.sideView() != sideTraffic { + t.Fatal("the member forgot its word") + } + + plainChat, _, _ := tabApp(t) + plainChat.profileDir = t.TempDir() + plainChat.width, plainChat.height = 160, 40 + plainChat.welcome.open = false + managerTasks(plainChat, 1) + if plainChat.sideKind() != sideKindPlain || plainChat.sideView() != sideTasks { + t.Fatal("a chat in no team is not on its tasks") + } + plainChat.sideSetView(sideTraffic) + rows := railLines(t, plainChat) + if plainChat.sideView() != sideTasks || railRowOf(rows, sideTrafficWord) >= 0 || railRowOf(rows, sideTasksWord+" 1") < 0 { + t.Fatalf("a chat in no team offers a Traffic:\n%s", strings.Join(rows, "\n")) + } +} + +// LEFT AND RIGHT SWITCH THE WORDS WHILE THE COLUMN HOLDS THE KEYBOARD, and +// only then: the keyboard stays with the column, the chat in front stays in +// front, and without the hold the arrows are the draft's. +func TestLeftAndRightSwitchTheColumnsWords(t *testing.T) { + a := managerColumnApp(t) + managerTasks(a, 2) + front := a.frontTabKey() + drive(t, a, key("right")) + if a.sideView() != sideTraffic { + t.Fatal("an arrow with the keyboard in the draft switched the column") + } + drive(t, a, altT()) + if !a.railHold { + t.Fatal("alt+t did not give the column the keyboard") + } + drive(t, a, key("right")) + if a.sideView() != sideTasks || !a.railHold || a.frontTabKey() != front { + t.Fatalf("right did not switch to the tasks in place: view %d hold %v", a.sideView(), a.railHold) + } + drive(t, a, key("left")) + if a.sideView() != sideTraffic || !a.railHold { + t.Fatal("left did not switch back to the Traffic") + } + drive(t, a, key("esc")) + if a.railHold { + t.Fatal("esc did not give the keyboard back") + } +} diff --git a/internal/tui3/margin.go b/internal/tui3/margin.go index ed8386a32d..9108f1e837 100644 --- a/internal/tui3/margin.go +++ b/internal/tui3/margin.go @@ -87,10 +87,10 @@ const ( // third task. marginDoorMark = "+ " // marginStandMoreWord is what the standing label calls the orders the column - // had no room for ([app.marginStandHead]). It is the footer's own word for the - // same fact one section down (`view more`, taskview.go's [taskSheetMoreHint]), - // because a column that said `hidden` in one place and `more` in another would - // be two vocabularies for "there is another page of this". + // had no room for ([app.marginStandHead]). It is the band's own word for + // the same fact (`+2 more`, sidecol.go), because a column that said `hidden` + // in one place and `more` in another would be two vocabularies for "there + // is another page of this". marginStandMoreWord = "more" ) diff --git a/internal/tui3/markdown.go b/internal/tui3/markdown.go index 8d342790f4..e2e2365191 100644 --- a/internal/tui3/markdown.go +++ b/internal/tui3/markdown.go @@ -824,6 +824,10 @@ type taskLink struct { span hudSpan id uint64 title string + // member and team are a team reference's target (teamlink.go): the member's + // conversation key and its team's id, or the team alone for a team's name. + // Both are "" on a task reference. + member, team string // ord is this reference's place among the ones its BLOCK drew, counted across // every row the block wrapped over. It is written by the layout that numbered // them (render.go's [app.deckRows]) and read by the pointer, which holds a @@ -892,6 +896,11 @@ type taskRef struct { from, to int id uint64 title string + // member and team are a team reference's target ([taskLink.member]). + member, team string + // paint, when set, is this reference's own ink. Nil uses the pass's ink. + // A team mention uses it so the bullet wears that team's colour. + paint func(palette, string) string } // taskWord is the anchor every shape in the grammar opens on. @@ -1097,6 +1106,12 @@ func flatten(text string) (string, []bool) { // hot is which of refs the pointer is on, and -1 for none. That one is inked a // step brighter and nothing else about the row changes — see [taskLinkHotInk]. func paintLinks(text, flat string, refs []taskRef, pal palette, hot int) (string, []taskLink) { + return paintLinksWith(text, flat, refs, pal, hot, taskLinkInk, taskLinkHotInk) +} + +// paintLinksWith is [paintLinks] with the two inks handed in, so a team +// reference (teamlink.go) is written back by the same walk in its own hover. +func paintLinksWith(text, flat string, refs []taskRef, pal palette, hot int, ink, hotInk func(palette, string) string) (string, []taskLink) { var ( out strings.Builder links []taskLink @@ -1109,9 +1124,13 @@ func paintLinks(text, flat string, refs []taskRef, pal palette, hot int) (string for i := 0; i < len(text); { if next < len(refs) && at == refs[next].from { ref := refs[next] - inked := taskLinkInk(pal, flat[ref.from:ref.to]) + pen := ink + if ref.paint != nil { + pen = ref.paint + } + inked := pen(pal, flat[ref.from:ref.to]) if next == hot { - inked = taskLinkHotInk(pal, flat[ref.from:ref.to]) + inked = hotInk(pal, flat[ref.from:ref.to]) } restore := "" if inked != flat[ref.from:ref.to] { @@ -1128,9 +1147,11 @@ func paintLinks(text, flat string, refs []taskRef, pal palette, hot int) (string } } links = append(links, taskLink{ - span: hudSpan{from: ansi.StringWidth(flat[:ref.from]), to: ansi.StringWidth(flat[:ref.to])}, - id: ref.id, - title: ref.title, + span: hudSpan{from: ansi.StringWidth(flat[:ref.from]), to: ansi.StringWidth(flat[:ref.to])}, + id: ref.id, + title: ref.title, + member: ref.member, + team: ref.team, }) next++ // A REFERENCE ALREADY WEARING THIS INK IS LEFT ALONE, and that is the diff --git a/internal/tui3/mention.go b/internal/tui3/mention.go new file mode 100644 index 0000000000..bfb3fa5244 --- /dev/null +++ b/internal/tui3/mention.go @@ -0,0 +1,710 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// MENTIONS: "@" ALSO NAMES A TEAM OR A CONVERSATION. +// +// files.go is the list, and taskmention.go is the task half of it. This file +// is the other two sections of that same list: teams, then conversations, then +// the tasks and the files that were already there. +// +// THE CATALOG IS MEMORY. Teams are the ones this window already loaded +// ([app.wall.teams]). Conversations are the ones open in this window, then the +// recent list the door already handed the surface. Nothing here opens a file +// on a frame. The recent list is read once, inside a command, because that +// read can touch the disk. +// +// A PREFIX NARROWS THE LIST TO ONE SECTION. "@team:", "@chat:" and "@file:" +// are the three, and the same three words sit on the list's first row, each +// a press that types its prefix. Typing still filters every visible section +// at once. +// +// WHAT A CHOICE BECOMES. A team is "●" and its slug, drawn in the team's +// colour. A conversation is "@" and its handle, or a short slug of its title +// when it has no handle. The token is text. The digest the model reads is +// built on the engine (internal/session's mention.go), so a window over +// --host never has to open the other transcript. + +const ( + scopeTeam = "team" + scopeChat = "chat" + scopeFile = "file" + // mentionRows is how many teams, and how many conversations, one list draws. + // It is the file list's own screenful. + mentionRows = 8 + // mentionRecentCap is how many recent conversations the snapshot keeps. + mentionRecentCap = 24 +) + +// mentionTeam is one team as the list and the link pass need it. +type mentionTeam struct { + id, name, slug string + hue teamHueSpec + members int +} + +// mentionChat is one conversation as the list and the link pass need it. +type mentionChat struct { + key, file, where string + title, handle string + slug string + open bool + note string +} + +// mentionScope splits an @ query into a section prefix and the needle. No +// prefix answers "" and the query unchanged. +func mentionScope(query string) (string, string) { + low := strings.ToLower(query) + for _, scope := range []string{scopeTeam, scopeChat, scopeFile} { + prefix := scope + ":" + if strings.HasPrefix(low, prefix) { + return scope, query[len(prefix):] + } + } + return "", query +} + +// mentionSlug is a title as one @ token: the same spelling a task mention uses, +// so a person can type what they can see. +func mentionSlug(title string) string { + slug := session.TaskSlug(title) + if slug == "" { + return "chat" + } + return slug +} + +// rankMentions keeps the teams and conversations the needle matches. An +// argument list gets none of them: "/image" takes a path. +func (c *completion) rankMentions(needle string) { + c.teamHits, c.chatHits = c.teamHits[:0], c.chatHits[:0] + if c.arg { + return + } + if c.scope == "" || c.scope == scopeTeam { + for _, team := range c.teams { + if _, ok := pathScore(team.name+" "+team.slug, needle); ok { + c.teamHits = append(c.teamHits, team) + if len(c.teamHits) >= mentionRows { + break + } + } + } + } + if c.scope == "" || c.scope == scopeChat { + for _, chat := range c.chats { + hay := chat.title + " " + chat.handle + " " + chat.slug + if _, ok := pathScore(hay, needle); ok { + c.chatHits = append(c.chatHits, chat) + if len(c.chatHits) >= mentionRows { + break + } + } + } + } +} + +// layoutMentions appends the team section and the conversation section. +func (c *completion) layoutMentions(lines []compLine) []compLine { + if len(c.teamHits) > 0 { + rule := deadLine() + rule.header = "teams" + lines = append(lines, rule) + for at := range c.teamHits { + line := deadLine() + line.team = at + lines = append(lines, line) + } + } + if len(c.chatHits) > 0 { + rule := deadLine() + rule.header = "conversations" + lines = append(lines, rule) + for at := range c.chatHits { + line := deadLine() + line.chat = at + lines = append(lines, line) + } + } + return lines +} + +// emptyWord is the line under the prefix words when nothing matched. +func (c *completion) emptyWord() string { + switch c.scope { + case scopeTeam: + return "no team matches" + case scopeChat: + return "no conversation matches" + case scopeFile: + return "no file matches" + default: + return "no matches" + } +} + +// teamChoice is the team under the cursor. +func (c *completion) teamChoice() (mentionTeam, bool) { + at := c.selLine() + if at < 0 || c.lines[at].team < 0 { + return mentionTeam{}, false + } + return c.teamHits[c.lines[at].team], true +} + +// chatChoice is the conversation under the cursor. +func (c *completion) chatChoice() (mentionChat, bool) { + at := c.selLine() + if at < 0 || c.lines[at].chat < 0 { + return mentionChat{}, false + } + return c.chatHits[c.lines[at].chat], true +} + +func mentionCount(team mentionTeam) string { + n := team.members + if n == 1 { + return "1 conversation" + } + if n == 0 { + return "" + } + return itoa(n) + " conversations" +} + +func mentionTeamLabel(team mentionTeam, pal palette) string { + dot := "●" + if pal.ascii { + dot = "*" + } + if pen := pal.teamInk(team.hue); pen != nil { + return pen(dot) + " " + team.name + } + return dot + " " + team.name +} + +func mentionChatLabel(chat mentionChat) string { + if chat.handle != "" { + return "@" + chat.handle + } + if chat.title != "" { + return chat.title + } + return "@" + chat.slug +} + +// mentionToken is what choosing a conversation types after the "@". +func mentionToken(chat mentionChat) string { + if chat.handle != "" { + return chat.handle + } + if chat.slug != "" { + return chat.slug + } + return mentionSlug(chat.title) +} + +// ── the catalogs, from memory ─────────────────────────────────────────────── + +// fillMentions copies the in-memory catalogs onto the list. It runs on the +// update loop, beside [completion.sync], and never from a frame. +func (a *app) fillMentions() { + a.comp.teams = a.mentionTeams() + a.comp.chats = a.mentionChats() +} + +func (a *app) mentionTeams() []mentionTeam { + if !a.wall.loaded || len(a.wall.teams) == 0 { + return nil + } + out := make([]mentionTeam, 0, len(a.wall.teams)) + for _, t := range a.wall.teams { + name := strings.TrimSpace(t.Name) + if name == "" { + continue + } + out = append(out, mentionTeam{ + id: t.ID, name: name, slug: mentionSlug(name), + hue: t.HueSpec(), members: len(t.Members), + }) + } + return out +} + +// mentionChats is the open conversations in this window, then recent ones that +// are not already open. The conversation in front is left off: pointing at the +// chat you are typing in is not a reference. +func (a *app) mentionChats() []mentionChat { + front := a.frontTabKey() + var out []mentionChat + seen := map[string]bool{} + for _, tab := range a.tabList() { + if tab.slot || tab.key == "" || tab.key == front || seen[tab.key] { + continue + } + seen[tab.key] = true + out = append(out, a.mentionFromTab(tab, true)) + } + for _, chat := range a.comp.recents { + if chat.key == "" || chat.key == front || seen[chat.key] { + continue + } + seen[chat.key] = true + chat.open = false + out = append(out, chat) + } + return out +} + +func (a *app) mentionFromTab(tab chatTab, open bool) mentionChat { + title := strings.TrimSpace(tab.full) + if title == "" { + title = strings.TrimSpace(tab.word) + } + handle := a.mentionHandle(tab.key) + note := title + if open { + note = "open" + if title != "" && handle != "" { + note = title + } + } + return mentionChat{ + key: tab.key, file: tab.file, where: tab.where, + title: title, handle: handle, slug: mentionSlug(title), + open: open, note: note, + } +} + +// mentionHandle is the handle any team gave this conversation, or "". +func (a *app) mentionHandle(key string) string { + if key == "" || !a.wall.loaded { + return "" + } + for _, t := range a.wall.teams { + for _, m := range t.Members { + if m.Key == key && m.Handle != "" { + return m.Handle + } + } + } + return "" +} + +// mentionRecentsMsg is the recent list, read off the loop. +type mentionRecentsMsg struct{ rows []Session } + +// loadMentionRecents reads the door's recent list once. The door's function +// may open a directory, so it runs inside the command and not on the loop. +func (a *app) loadMentionRecents() tea.Cmd { + if a.comp.recentsHeld || a.recentSessions == nil { + return nil + } + a.comp.recentsHeld = true + read := a.recentSessions + return func() tea.Msg { + list := read() + if len(list) > mentionRecentCap { + list = list[:mentionRecentCap] + } + return mentionRecentsMsg{rows: list} + } +} + +func (a *app) mentionRecentsLoaded(rows []Session) { + a.comp.recentsHeld = true + a.comp.recents = a.comp.recents[:0] + seen := map[string]bool{} + for _, row := range rows { + file := strings.TrimSpace(row.File) + if file == "" || seen[file] { + continue + } + seen[file] = true + title := strings.TrimSpace(row.Title) + if title == "" { + title = strings.TrimSpace(row.Opening) + } + if title == "" { + continue + } + a.comp.recents = append(a.comp.recents, mentionChat{ + key: file, file: file, title: title, + handle: a.mentionHandle(file), slug: mentionSlug(title), + note: title, + }) + } + if a.comp.open { + a.fillMentions() + a.comp.rank() + } + a.touch() +} + +// ── choosing ──────────────────────────────────────────────────────────────── + +// completeTeam types "●" and the team's slug where the @ token was. The "@" +// comes out: the bullet is the mark, and a second mark in front of it would +// be two names for one thing. +func (a *app) completeTeam(team mentionTeam) { + slug := team.slug + if slug == "" { + slug = mentionSlug(team.name) + } + token := "●" + slug + e := &a.input + head := append([]rune(nil), e.value[:a.comp.at]...) + tail := append([]rune(nil), e.value[e.cursor:]...) + e.value = append(append(head, []rune(token)...), tail...) + e.cursor = a.comp.at + len([]rune(token)) + a.comp.done = "" + a.comp.close() + a.touch() +} + +// completeChat types "@" and the handle, or the title's slug when the +// conversation has no handle. +func (a *app) completeChat(chat mentionChat) { + token := mentionToken(chat) + if token == "" { + a.comp.close() + return + } + e := &a.input + head := append([]rune(nil), e.value[:a.comp.at+1]...) + tail := append([]rune(nil), e.value[e.cursor:]...) + e.value = append(append(head, []rune(token)...), tail...) + e.cursor = a.comp.at + 1 + len([]rune(token)) + a.comp.done = token + a.comp.close() + a.touch() +} + +// ── the prefix words ──────────────────────────────────────────────────────── + +// mentionHeadWords are the three prefixes, drawn as words on the list's first +// row. The order is the order of the sections. +var mentionHeadWords = []string{scopeTeam, scopeChat, scopeFile} + +// mentionHeadLine paints those words. The active prefix is accent. The word +// under the pointer wears the cursor ground. +func mentionHeadLine(pal palette, scope, hot string, width int) string { + var b strings.Builder + b.WriteString(" ") + for i, word := range mentionHeadWords { + if i > 0 { + b.WriteString(" ") + } + painted := pal.dim(word) + if word == scope { + painted = pal.accent(word) + } + if word == hot { + painted = pal.cursor(word, 0) + } + b.WriteString(painted) + } + return b.String() +} + +// mentionHeadAt reports which prefix word a column of the header row is on. +// The row is " team chat file", and the column is the frame's. +func mentionHeadAt(x int) (string, bool) { + at := 2 + for _, word := range mentionHeadWords { + if x >= at && x < at+len(word) { + return word, true + } + at += len(word) + 2 + } + return "", false +} + +// mentionHeadPress is a click on one of those words. It types that prefix, or +// takes it back off when it was already the one in force. +func (a *app) mentionHeadPress(x, y int) (tea.Cmd, bool) { + if !a.comp.open || a.comp.arg || a.comp.top != 0 { + return nil, false + } + mark, ok := a.chromeAt(y) + if !ok || mark.kind != chromeOverlay || mark.index != 0 { + return nil, false + } + word, ok := mentionHeadAt(x) + if !ok { + return nil, false + } + a.applyMentionScope(word) + return a.edited(), true +} + +// applyMentionScope rewrites the @ token's prefix and leaves the needle. +func (a *app) applyMentionScope(scope string) { + e := &a.input + if a.comp.at < 0 || a.comp.at >= len(e.value) { + return + } + _, needle := mentionScope(a.comp.query) + next := scope + ":" + if a.comp.scope == scope { + next = "" + } + repl := []rune(next + needle) + head := append([]rune(nil), e.value[:a.comp.at+1]...) + tail := append([]rune(nil), e.value[e.cursor:]...) + e.value = append(append(head, repl...), tail...) + e.cursor = a.comp.at + 1 + len(repl) + a.comp.done = "" +} + +// mentionHeadHint is the one line under the box while the pointer is on a +// prefix word. +func (a *app) mentionHeadHint() string { + if a.hot.kind != hoverOverlay || !a.comp.open { + return "" + } + switch a.hot.key { + case scopeTeam: + return "only teams" + hintSegment + "click" + case scopeChat: + return "only conversations" + hintSegment + "click" + case scopeFile: + return "only files" + hintSegment + "click" + default: + return "" + } +} + +// paintDraftMentions colours a "●slug" in the box with its team's colour. The +// runes stay the runes, so the caret's column does not move. +func (a *app) paintDraftMentions(block []string) []string { + if len(a.comp.teams) == 0 && len(a.wall.teams) == 0 { + return block + } + teams := a.comp.teams + if len(teams) == 0 { + teams = a.mentionTeams() + } + for i, line := range block { + plain := ansi.Strip(line) + if !strings.Contains(plain, "●") { + continue + } + for _, team := range teams { + token := "●" + team.slug + if !strings.Contains(line, token) { + continue + } + pen := a.pal.accent + if ink := a.pal.teamInk(team.hue); ink != nil { + pen = ink + } + line = strings.Replace(line, token, pen(token), 1) + } + block[i] = line + } + return block +} + +// mentionLinkOrd is the first ordinal a block's mention references take. It +// sits above the team references ([teamLinkOrd]) so one hover holds either. +const mentionLinkOrd = 1 << 17 + +// mentionLinkPass inks "●slug" and "@handle" on the person's own messages, and +// on the same rows a team reference already rides. A conversation in no team +// is still a door: the catalog is every open tab, every recent row this list +// has loaded, and every team member. +func (a *app) mentionLinkPass(out []row, es []entry) { + teams := a.mentionTeams() + chats := a.mentionLinkChats() + if len(teams) == 0 && len(chats) == 0 { + return + } + block, n := -1, 0 + for i := range out { + r := &out[i] + if r.entry < 0 || r.entry >= len(es) || !mentionLinkRow(&es[r.entry]) || r.hit == hitPictureOriginal { + continue + } + if r.entry != block { + block, n = r.entry, 0 + } + hot := -1 + if at := a.hoveringLink(r.entry); at >= mentionLinkOrd { + hot = at - mentionLinkOrd - n + } + rowChats := chats + if es[r.entry].kind != entryUser { + rowChats = nil + } + text, links := linkifyMentions(r.text, a.pal, teams, rowChats, hot) + if len(links) == 0 { + continue + } + for j := range links { + links[j].ord = mentionLinkOrd + n + j + } + n += len(links) + r.text = text + r.links = append(r.links, links...) + } +} + +func mentionLinkRow(e *entry) bool { + if e.kind == entryUser { + return true + } + return teamLinkRow(e) +} + +// mentionLinkChats is every conversation a sent token might name: open tabs, +// the recent snapshot, and every team member, including ones in no team only +// as a tab or a recent row. +func (a *app) mentionLinkChats() []mentionChat { + seen := map[string]bool{} + var out []mentionChat + add := func(chat mentionChat) { + if chat.key == "" || seen[chat.key] { + return + } + seen[chat.key] = true + out = append(out, chat) + } + for _, chat := range a.mentionChats() { + add(chat) + } + for _, chat := range a.comp.recents { + add(chat) + } + if a.wall.loaded { + for _, t := range a.wall.teams { + for _, m := range t.Members { + add(mentionChat{ + key: m.Key, file: m.File, where: m.Where, + title: m.Word, handle: m.Handle, slug: mentionSlug(m.Word), + note: m.Word, + }) + } + } + } + return out +} + +func linkifyMentions(text string, pal palette, teams []mentionTeam, chats []mentionChat, hot int) (string, []taskLink) { + if !strings.Contains(text, "●") && !strings.Contains(text, "@") { + return text, nil + } + flat, _ := flatten(text) + refs := mentionTextRefs(flat, teams, chats) + if len(refs) == 0 { + return text, nil + } + return paintLinksWith(text, flat, refs, pal, hot, teamLinkInk, teamLinkHotInk) +} + +func mentionTextRefs(flat string, teams []mentionTeam, chats []mentionChat) []taskRef { + var out []taskRef + const bullet = "●" + for i := 0; i < len(flat); i++ { + if strings.HasPrefix(flat[i:], bullet) && (i == 0 || !wordByte(flat[i-1])) { + j := i + len(bullet) + for j < len(flat) && (wordByte(flat[j]) || flat[j] == '-') { + j++ + } + slug := strings.ToLower(flat[i+len(bullet) : j]) + for _, team := range teams { + if team.slug == slug { + hue := team.hue + out = append(out, taskRef{ + from: i, to: j, team: team.id, + paint: func(pal palette, s string) string { + if pen := pal.teamInk(hue); pen != nil { + return pal.underline(pen(s)) + } + return teamLinkInk(pal, s) + }, + }) + break + } + } + i = j - 1 + continue + } + if flat[i] != '@' || (i > 0 && (wordByte(flat[i-1]) || flat[i-1] == '.' || flat[i-1] == '@')) { + continue + } + j := i + 1 + for j < len(flat) && (wordByte(flat[j]) || flat[j] == '-' || flat[j] == '/') { + j++ + } + token := flat[i+1 : j] + if strings.Contains(token, "/") || token == "" { + i = j - 1 + continue + } + low := strings.ToLower(token) + if scope, rest := mentionScope(low); scope != "" { + low = strings.ToLower(rest) + } + for _, chat := range chats { + if low == "" { + break + } + if strings.EqualFold(chat.handle, low) || chat.slug == low { + out = append(out, taskRef{from: i, to: j, member: chat.key, title: chat.title}) + break + } + } + i = j - 1 + } + return out +} + +func (a *app) mentionChatPress(key string) tea.Cmd { + if key == "" || key == a.frontTabKey() { + return nil + } + for _, tab := range a.tabList() { + if tab.key == key { + return a.tabGo(tab) + } + } + for _, chat := range a.mentionLinkChats() { + if chat.key != key { + continue + } + word := chat.title + if strings.TrimSpace(word) == "" { + word = "@" + mentionToken(chat) + } + return a.tabGo(chatTab{key: chat.key, file: chat.file, where: chat.where, word: word, full: chat.title}) + } + return nil +} + +func (a *app) mentionChatHint(key string) string { + for _, chat := range a.mentionLinkChats() { + if chat.key != key { + continue + } + name := "@" + mentionToken(chat) + verb := "Resume" + if tabsHold(a.tabList(), key) { + verb = "Open" + } + words := verb + " " + name + if title := strings.TrimSpace(chat.title); title != "" && title != name { + words += hintSegment + title + } + return words + hintSegment + "click" + } + return "" +} diff --git a/internal/tui3/mention_test.go b/internal/tui3/mention_test.go new file mode 100644 index 0000000000..3bddf37cbe --- /dev/null +++ b/internal/tui3/mention_test.go @@ -0,0 +1,172 @@ +package tui3 + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +func mentionApp(t *testing.T) *app { + t.Helper() + a := completionApp(t, "internal/tui3/app.go", "cmd/codeaf/main.go") + a.pal = newPalette(tokens.ANSI256, false) + a.wall.loaded = true + a.wall.teams = []team{{ + ID: "t1", Name: "harbor", Hue: 210, + Members: []teamMember{ + {Key: "/s/parser.jsonl", File: "/s/parser.jsonl", Handle: "parser", Word: "the parser"}, + {Key: "/s/web.jsonl", File: "/s/web.jsonl", Handle: "web", Word: "web frontend"}, + }, + }} + a.comp.recentsHeld = true + a.comp.recents = []mentionChat{{ + key: "/s/side.jsonl", file: "/s/side.jsonl", + title: "side chat", slug: "side-chat", note: "side chat", + }} + return a +} + +func TestMentionListSectionsFilterAndPrefixes(t *testing.T) { + a := mentionApp(t) + typeInto(t, a, "@") + if !a.comp.open { + t.Fatal("the bare @ did not open the list") + } + plainRows := plain(strings.Join(a.overlayRows(a.width, a.overlayHeight()), "\n")) + for _, want := range []string{"team", "chat", "file", "harbor", "side chat", "app.go"} { + if !strings.Contains(plainRows, want) { + t.Fatalf("the list is missing %q:\n%s", want, plainRows) + } + } + if _, ok := a.comp.teamChoice(); !ok { + t.Fatal("the first choice is not the team") + } + + typeInto(t, a, "har") + if _, ok := a.comp.teamChoice(); !ok { + t.Fatal("harbor dropped out of a query it matches") + } + if len(a.comp.chatHits) != 0 { + t.Fatalf("conversations matched %q", a.comp.query) + } + + a = mentionApp(t) + typeInto(t, a, "@team:app") + if len(a.comp.teamHits) != 0 || len(a.comp.chatHits) != 0 || len(a.comp.hits) != 0 { + t.Fatal("@team: kept a section it does not name") + } + if !strings.Contains(plain(strings.Join(a.overlayRows(a.width, a.overlayHeight()), "\n")), "no team matches") { + t.Fatal("a team prefix with no hit did not say so") + } + + a = mentionApp(t) + typeInto(t, a, "@file:app") + if len(a.comp.teamHits) != 0 || len(a.comp.chatHits) != 0 { + t.Fatal("@file: kept a team or a conversation") + } + if path, ok := a.comp.choice(); !ok || !strings.Contains(path, "app.go") { + t.Fatalf("the file prefix chose %q", path) + } + + a = mentionApp(t) + typeInto(t, a, "@chat:side") + if len(a.comp.chatHits) != 1 || a.comp.chatHits[0].slug != "side-chat" { + t.Fatalf("the chat prefix kept %+v", a.comp.chatHits) + } + if len(a.comp.teamHits) != 0 || len(a.comp.hits) != 0 { + t.Fatal("the chat prefix kept another section") + } +} + +func TestMentionPrefixWordIsAPress(t *testing.T) { + a := mentionApp(t) + typeInto(t, a, "@har") + word, ok := mentionHeadAt(2) + if !ok || word != scopeTeam { + t.Fatalf("column 2 is %q", word) + } + var y int + found := false + for at := 0; at < a.height; at++ { + mark, ok := a.chromeAt(at) + if ok && mark.kind == chromeOverlay && mark.index == 0 { + y, found = at, true + break + } + } + if !found { + t.Fatal("the prefix row is not on the frame") + } + drive(t, a, tea.MouseClickMsg{X: 2, Y: y, Button: tea.MouseLeft}) + if got := a.input.String(); got != "@team:har" { + t.Fatalf("the prefix word typed %q", got) + } + if a.hot.kind != hoverOverlay { + a.hot = hoverAt{kind: hoverOverlay, key: scopeTeam} + } + if hint := a.mentionHeadHint(); !strings.Contains(hint, "only teams") || !strings.Contains(hint, "click") { + t.Fatalf("the prefix hint is %q", hint) + } +} + +func TestMentionInsertsTheTokenAndLinksIt(t *testing.T) { + a := mentionApp(t) + typeInto(t, a, "see @") + drive(t, a, key("enter")) + if got := a.input.String(); got != "see ●harbor" { + t.Fatalf("choosing the team inserted %q", got) + } + painted := a.paintDraftMentions([]string{a.input.String()}) + if ansi.Strip(painted[0]) != "see ●harbor" { + t.Fatalf("the draft's runes moved: %q", ansi.Strip(painted[0])) + } + if painted[0] == "see ●harbor" { + t.Fatal("the team mark was not drawn in the team's colour") + } + + a = mentionApp(t) + typeInto(t, a, "@chat:side") + drive(t, a, key("enter")) + if got := a.input.String(); got != "@side-chat" { + t.Fatalf("choosing the conversation inserted %q", got) + } + + a = mentionApp(t) + a.entries = []entry{{kind: entryUser, text: "see ●harbor and @parser"}} + rows := []row{{entry: 0, text: "see ●harbor and @parser"}} + a.mentionLinkPass(rows, a.entries) + if len(rows[0].links) != 2 { + t.Fatalf("the sent line has %d links", len(rows[0].links)) + } + if rows[0].links[0].team != "t1" { + t.Fatalf("the team link is %+v", rows[0].links[0]) + } + if rows[0].links[1].member != "/s/parser.jsonl" { + t.Fatalf("the chat link is %+v", rows[0].links[1]) + } + if !strings.Contains(ansi.Strip(rows[0].text), "●harbor") || !strings.Contains(ansi.Strip(rows[0].text), "@parser") { + t.Fatalf("the linked line is %q", ansi.Strip(rows[0].text)) + } + if hint := a.mentionChatHint("/s/parser.jsonl"); !strings.Contains(hint, "the parser") { + t.Fatalf("the chat hint is %q", hint) + } +} + +func TestMentionFrameDoesNotReadRecents(t *testing.T) { + a := mentionApp(t) + framing := false + a.recentSessions = func() []Session { + if framing { + t.Fatal("a frame read the recent conversations") + } + return nil + } + typeInto(t, a, "@harbor") + framing = true + _ = a.View() + a.mentionLinkPass([]row{{entry: 0, text: "●harbor"}}, []entry{{kind: entryUser}}) +} diff --git a/internal/tui3/narrow_test.go b/internal/tui3/narrow_test.go index cabc2a7fee..5a58396611 100644 --- a/internal/tui3/narrow_test.go +++ b/internal/tui3/narrow_test.go @@ -21,98 +21,89 @@ import ( // not DO there: find six of the seven places, read the end of a sentence, and // tell one conversation from another. -// THE NARROW BAR STILL SAYS WHERE ELSE YOU CAN GO. +// THE NARROW NAV STILL SAYS WHERE ELSE YOU CAN GO. // -// At sixty columns the bar used to collapse to the single word `home`, with -// nothing on the frame saying that tasks, standing, memory, spend, search and -// settings existed at all: seven words and their padding are fifty-seven cells, -// the air between them is six more, and sixty overshot by three — straight past -// the middle rung of the ladder, because on a quiet machine no place wears a -// count. The air is what goes now. -func TestTheNarrowBarStillSaysWhereElseYouCanGo(t *testing.T) { +// At sixty columns the places' bar used to collapse to the single word `home`, +// with nothing on the frame saying the other places existed at all. The nav +// on the wordmark's row keeps every place reachable at every width: a word it +// has no room for folds into `more ▾`, which is a door onto exactly those +// places (navmore.go), and the air between two words never changes. +func TestTheNarrowNavStillSaysWhereElseYouCanGo(t *testing.T) { a := placeApp(t) - // THE WIDTH WHERE THE AIR GOES is one cell under the bar's own width: the - // words still fit there once the gaps between them are given up. It is read - // off the bar rather than typed, because the bar is four words now and a - // literal sixty was a width measured against seven. - tight := ansi.StringWidth(plain(a.placeTabBar(200, false, a.pal))) - 1 - for _, width := range []int{tight, 60, 80, 120, 160} { - bar := plain(a.placeTabBar(width, false, a.pal)) - for _, id := range barPages(a.page, false) { - if !strings.Contains(bar, id.word()) { - t.Fatalf("at %d columns the bar drew\n\t%q\nand a person cannot reach %q from it; every one of its places should be on the row:\n\t%q", - width, bar, id.word(), plain(a.placeTabBar(200, false, a.pal))) + for _, width := range []int{50, 60, 80, 120, 160} { + bar := navPlaces(a, width, false) + for _, id := range barPages(a.navLit(), false) { + if !strings.Contains(" "+bar+" ", " "+id.word()+" ") && !pagesHold(a.navMore.folded, id) { + t.Fatalf("at %d columns the nav drew\n\t%q\nand a person cannot reach %q from it, on the row or behind `more`", width, bar, id.word()) } } - if got := ansi.StringWidth(bar); got > width { - t.Fatalf("at %d columns the bar is %d cells wide and runs past the frame:\n\t%q", width, got, bar) + if got := ansi.StringWidth(plain(a.navLine(width, a.pal))); got > width { + t.Fatalf("at %d columns the nav is %d cells wide and runs past the frame", width, got) + } + // AND THE AIR IS HELD: two blank cells between two words, whatever the + // width, because what a narrow row gives up is words and never air. + if width >= 80 && !strings.Contains(bar, "home teams chats sessions spend settings") { + t.Fatalf("at %d columns the nav drew\n\t%q\nand should carry the six places two cells apart", width, bar) + } + if strings.Contains(bar, " ") { + t.Fatalf("at %d columns the nav drew\n\t%q\nwith the air between two words changed", width, bar) } } - // AND THE WIDE TIER DID NOT MOVE. The air between the chips is what a narrow - // frame gives up, so a frame with room for it still has it — a fix for sixty - // columns that re-spaced a hundred and sixty would be a fix that cost every - // other terminal something. - wide := plain(a.placeTabBar(120, false, a.pal)) - if !strings.Contains(wide, "home sessions") { - t.Fatalf("at 120 columns the bar drew\n\t%q\nand the air between two chips is gone; it should read\n\t%q", - wide, " home sessions spend settings") - } - if narrow := plain(a.placeTabBar(tight, false, a.pal)); !strings.Contains(narrow, "home sessions") { - t.Fatalf("at %d columns the bar drew\n\t%q\nand it should carry every word with the air between the chips given up:\n\t%q", - tight, narrow, " home sessions spend settings") +} + +// pagesHold reports whether one place is in a list of places. +func pagesHold(list []page, id page) bool { + for _, p := range list { + if p == id { + return true + } } + return false } -// A BAR TOO NARROW FOR EVERY WORD SAYS HOW MANY IT DROPPED. +// A NAV TOO NARROW FOR EVERY WORD FOLDS THEM INTO `more ▾`, AND IT IS A DOOR. // -// Under the width where all seven fit there is no honest way to draw them, and -// the collapse this ladder exists to prevent is not "fewer words" — it is a row +// Under the width where all six fit there is no honest way to draw them, and +// the collapse the ladder exists to prevent is not "fewer words", it is a row // that says `home` and lets a person believe that is all there is. So what is -// left ends in a count of the places that are not on it, and the key that -// reaches them is on the foot of every place. -func TestABarTooNarrowForEveryWordSaysHowManyItDropped(t *testing.T) { +// left ends in `more ▾`, which stands for exactly the places it folded, and +// never in a bare count a person cannot press. +func TestANavTooNarrowForEveryWordFoldsIntoMore(t *testing.T) { a := placeApp(t) - for _, tc := range []struct{ width int }{{28}, {24}} { - bar := plain(a.placeTabBar(tc.width, false, a.pal)) + for _, width := range []int{34, 40, 48} { + bar := navPlaces(a, width, false) if !strings.Contains(bar, a.page.word()) { - t.Fatalf("at %d columns the bar drew\n\t%q\nand dropped the place you are standing in (%q)", tc.width, bar, a.page.word()) - } - if !strings.Contains(bar, tokens.GlyphCollapsed) { - t.Fatalf("at %d columns the bar drew\n\t%q\nand said nothing about the places it could not carry; it should end in a marked count, as in\n\t%q", - tc.width, bar, " home sessions "+tokens.GlyphCollapsed+" 2") + t.Fatalf("at %d columns the nav drew\n\t%q\nand folded the place you are standing in (%q)", width, bar, a.page.word()) } - if got := ansi.StringWidth(bar); got > tc.width { - t.Fatalf("at %d columns the bar is %d cells wide and runs past the frame:\n\t%q", tc.width, got, bar) + if !strings.HasSuffix(bar, a.navMoreWord(a.pal)) || !a.navMore.span.pressable() { + t.Fatalf("at %d columns the nav drew\n\t%q\nand said nothing about the places it could not carry; it should end in `more ▾`", width, bar) } - // AND THE COUNT IS THE TRUTH. Every place that is not spelled on the row - // is one the count has to stand for, or the row is a second way of - // hiding them. missing := 0 for _, id := range barPages(a.page, false) { - if !strings.Contains(bar, id.word()) { + if !strings.Contains(" "+bar+" ", " "+id.word()+" ") { missing++ + if !pagesHold(a.navMore.folded, id) { + t.Fatalf("at %d columns %q is off the row and not behind `more`", width, id.word()) + } } } - // THE COUNT WEARS THE FOLD MARK, which is what tells it from a badge or - // a door ([barMoreWord] and [foldSpellings]). - if want := tokens.GlyphCollapsed + " " + itoa(missing); !strings.Contains(bar, want) { - t.Fatalf("at %d columns the bar drew\n\t%q\nwhich leaves %d places off the row; the count should read %q", - tc.width, bar, missing, want) + if missing != len(a.navMore.folded) || missing == 0 { + t.Fatalf("at %d columns the nav left %d places off and folded %v", width, missing, a.navMore.folded) + } + if strings.Contains(bar, "+") || strings.Contains(bar, tokens.GlyphCollapsed) { + t.Fatalf("at %d columns the fold is a count and not a word: %q", width, bar) } } - // AND A FRAME WITH NO ROOM FOR THE COUNT SAYS NOTHING RATHER THAN RUNNING - // PAST ITS OWN EDGE, which is the fault this whole ladder exists to prevent. - for _, width := range []int{8, 12, 16} { - if bar := plain(a.placeTabBar(width, false, a.pal)); ansi.StringWidth(bar) > width { - t.Fatalf("at %d columns the bar is %d cells wide and runs past the frame:\n\t%q", width, ansi.StringWidth(bar), bar) + // AND A FRAME WITH NO ROOM EVEN FOR THE FOLD NEVER RUNS PAST ITS OWN EDGE. + for _, width := range []int{8, 12, 16, 24} { + if got := ansi.StringWidth(plain(a.navLine(width, a.pal))); got > width { + t.Fatalf("at %d columns the nav is %d cells wide and runs past the frame", width, got) } } - // AND A COUNT NEVER APPEARS ON A BAR THAT CARRIED EVERYTHING. A `+0` beside - // four words would be furniture, and furniture is what people stop seeing — - // and the three places reached by command are not a count the bar owes. - for _, width := range []int{60, 80, 120, 160} { - if bar := plain(a.placeTabBar(width, false, a.pal)); strings.Contains(bar, "+") { - t.Fatalf("at %d columns every place is on the bar and it still counts something:\n\t%q", width, bar) + // AND A NAV THAT CARRIED EVERYTHING FOLDS NOTHING. + for _, width := range []int{80, 120, 160} { + if navPlaces(a, width, false); a.navMore.span.pressable() { + t.Fatalf("at %d columns every place is on the row and it still folds %v", width, a.navMore.folded) } } } @@ -313,59 +304,67 @@ func pulseLab(t *testing.T) (*app, time.Time) { return a, now } -// THE TOP LINE GIVES UP THE CLOCK BEFORE THE WORK COUNT. +// THE TOP LINE GIVES THINGS UP IN THE OWNER'S ORDER. // -// This line was drawn ALL OR NOTHING: everything, or the program's name by -// itself. So a sixty-column window — a split pane, an ssh session from a train — -// spent twelve of its cells on `thu 12:01am` and then, one segment later, threw -// the whole right end away and said nothing about the machine at all. It walks a -// ranked ladder now, and the clock is the first thing off it: the terminal, the -// window and the wall all say what time it is, and nothing else on this machine -// says that twelve things have stopped and will not move until somebody looks. -func TestTheTopLineGivesUpTheClockBeforeTheWorkCount(t *testing.T) { +// The places and the pulse share the first row now, and the owner ruled the +// order a narrowing row gives things up in (2026-09-24): the clock first, with +// the machine's name, then the counts (the moving one before the one that +// wants you), then the allowance behind the day's figure, then the trailing +// places fold into `more ▾`, and the day's figure is the last clause standing. +// Every width is checked: a thing given up early may never be on the row while +// a thing given up later is gone, and every rung of the ladder is met. +func TestTheTopLineGivesThingsUpInTheOwnersOrder(t *testing.T) { a, now := pulseLab(t) + a.showPage(pageNone) + a.machine = machineFacts{wants: 12, hands: 4, spent: 123.45, ceiling: 500} + a.host = "spark" clock := pulseClock(now) - // THE WIDE TIERS DID NOT MOVE. A fix for sixty columns that cost a hundred - // and sixty a segment would be a fix that made the common case worse. - for _, width := range []int{80, 120, 160} { - line := plain(a.pulseLine(width, a.pal, pulseWhole)) - for _, want := range []string{product, "12 want you", "4 moving", "$123.45 / " + railFigure(500), clock} { - if !strings.Contains(line, want) { - t.Fatalf("at %d columns the top line drew\n\t%q\nand lost %q; there is room for all of it:\n\t%q", - width, line, want, " "+product+" 12 want you · 4 moving · $123.45 / "+railFigure(500)+" · "+clock) + type state struct{ clock, host, hands, wants, allowance, unfolded, spend bool } + seen := map[state]bool{} + for width := 220; width >= 30; width-- { + line := plain(a.navLine(width, a.pal)) + if got := ansi.StringWidth(line); got > width { + t.Fatalf("at %d columns the top line is %d cells wide:\n\t%q", width, got, line) + } + if !strings.Contains(line, product) || !strings.Contains(line, " chats ") { + t.Fatalf("at %d columns the top line lost the wordmark or the lit place:\n\t%q", width, line) + } + s := state{ + clock: strings.Contains(line, clock), host: strings.Contains(line, "on spark"), + hands: strings.Contains(line, "4 moving"), wants: strings.Contains(line, "12 want you"), + allowance: strings.Contains(line, "/ "+railFigure(500)), unfolded: !a.navMore.span.pressable(), + spend: strings.Contains(line, "$123.45"), + } + order := []bool{s.clock, s.host, s.hands, s.wants, s.allowance, s.unfolded, s.spend} + for i := range order { + for j := i + 1; j < len(order); j++ { + if order[i] && !order[j] { + t.Fatalf("at %d columns the top line gave up rung %d before rung %d:\n\t%q", width, j, i, line) + } } } - } - // AND THE LADDER, RUNG BY RUNG. Each width is the widest one at which the - // rung below is the honest answer, and each expectation is a WHOLE clause - // fewer than the one above it — never a clause with its end sliced off. - for _, one := range []struct { - width int - want string - }{ - {160, " >● " + product + " 12 want you · 4 moving · $123.45 / " + railFigure(500) + " · " + clock}, - {60, " >● " + product + " 12 want you · 4 moving · $123.45 / " + railFigure(500)}, - {47, " >● " + product + " 12 want you · 4 moving · $123.45"}, - {40, " >● " + product + " 12 want you · 4 moving"}, - {30, " >● " + product + " 12 want you"}, - {16, " " + product}, + seen[s] = true + } + for _, want := range []state{ + {true, true, true, true, true, true, true}, + {false, true, true, true, true, true, true}, + {false, false, true, true, true, true, true}, + {false, false, false, true, true, true, true}, + {false, false, false, false, true, true, true}, + {false, false, false, false, false, true, true}, + {false, false, false, false, false, false, true}, + {false, false, false, false, false, false, false}, } { - line := plain(a.pulseLine(one.width, a.pal, pulseWhole)) - if squash(line) != squash(one.want) { - t.Fatalf("at %d columns the top line drew\n\t%q\nand it should have dropped whole segments by rank:\n\t%q", - one.width, line, one.want) - } - if got := ansi.StringWidth(line); got > one.width { - t.Fatalf("at %d columns the top line is %d cells wide and runs past the frame:\n\t%q", one.width, got, line) + if !seen[want] { + t.Fatalf("no width drew the rung %+v; the ladder skipped a step", want) } } // AND THE CLOCK IS STILL THE ONE SEGMENT A QUIET MORNING KEEPS. It is the - // lowest-ranked thing on the line and it is never EMPTY, which are two - // different laws: a machine with nothing stopped, nothing moving and nothing - // spent draws the name and the time. - a.machine = machineFacts{} - if line := plain(a.pulseLine(80, a.pal, pulseWhole)); !strings.Contains(line, clock) { - t.Fatalf("over a quiet morning the top line drew\n\t%q\nand it should be the name and the time:\n\t%q", line, " "+product+" "+clock) + // lowest-ranked thing on the line and it is never EMPTY: a machine with + // nothing stopped, nothing moving and nothing spent draws the time. + a.machine, a.host = machineFacts{}, "" + if line := plain(a.navLine(120, a.pal)); !strings.HasSuffix(strings.TrimRight(line, " "), clock) { + t.Fatalf("over a quiet morning the top line drew\n\t%q\nand it should end in the time", line) } } @@ -377,8 +376,10 @@ func TestTheTopLineGivesUpTheClockBeforeTheWorkCount(t *testing.T) { // no allowance with an empty numerator in front of it, no bare `$`. func TestANarrowTopLineNeverSaysTheDayCostNothing(t *testing.T) { a, _ := pulseLab(t) + a.showPage(pageNone) + a.machine = machineFacts{wants: 12, hands: 4, spent: 123.45, ceiling: 500} for width := 12; width <= 160; width++ { - line := plain(a.pulseLine(width, a.pal, pulseWhole)) + line := plain(a.navLine(width, a.pal)) switch { case strings.Contains(line, "$0.00"): t.Fatalf("at %d columns the top line drew\n\t%q\nover a day that spent $123.45; a dropped segment may not become a zero", width, line) diff --git a/internal/tui3/navmore.go b/internal/tui3/navmore.go new file mode 100644 index 0000000000..5fdc60e13d --- /dev/null +++ b/internal/tui3/navmore.go @@ -0,0 +1,209 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" +) + +// ── THE NAV'S FOLD: `more ▾` AND THE PLACES BEHIND IT ─────────────────────── +// +// A row too narrow for every place folds the trailing ones into `more ▾` +// (topnav.go), and a press on it hangs this menu under it, listing exactly the +// places it folded, each with the key that reaches it: +// +// ╭──────────────────╮ +// │ settings alt+6 │ +// │ standing alt+7 │ +// ╰──────────────────╯ +// +// It is modal as every menu here is (teammenu.go): while it is up it has the +// keyboard, `↑` `↓` walk it, `enter` goes to the place under the cursor and +// `esc` puts it away. A press on a row goes there; a press anywhere off it, +// `more ▾` included, only puts it away. IT NEVER MOVES FOCUS ANYWHERE ELSE: +// putting it away leaves the cursor, the draft and the page exactly as they +// were when it opened. + +// navMore is the fold's state: where its word was drawn and what it folded, +// whether its menu is up, the row the keyboard is on and the row the pointer +// is on, and where the last frame drew the menu, in frame cells. +type navMore struct { + // span is where `more ▾` was drawn on the nav's row, empty with nothing + // folded; folded is the places behind it, in the bar's order. + span hudSpan + folded []page + // hot is the pointer resting on `more ▾` itself. + hot bool + on bool + cursor int + // hover is the row the pointer is on, -1 for none. + hover int + card wallRect + hits []wallHit +} + +// navMoreFootWords is the hint line while the menu is up: its own keys, since +// they are the only keys that do anything. +const navMoreFootWords = "↑↓ choose · enter go · esc close" + +func (a *app) openNavMore() { + if len(a.navMore.folded) == 0 { + return + } + a.navMore.on, a.navMore.cursor, a.navMore.hover = true, 0, -1 + a.touch() +} + +func (a *app) closeNavMore() { + a.navMore.on, a.navMore.hover, a.navMore.card, a.navMore.hits = false, -1, wallRect{}, nil + a.touch() +} + +// navMoreHot records the pointer on or off `more ▾`, repainting only when +// that is news. +func (a *app) navMoreHot(on bool) { + if a.navMore.hot == on { + return + } + a.navMore.hot = on + a.touch() +} + +// navMoreGo is one place chosen from the menu. +func (a *app) navMoreGo(id page) tea.Cmd { + a.closeNavMore() + if a.headCovers() { + a.headUncover() + } + if id == a.navLit() { + return nil + } + return a.showPage(id) +} + +// navMoreKey is a key while the menu is up. +func (a *app) navMoreKey(msg tea.KeyPressMsg) tea.Cmd { + m := &a.navMore + switch msg.String() { + case "esc": + a.closeNavMore() + case "up", "k": + m.cursor = max(m.cursor-1, 0) + a.touch() + case "down", "j": + m.cursor = min(m.cursor+1, len(m.folded)-1) + a.touch() + case "enter", "space": + if m.cursor >= 0 && m.cursor < len(m.folded) { + return a.navMoreGo(m.folded[m.cursor]) + } + } + return nil +} + +// navMoreHitAt is the menu's row under the pointer on the last frame. +func (a *app) navMoreHitAt(x, y int) (wallHit, bool) { + for _, hit := range a.navMore.hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit, true + } + } + return wallHit{}, false +} + +// navMorePress answers a left press while the menu is up. +func (a *app) navMorePress(x, y int) tea.Cmd { + if hit, ok := a.navMoreHitAt(x, y); ok && hit.arg < len(a.navMore.folded) { + return a.navMoreGo(a.navMore.folded[hit.arg]) + } + if !a.navMore.card.holds(x, y) { + a.closeNavMore() + } + return nil +} + +// navMoreMotion lights the row under the pointer. +func (a *app) navMoreMotion(x, y int) { + hit, ok := a.navMoreHitAt(x, y) + under := -1 + if ok { + under = hit.arg + } + if under != a.navMore.hover { + a.navMore.hover = under + a.touch() + } +} + +// navMoreOver lays the menu over a finished frame, hung from `more ▾`, and +// writes down where its rows landed. With the menu down it hands the frame +// back as it was given. +func (a *app) navMoreOver(frame string) string { + if !a.navMore.on { + return frame + } + // A WIDER WINDOW UNFOLDS THE PLACES AND THE MENU GOES WITH THEM: a menu + // of nothing, or of words the row now shows, is not one to leave up. + if len(a.navMore.folded) == 0 || !a.navMore.span.pressable() { + a.navMore.on, a.navMore.card, a.navMore.hits = false, wallRect{}, nil + return frame + } + a.navMore.cursor = min(max(a.navMore.cursor, 0), len(a.navMore.folded)-1) + width, height := a.size() + card := a.navMoreCard(width, height) + a.navMore.hits = card.hits + if len(card.rows) == 0 { + a.navMore.card = wallRect{} + return frame + } + a.navMore.card = wallRect{card.x, card.y, card.x + card.w, card.y + len(card.rows)} + rows := strings.Split(frame, "\n") + for len(rows) < height { + rows = append(rows, "") + } + for dy, cr := range card.rows { + if y := card.y + dy; y >= 0 && y < len(rows) { + rows[y] = wallSplice(rows[y], cr, card.x, width) + } + } + return strings.Join(rows[:height], "\n") +} + +// navMoreCard is the menu as a card: one row per folded place, its word and +// its key, the row under the keyboard's cursor or the pointer on the cursor +// ground. It is hung on the row under the nav, its left edge under the fold's +// word and kept a cell inside the frame, and not drawn on a frame too small +// to hold it whole. +func (a *app) navMoreCard(width, height int) wallCard { + pal := a.pal + words, keys := 0, 0 + for _, id := range a.navMore.folded { + words = max(words, ansi.StringWidth(id.word())) + keys = max(keys, ansi.StringWidth(a.chords.say(placeChord(id)))) + } + const padX = 1 + inner := 1 + words + 2 + keys + 1 + w := inner + 2 + 2*padX + top := navRow + 1 + if w > width-2 || top+len(a.navMore.folded)+2 > height { + return wallCard{} + } + x := min(max(a.navMore.span.from, 1), width-1-w) + lines := make([]wallCardLine, 0, len(a.navMore.folded)) + for i, id := range a.navMore.folded { + word := id.word() + key := a.chords.say(placeChord(id)) + ink := pal.ink + if id == a.navLit() { + ink = func(s string) string { return pal.bold(pal.accent(s)) } + } + s := " " + ink(word) + strings.Repeat(" ", words-ansi.StringWidth(word)+2) + pal.dim(key) + " " + lit := a.navMore.hover == i || (a.navMore.hover < 0 && a.navMore.cursor == i) + lines = append(lines, wallCardLine{ + s: wallPopRowPaint(pal, s, inner, lit), + hits: []wallHit{{x0: 0, y0: 0, x1: inner, y1: 1, kind: wallHitPopRow, arg: i}}, + }) + } + return wallCardBuild(pal, "", lines, x, top, w, padX, 0) +} diff --git a/internal/tui3/offlooplaw_test.go b/internal/tui3/offlooplaw_test.go index 3bc524cecc..60b50aebfb 100644 --- a/internal/tui3/offlooplaw_test.go +++ b/internal/tui3/offlooplaw_test.go @@ -435,6 +435,8 @@ var doorsBesideTheLine = map[string]string{ "PlanRunSummary": "reads the run's stored summary for a refresh nobody pressed for", "PlanTasks": "reads the run's rows for the side list after a message; nobody pressed for it, and a verb's own read is asked only once the verb has landed", "RefreshRunSummary": "asks a model for the run's summary under a budget of seconds; nobody pressed for it and no gesture depends on it", + "NameTeam": "asks a model for a suggested team name under a budget of seconds; it changes nothing on the engine, typing overrides it, and a message sent while it thinks must not wait behind it", + "ProposeTeams": "asks a model for Organize's proposals under a budget of seconds; it changes nothing on the engine (Apply writes through the teams store), and nothing after it depends on the engine having seen it", } func TestOnlyReadsNobodyPressedForAreAskedBesideTheLine(t *testing.T) { diff --git a/internal/tui3/onboarding.go b/internal/tui3/onboarding.go index 24b657b2e0..72ee472760 100644 --- a/internal/tui3/onboarding.go +++ b/internal/tui3/onboarding.go @@ -1658,7 +1658,7 @@ func (a *app) setupControlsKeys(width int) string { // THE WAY OUT IS SECOND AND NOT LAST. At forty columns a legend has room // for about two clauses, and of everything a chooser could teach, "this // key leaves without choosing" is the one a person cannot guess. - parts = []string{"enter takes it", "esc cancels", "↑↓ choose"} + parts = []string{"enter takes it", "esc cancel", "↑↓ choose"} if s.modelOpen { parts = append(parts, "type to narrow") } diff --git a/internal/tui3/onetopbar_test.go b/internal/tui3/onetopbar_test.go new file mode 100644 index 0000000000..d47682dbee --- /dev/null +++ b/internal/tui3/onetopbar_test.go @@ -0,0 +1,74 @@ +package tui3 + +import ( + "strings" + "testing" +) + +// barGeometry reads one head row: the row it is on, the column its first word +// starts in, and the blank cells between that word and the next item. +func barGeometry(frame, first string) (y, x, gap int) { + for i, r := range strings.Split(plain(frame), "\n") { + at := strings.Index(r, first) + if at < 0 { + continue + } + rest := r[at+len(first):] + return i, at, len(rest) - len(strings.TrimLeft(rest, " ")) + } + return -1, -1, -1 +} + +// ONE TOP NAV. A conversation and a place draw the same nav: the places on the +// wordmark's row, in the same cells, with the same air between two words. The +// strip of chats is the next row only in a conversation. On a place that row +// is the rule. The one thing that differs on row zero is which word is lit: +// `chats` over a conversation, the place over a place. +func TestOneTopNavOnAChatAndOnAPlace(t *testing.T) { + for _, width := range []int{80, 110, 160} { + a, _, _, _ := trafficApp(t) + a.open = func(workspace, transcript string) (Conversation, error) { return Conversation{}, nil } + a.welcome.open = false + a.railAway = true + a.width, a.height = width, 24 + a.touch() + chat, _, _ := a.frame() + cy, cx, cgap := barGeometry(chat, " home ") + chatSpans := append([]placeTabSpan(nil), a.tabs...) + walkTo(t, a, pageSpend) + frame, _, _ := a.frame() + py, px, pgap := barGeometry(frame, " home ") + if cy != navRow || py != navRow || a.tabRow != navRow { + t.Fatalf("at %d the nav is on row %d in the chat and %d on the place", width, cy, py) + } + if cx != px || cgap != pgap || pgap != len(tabPad) { + t.Fatalf("at %d the navs differ: chat x %d gap %d, place x %d gap %d", width, cx, cgap, px, pgap) + } + if len(chatSpans) != len(a.tabs) { + t.Fatalf("at %d the chat's nav has %d buttons and the place's %d", width, len(chatSpans), len(a.tabs)) + } + for i := range chatSpans { + if chatSpans[i] != a.tabs[i] { + t.Fatalf("at %d the button %d moved between the chat and the place: %+v, %+v", width, i, chatSpans[i], a.tabs[i]) + } + } + // THE STRIP IS UNDER THE NAV IN THE CHAT, and absent on the place. + if sy, _, _ := barGeometry(chat, "harbor ▾"); sy != tabStripRow { + t.Fatalf("at %d the chat's strip is on row %d", width, sy) + } + if py2, _, _ := barGeometry(frame, "harbor ▾"); py2 >= 0 { + t.Fatalf("at %d the place drew the strip on row %d", width, py2) + } + placeRows := strings.Split(plain(frame), "\n") + if len(placeRows) <= placeHeadRows || !strings.HasPrefix(placeRows[1], "─") || strings.TrimSpace(placeRows[2]) != "" { + t.Fatalf("at %d the place's head is not the nav, the rule and a blank", width) + } + lit := a.pal.onPlaces() + if !strings.Contains(frame, lit.bold(lit.accent(tabPad+"spend"+tabPad))) { + t.Fatalf("at %d the place you stand in is not lit in the accent", width) + } + if a.tabActivePaint(" x ") != activeGround(a.pal, " x ") { + t.Fatal("the chat strip's tab in front has a ground of its own") + } + } +} diff --git a/internal/tui3/pages.go b/internal/tui3/pages.go index abf9608cfc..baa4142a75 100644 --- a/internal/tui3/pages.go +++ b/internal/tui3/pages.go @@ -49,6 +49,13 @@ const ( pageSpend pageSearch pageSettings + // pageTeams is the team-level view (place_teams.go). It is appended rather + // than put after pageHome because the ids are only names: the order a + // person meets the places in is [placeOrder]'s, and nothing stores an id. + pageTeams + // pageChats is the bar's way back to the conversations (place_chats.go): + // never stood in, only walked out through. + pageChats ) // ── THE CONTRACT EVERY PLACE ANSWERS ──────────────────────────────────────── @@ -243,6 +250,11 @@ type place interface { // hint is the line under the composer: what the row under the cursor can be // asked for, and how to leave. hint(a *app) string + // about is what this place holds, in the few words the hint line has room + // for while the pointer rests on the place's word on the nav (topnav.go's + // [app.headHint]): `the teams you hand work to`. Like `hint` it has no + // default, so a place added later says what it is for or does not build. + about() string // changed is the tab's count: how many things in here have moved since the // person last looked at this place. changed(a *app, since time.Time) int @@ -366,18 +378,20 @@ func (placeBase) caretRow(a *app, width int, rows []placeRow) (int, int, bool) { var placeRegistry = map[page]place{} // placeOrder is the whole set, in the one order that matters: `alt+1` through -// `alt+7`, and — for the first [placeBarPlaces] of them — left to right along +// `alt+9`, and, for the first [placeBarPlaces] of them, left to right along // the tab bar and round the circle `tab` walks. // // THE BAR IS FOUR PLACES AND HOME IS THEIR SUMMARY (DESIGN.md's law 10). What -// wants you and what is running (home), the work itself (tasks), what it cost -// (spend), and how this machine is set (settings). Standing, memory and search -// come after them: still rooms, still reached by `/standing`, `/memory` and -// `/search`, by the typed box's place offers, by `alt+5`…`alt+7` and by the -// map — but not drawn on a bar a person reads a hundred times a day, until they -// are the rooms a person walks into a hundred times a day. -// -// THE THREE KEEP A DIGIT EACH so a hand that learned `alt+5` finds a room there +// wants you and what is running (home), the work itself (sessions, the tasks +// place), what it cost (spend), and how this machine is set (settings), with +// teams and the way back to the chats between home and the work. Standing, +// memory and search come after them: still rooms, still reached by +// `/standing`, `/memory` and `/search`, by the typed box's place offers, by +// `alt+7`…`alt+9` and by the map, but not drawn on a bar a person reads a +// hundred times a day, until they are the rooms a person walks into a hundred +// times a day. +// +// THE THREE KEEP A DIGIT EACH so a hand that learned `alt+7` finds a room there // rather than a key that does nothing. // // IT IS A LIST HERE AND NOT AN `init` ORDER. Go runs a package's `init`s in @@ -385,11 +399,16 @@ var placeRegistry = map[page]place{} // bar's reading order at the mercy of what a file happens to be called — and // `place_home.go` sorts after `place_tasks.go` would silently reorder the bar // and every number on it. -var placeOrder = []page{pageHome, pageTasks, pageSpend, pageSettings, pageStanding, pageMemory, pageSearch} +// +// TEAMS IS SECOND AND THE CHATS THIRD (the owner's order, 2026-09-24). Teams +// is where a person runs the work they handed off (place_teams.go, DESIGN.md +// section 8.4), so it is read as often as home is; the chats (place_chats.go) +// are the room a person came from, and goes back to more than to any other. +var placeOrder = []page{pageHome, pageTeams, pageChats, pageTasks, pageSpend, pageSettings, pageStanding, pageMemory, pageSearch} // placeBarPlaces is how many of [placeOrder] the tab bar draws: the four a day -// is read through. -const placeBarPlaces = 4 +// is read through, teams beside home, and the way back to the chats. +const placeBarPlaces = 6 // barPages is the places the bar draws while a person stands at `here`: the // first [placeBarPlaces], and the room they are standing in when it is one of @@ -438,7 +457,19 @@ func registerPlace(p place) { // pages is every place in digit order, read from the registry's order table. // The bar draws a prefix of it ([barPages]). -func pages() []page { return placeOrder } +// +// THE CHATS ARE ON THE BAR AND NOT AMONG THE ROOMS: `chats` is the way out of +// the places (place_chats.go), so what is counted, listed on home and walked +// as a room is every other word. +func pages() []page { + rooms := make([]page, 0, len(placeOrder)-1) + for _, id := range placeOrder { + if id != pageChats { + rooms = append(rooms, id) + } + } + return rooms +} // placeWordList is the seven words in digit order, for the one sentence on the // key sheet that has to say which digit is which (commands.go). @@ -561,105 +592,18 @@ func (a *app) placeCount(id page) int { return 0 } -// ── the tab bar ───────────────────────────────────────────────────────────── - -// placeTabBar is the second row of every place: the four words ([barPages]), the -// one you are standing in wearing the band, and a number beside any place that -// has something new in it. -// -// IT IS [sheetTabBar] WITH THE TITLES PASSED IN, and it is drawn with that -// function's own geometry — [tabLead], [tabGap], [tabPad] — for the reason that -// function's comment already gives: "this panel IS a tab bar — the same object -// the task strip is, drawn the same way, so that 'which page am I on' is one -// visual question across the app rather than two". The settings panel keeps its -// own inner bar under this one, and the two are told apart by what they are -// made of rather than by a decoration: this one is the places, that one is -// settings' own sections. -// -// ── THE WIDTH LADDER ──────────────────────────────────────────────────────── -// -// A bar that is cut in half is a bar that lies about how many places there are, -// so it gives up words in a stated order rather than being trimmed: -// -// 1. every word, every count, with the bar's own air between the chips — -// while they fit; -// 2. EVERY WORD AGAIN, WITH THE AIR GIVEN UP. When the bar was seven words, -// they and the padding each chip carries were fifty-seven cells and the air -// between them six more, so a sixty-column terminal — a split pane, an ssh -// session from a train, a phone — overshot by three and fell all the way -// past the middle rung to the single word `home`, because on a quiet machine -// no place wears a count. The words are what this row is FOR and the space -// between them is not, so the space is what goes first. -// 3. as many words as fit, in the bar's own order, always carrying the place -// you are standing in and any place wearing a count, and ending with a dim -// count of the places that did not fit ([barMoreWord]). -// -// THE BAR IS THE SIGN AND THE FOOT IS THE ROUTE. A row this narrow cannot say -// `tab next place` as well as the words — at rung 3 there are not seven cells -// spare for it — so what the bar owes a person is that the other rooms EXIST, -// and the key that reaches them is on the foot of every place -// ([placeHintTail]), which [hintFit] protects to the last cell there is. A bar -// collapsed to the word `home` said neither of those things, and every other -// place was undiscoverable on exactly the tier where a person is least able to -// go looking for them. -// -// `numbered` is the map ([app.mapShowing]): every chip grows the digit that -// jumps to it, in the cells the words were already in, and the places off the -// bar are drawn after them with theirs — nothing moves that a person has to -// re-find when the map goes away, and the three digits the bar does not show -// are shown where the keys are. -func (a *app) placeTabBar(width int, numbered bool, pal palette) string { - every := func(page) bool { return true } - if full, spans, ok := a.tabBarAt(width, numbered, pal, every, tabGap, 0); ok { - a.tabs = spans - return a.placeBarMachine(full, width, pal) - } - if tight, spans, ok := a.tabBarAt(width, numbered, pal, every, 0, 0); ok { - a.tabs = spans - return a.placeBarMachine(tight, width, pal) - } - keep, elided := a.barWordsAt(width, numbered) - some, spans, _ := a.tabBarAt(width, numbered, pal, func(id page) bool { return keep[id] }, 0, elided) - a.tabs = spans - return a.placeBarMachine(some, width, pal) -} - -// barMoreWord is the count of places a narrow bar could not carry, in the -// spellings [rowfit.go]'s law 2 asks a fact to degrade through: `▸ 3 more` while -// there are cells for it, and `▸ 3` when there are not. -// -// IT IS THE SURFACE'S ONE FOLD SENTENCE ([foldSpellings]) AND NO LONGER A `+`. -// This row and the command menu's own tail mean the same thing — a navigation -// list has more items than fit — and they were two writers with two spellings: -// `+3 more` here against `▸ 3 more` there, so a person could not tell whether -// `+3` was a count, a badge or a door. The mark is the half that says which, and -// it is on every rung of the ladder: the word `more` gives way before `▸` does. -// -// IT IS A SIGN AND NOT A DOOR, and that is decided rather than unfinished: it -// opens nothing, wears no cursor and claims no span, exactly as the machine's -// name at the other end of this row does ([placeBarMachine]). A chip that -// carried a press would have to pick one of the places it stands for, and the -// key that reaches them all in order is `tab`. -func barMoreWord(n, room int) string { - if n <= 0 { - return "" - } - for _, say := range foldSpellings(n, "") { - if tabPadCols+ansi.StringWidth(say) <= room { - return say - } - } - // AND A FRAME WITH NO ROOM EVEN FOR `+6` SAYS NOTHING, rather than running - // past its own edge. A count that overflowed the row would be this ladder - // committing the fault it exists to prevent. - return "" -} +// ── the places' words on the nav ──────────────────────────────────────────── +// +// THE PLACES ARE DRAWN ON THE HEAD'S FIRST ROW, after the wordmark, on every +// page (topnav.go). They used to be a bar of their own on the second row of a +// place and nowhere else, taking turns with the chat strip; what is left here +// is what the nav reads about each place. -// barChipWord is the word one place's chip carries: its own word, the digit the -// map grows in front of it, and the count behind it. It is factored out of -// [app.tabBarAt] so the ladder can MEASURE a chip without painting one, and so -// the measurement and the paint can never come to disagree about how wide a -// word is. +// barChipWord is the word one place's button carries: its own word, the digit +// the map grows in front of it, and the count behind it. It is factored out so +// the nav's ladder can MEASURE a button without painting one, and so the +// measurement and the paint can never come to disagree about how wide a word +// is. func (a *app) barChipWord(id page, numbered bool) string { word := id.word() if numbered { @@ -671,102 +615,13 @@ func (a *app) barChipWord(id page, numbered bool) string { return word } -// barWordsAt chooses the words a bar too narrow for all seven carries, and says -// how many it had to leave off. -// -// THE MANDATORY HALF FIRST: the place you are standing in and the word under the -// cursor may never go ([app.barKeeps] holds that argument), and neither may a -// place wearing a count, because a number is this row saying something moved in -// a room you are not standing in. -// -// THEN THE ROW IS FILLED IN THE BAR'S OWN ORDER AND STOPS AT THE FIRST WORD -// THAT WILL NOT FIT — [rowfit.go]'s law 3 said about words instead of facts. A -// fill that skipped `standing` because `spend` was shorter would draw a -// different four places at every width, and `alt+1` … `alt+7` name positions -// that never move; a prefix plus your own word is a reading a person can learn. -// -// The count's own cells are reserved out of the fill, measured against the -// longest spelling this row could end up drawing, because a bar that spent its -// last cells on one more word and then had no room to say two others exist -// would be the collapse this ladder is here to prevent, one word later. -func (a *app) barWordsAt(width int, numbered bool) (map[page]bool, int) { - shown := barPages(a.page, numbered) - cost := func(id page) int { return ansi.StringWidth(a.barChipWord(id, numbered)) + tabPadCols } - keep := make(map[page]bool, len(shown)) - spent := tabLead - for _, id := range shown { - if a.barKeeps(id) || a.placeCount(id) > 0 { - keep[id] = true - spent += cost(id) - } - } - folds := foldSpellings(len(shown), "") - reserve := tabPadCols + ansi.StringWidth(folds[len(folds)-1]) - for _, id := range shown { - if keep[id] { - continue - } - if spent+cost(id)+reserve > width { - break - } - keep[id] = true - spent += cost(id) - } - elided := 0 - for _, id := range shown { - if !keep[id] { - elided++ - } - } - return keep, elided -} - -// placeMachineLead is the word in front of the machine's name at the right end -// of the bar. It is there so that a bare `spark` in the row the seven places are -// drawn in cannot be read as an eighth place. +// placeMachineLead is the word in front of the machine's name on the nav's far +// end. It is there so that a bare `spark` on the row the places are drawn in +// cannot be read as one more place. const placeMachineLead = "on " -// placeBarMachine puts the MACHINE THESE PLACES ARE ABOUT at the right end of -// the tab bar, and puts nothing there at all on a local session. -// -// THE PLACES FOLLOW THE SESSION'S MACHINE NOW, AND A ROOM THAT MOVED WITHOUT -// SAYING SO WOULD BE THE SAME FAULT WALKED BACKWARDS. Home used to draw one -// sentence saying its rows belonged to the wrong machine; it draws the right -// machine's rows instead ([app.readWorld]) — so the thing a person cannot see -// any more is WHOSE work they are reading, and the fix is a name rather than a -// sentence, because it is true on every frame of every place rather than in one -// state of one of them. -// -// IT IS [app.host] AND NOT A SECOND SPELLING OF IT. The status line's place -// segment writes `spark:app`, /status writes `spark:/srv/code/app`, and the -// legend under the input writes `spark · porting the parser` — three renderings -// of one field, which host.go's header states as the law that the connection is -// shown as the place and nowhere else. This is the fourth, and it is the machine -// alone because a place is a listing of a whole disk rather than of one -// workspace. -// -// AND IT DISAPPEARS COMPLETELY ON A LOCAL SESSION, which is the test host.go -// holds every indicator to: it is invisible when there is nothing to say. It -// also gives up its cells before the bar gives up a word — the places are what -// the row is for, and a name that pushed `search` off the end would be telling -// somebody about a machine instead of about their own rooms. -func (a *app) placeBarMachine(bar string, width int, pal palette) string { - name := strings.TrimSpace(a.host) - if name == "" { - return bar - } - word := placeMachineLead + name - used, room := ansi.StringWidth(bar), ansi.StringWidth(word) - // tabLead's worth of air at each end, and tabGap between the last chip and - // the name, so the row breathes the way every other row of this bar does. - if used+tabGap+room+tabLead > width { - return bar - } - return bar + strings.Repeat(" ", width-used-room-tabLead) + pal.dim(word) -} - -// barKeeps is the word the ladder may never give up: the place you are standing -// in, and — while the cursor is on the bar — the word the cursor is on. +// barKeeps is the word the nav's ladder may never fold: the place you are +// standing in, and, while the cursor is on the bar, the word the cursor is on. // // A CURSOR ON A WORD THE LADDER DROPPED WOULD BE A CURSOR NOBODY CAN SEE, which // is SCREEN 3a's clause said about a row rather than a key: nothing on this @@ -777,11 +632,11 @@ func (a *app) barKeeps(id page) bool { return id == a.page || (a.bar.on && id == a.bar.at) } -// placeTabSpan is where one place's CHIP sits on the bar, so the draw and the +// placeTabSpan is where one place's BUTTON sits on the nav, so the draw and the // press agree about it. It is the settings panel's [tabSpan] with the place it -// belongs to carried on it — the bar gives up words as the frame narrows -// (the ladder above), so a span computed from the list of places rather than -// from the bar that was actually painted would open whichever room happened to +// belongs to carried on it: the nav folds words as the frame narrows +// (topnav.go's ladder), so a span computed from the list of places rather than +// from the row that was actually painted would open whichever room happened to // sit at that position on a wider terminal. // // It covers the chip's padding as well as its word, for the reason [tabSpan] @@ -792,75 +647,6 @@ type placeTabSpan struct { from, to int } -// tabBarAt draws the bar over the places `keep` admits, says where each chip -// landed, and says whether it fit. -// -// `gap` is the air between two chips, which the ladder above gives up before it -// gives up a word, and `elided` is how many places are not on this bar at all — -// drawn as [barMoreWord] at the end of the row, in the cells that are left. -func (a *app) tabBarAt(width int, numbered bool, pal palette, keep func(page) bool, gap, elided int) (string, []placeTabSpan, bool) { - line, plain := strings.Repeat(" ", tabLead), strings.Repeat(" ", tabLead) - shown := barPages(a.page, numbered) - spans := make([]placeTabSpan, 0, len(shown)) - at, first := tabLead, true - for _, id := range shown { - if !keep(id) { - continue - } - if !first { - line += strings.Repeat(" ", gap) - plain += strings.Repeat(" ", gap) - at += gap - } - first = false - // THE MAP GROWS THE NUMBER IN THE CELL THE WORD WAS ALREADY IN - // (SCREEN 3b). Nothing shifts, nothing pops up, and letting go of the - // map leaves the bar exactly where the eye left it ([app.barChipWord]). - word := a.barChipWord(id, numbered) - chip := tabPad + word + tabPad - band := ansi.StringWidth(word) + tabPadCols - switch { - case a.bar.on && id == a.bar.at: - // THE CURSOR'S OWN BAND, AND IT REPLACES THE SELECTED MARK RATHER THAN - // STACKING ON IT. While the cursor is up here the bar is the row a - // person is standing on, and the question the frame has to answer is - // "where is my cursor" — not "which room am I in", which the body - // underneath is already answering with every one of its rows. Two - // grounds on one word would be the screen saying both at once and - // neither clearly ([barCursor]). - line += pal.cursor(pal.bold(pal.ink(chip)), band) - case id == a.page: - // THE WORD YOU ARE STANDING IN IS TIER 1, BOLD, AND NOT AN ACCENT. - // SCREEN 2a's first level is spelled out: "1 · page — bright, bold, - // one word, only in the tab bar", and the accent on a place is spent - // on the two live states and on nothing else (styles.go's THE - // ONE-ACCENT LAW). The band under it is what says "here". - line += pal.selected(pal.bold(pal.ink(chip)), band) - case id == a.tabHover: - // AND THE POINTER LIFTS THE WORD AND DOES NOTHING ELSE: the selected - // word's own ink and weight, with no band under it. A word that grew a - // ground on hover would look like the room a person was standing in, - // and a bar with two banded words on it says nothing at all; a word - // that lifted a tier says "this one is a door", which is the whole of - // what a pointer resting on it has learned. - line += pal.bold(pal.ink(chip)) - default: - line += pal.dim(chip) - } - plain += chip - spans = append(spans, placeTabSpan{id: id, from: at, to: at + ansi.StringWidth(chip)}) - at += ansi.StringWidth(chip) - } - // AND THE COUNT OF WHAT IS NOT HERE RIDES THE END OF THE ROW, with no span - // behind it: it is a sign, and [barMoreWord] says why it is not a door. - if more := barMoreWord(elided, width-ansi.StringWidth(plain)); more != "" { - chip := tabPad + more + tabPad - line += pal.dim(chip) - plain += chip - } - return line, spans, ansi.StringWidth(plain) <= width -} - // ── THE BAR IS A ROW THE CURSOR CAN STAND ON ──────────────────────────────── // barCursor is the tab bar as a ROW, and not only as a set of targets. @@ -962,7 +748,7 @@ func (a *app) barWalk(back bool) { // THE CURSOR COMES DOWN EITHER WAY. Pressing the word you are already standing // in is not a door — going there would close and reopen the room, throwing away // the filter somebody typed and the row they were on, which is the same law the -// pointer already keeps ([app.placeTabPress]) — so it simply puts the cursor +// pointer already keeps ([app.navPress]), so it simply puts the cursor // back in the body. func (a *app) barEnter() tea.Cmd { at := a.bar.at @@ -984,7 +770,7 @@ func (a *app) barEnter() tea.Cmd { // on. Anywhere else `↑` is the walk it has always been, and the place keeps it. func (a *app) barReach() bool { pl := a.showing() - if pl == nil || a.bar.on || a.tabRow < 1 { + if pl == nil || a.bar.on || a.tabRow < 0 { return false } // HOME'S COLUMN HAS NO WAY UP ONTO THE BAR (owner, 2026-09-17: "don't let @@ -1032,9 +818,9 @@ func (a *app) barKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { a.barDrop() return nil, true case "up", "ctrl+p": - // THERE IS NOTHING OVER THE BAR. Row zero is the pulse, which is telemetry - // and not a control, so `↑` here is a key that has arrived at the top — - // swallowed rather than falling through into the body it just left. + // THERE IS NOTHING OVER THE BAR. It is row zero, the nav itself, so `↑` + // here is a key that has arrived at the top, swallowed rather than + // falling through into the body it just left. return nil, true } // AND EVERY PRINTABLE CHARACTER GOES WHERE IT ALWAYS GOES, taking the cursor @@ -1149,10 +935,9 @@ func placeLineHits(hits []placeHit) []int { return placeHitsOf(hits, -1) } // placeFrame is THE frame. Every place is drawn in it, and the head, the foot // and the clamp below belong to the router rather than to any place: // -// row 0 the pulse — this machine's vital signs (pulse.go) -// row 1 the tab bar — the seven places, and where you are -// row 2 a dim rule -// row 3 blank +// row 0 the nav: the wordmark, the places, the pulse (topnav.go) +// row 1 a dim rule +// row 2 blank // ... the body — the place's own rows // ... blank, then a dim rule // ... the composer, with the scope chip at the right of its box row @@ -1201,16 +986,10 @@ func placeFrameWithBar(a *app, width, height int, hits = append(hits, hit) } - // THE HEAD IS THE CONVERSATION'S HEAD, drawn by the same function with the - // bar as its middle row (head.go). - // - // THE BAR IS ROW ONE AND THE POINTER IS TOLD SO HERE. A press arrives as a - // row of the terminal, and the only honest way to know which row the bar - // ended up on is to record it where it was drawn — the clamp below can cut - // it off a frame too short for its own contents, and a press resolved - // against a constant would then open a place for a click on a body row. - a.tabRow = placeTabRow - for _, row := range a.headRows(width, a.placeTabBar(width, a.mapShowing, pal), pal) { + // THE HEAD IS THE NAV, THE RULE AND A BLANK. The strip is a chat's row and + // is not drawn on a place (head.go), so this frame does not lay it out and + // does not keep its hit spans. + for _, row := range a.headRows(width, "", pal) { add(row, nil) } @@ -1555,11 +1334,11 @@ func placeFrameWithBar(a *app, width, height int, if len(lines) > height { removed := len(lines) - height - // A FRAME TOO SHORT FOR ITS OWN CONTENTS LOSES THE BAR, and the pointer - // is told that too: -1 is "there is no tab bar on this frame", which is - // the only answer that cannot turn a press on a body row into a place - // change. - a.tabRow = -1 + // A FRAME TOO SHORT FOR ITS OWN CONTENTS KEEPS THE NAV. A place draws + // no strip, so there is no strip row to give back; the targets are + // cleared anyway so a stale span from a chat cannot catch the press. + a.chatTabHits = nil + a.wall.chip, a.wall.door = hudSpan{}, hudSpan{} keep, keepHits := lines[:1], hits[:1] lines = append(keep, lines[len(lines)-(height-1):]...) hits = append(keepHits, hits[len(hits)-(height-1):]...) @@ -1716,7 +1495,7 @@ const ( // it where the place declares no verbs). // // IT SAYS WHAT THE KEY DOES. It read `→ verbs on this row`, which named a - // CATEGORY on a line where `alt+1…7 go to a place`, `alt+enter send it off as + // CATEGORY on a line where `alt+1…9 go to a place`, `alt+enter send it off as // a task` and `esc close` all name an act — and `verbs` is the machinery's // word for the strip rather than anybody's word for what pressing `→` gets // them. The card's own `→ verbs: pause, stop` keeps the noun because the acts @@ -1725,7 +1504,7 @@ const ( placeMapVerbWords = "→ show what this row can do" // placeMapWords is the hint line while the map is drawn (SCREEN 3b): the // chord list, in the cells the hint was already in. - placeMapWords = "alt+1…7 go to a place · " + placeMapTaskWords + " · " + + placeMapWords = "alt+1…9 go to a place · " + placeMapTaskWords + " · " + placeMapVerbWords + " · " + mapCloseWords // placeMapTaskWords is the map's clause about the chord that starts a task, // named so the line can be drawn WITHOUT it: only home starts things, so on @@ -1850,13 +1629,19 @@ func (a *app) placeHintSaid() string { if a.hopShowing() { return hopFootWords } + // AND A WORD OF THE HEAD UNDER THE POINTER SAYS WHAT IT OPENS AND ITS KEY + // (topnav.go's [app.headHint]), over every resting sentence, because the + // pointer on it is a person asking exactly that. + if hint := a.headHint(); hint != "" { + return hint + } if a.mapShowing { // THE SWITCHER IS NAMED ON THE MAP AND NOWHERE ELSE ON A PLACE. The map // is this surface's own chord list — the one line whose job is to say // what the keys are — and the place's resting foot is four clauses that // the design fixes word for word (FIDELITY.md item 3). A key bound on // every place and drawn on none of them would break SCREEN 3a's clause, - // and this is the line that keeps it, exactly as it keeps the `ctrl+1…7` + // and this is the line that keeps it, exactly as it keeps the `ctrl+1…9` // alias ([chordSpelling.mapLine]). line := a.chords.mapLine(a.placeMapSaid(), a.ctrlDigits()) if a.hopAvailable() { @@ -2239,6 +2024,11 @@ func (a *app) placeMsgLine(width int) (string, bool) { // ([place.remote]), which is still the place being open and saying why it is // empty. func (a *app) showPage(id page) (cmd tea.Cmd) { + // THE CHATS ARE THE ROAD OUT, not a room (place_chats.go): every door that + // names them, the bar, the digit and the cursor, arrives here. + if id == pageChats { + return a.goChats() + } if a.startingChat() { back := a.parkChatStart() defer func() { cmd = tea.Batch(back, cmd) }() @@ -2263,6 +2053,8 @@ func (a *app) showPage(id page) (cmd tea.Cmd) { a.standDownRest() a.closeStrip() a.mapShowing = false + // AND THE NAV'S FOLD MENU: it was a way to this door, and it is used. + a.navMore.on = false // AND THE COMPOSER LAYER GOES WITH THE PLACE IT WAS OPENED ON. It names that // place in its own foot and dims that place's rows behind it; carried onto the // next room it would be a decision drawn over a page it was never about @@ -2410,7 +2202,15 @@ func (a *app) placeBodyWheel(delta int) (tea.Cmd, bool) { // THE CIRCLE IS THE BAR ([barPages]). `tab` is the bar walked by a key, so it // goes where the words are: the four, and the room you are standing in when it // is one of the three off the bar — from which `tab` goes on to home. -func nextPage(at page, back bool) page { return nextOn(barPages(at, false), at, back) } +func nextPage(at page, back bool) page { + // `tab` walks the rooms, and the chats are the way out of them rather than + // one of them (place_chats.go), so the walk steps over the word. + next := nextOn(barPages(at, false), at, back) + if next == pageChats { + next = nextOn(barPages(at, false), pageChats, back) + } + return next +} // nextOn is one step round a ring of places from `at`. func nextOn(all []page, at page, back bool) page { diff --git a/internal/tui3/pages_test.go b/internal/tui3/pages_test.go index 3b96075be0..417f91d35e 100644 --- a/internal/tui3/pages_test.go +++ b/internal/tui3/pages_test.go @@ -61,12 +61,23 @@ func placeFrameText(a *app) string { // agree with is the registry rather than a literal seven this file counted. What // is left here is the two facts that are about the EDGES of that list. func TestTheSevenPlacesAreOneList(t *testing.T) { - if len(pages()) != 7 { - t.Fatalf("there are %d places, and the design has seven", len(pages())) + if len(pages()) != 8 { + t.Fatalf("there are %d places, and the design has eight rooms", len(pages())) } - // AND alt+8 IS NOTHING, rather than the first place again. - if _, ok := placeDigit("alt+8"); ok { - t.Fatal("alt+8 reaches a place that does not exist") + // AND alt+0 IS NOTHING, rather than a tenth place: the nine digits are the + // eight rooms and the way back to the chats, teams second and the chats + // third (the owner's order). + if _, ok := placeDigit("alt+0"); ok { + t.Fatal("alt+0 reaches a place that does not exist") + } + if got, ok := placeDigit("alt+2"); !ok || got != pageTeams { + t.Fatalf("alt+2 reaches %q, not teams", got.word()) + } + if got, ok := placeDigit("alt+3"); !ok || got != pageChats { + t.Fatalf("alt+3 reaches %q, not the chats", got.word()) + } + if got, ok := placeDigit("alt+9"); !ok || got != pageSearch { + t.Fatalf("alt+9 reaches %q, not search", got.word()) } } @@ -94,7 +105,7 @@ func TestATabWearsNoCountUntilSomethingAnswersForIt(t *testing.T) { if a.places != nil { t.Fatal("a surface that has not counted yet wired a counter") } - bar := plain(a.placeTabBar(a.width, false, a.pal)) + bar := navPlaces(a, a.width, false) for _, digit := range "0123456789" { if strings.ContainsRune(bar, digit) { t.Fatalf("the bar wears a figure with nothing to count: %q", bar) @@ -210,38 +221,41 @@ func TestNothingIsEverPutBackBecauseNothingRefuses(t *testing.T) { // placelaws_test.go, over every registered place at six widths — [tierPhone] // among them, which this one never reached for the four places it did not name. -// THE TAB BAR GIVES UP WORDS IN A STATED ORDER RATHER THAN BEING CUT IN HALF. A -// bar trimmed mid-word is a bar lying about how many places there are. +// THE NAV FOLDS WORDS IN A STATED ORDER RATHER THAN BEING CUT IN HALF. A row +// trimmed mid-word is a row lying about how many places there are. // -// THE COUNT IS OF THE BAR'S OWN WORDS. The bar is four places (DESIGN.md's law -// 10); a fold that counted the three reached by command would say `▸ 5` over a -// bar that only ever had four to give up. -func TestTheTabBarFoldsRatherThanBeingCut(t *testing.T) { +// THE FOLD IS OF THE NAV'S OWN WORDS. The row is six places (DESIGN.md's law +// 10); a fold that stood for the three reached by command would offer rooms +// the row never had to give up. +func TestTheNavFoldsRatherThanBeingCut(t *testing.T) { a := placeApp(t) shown := barPages(a.page, false) - wide := plain(a.placeTabBar(160, false, a.pal)) + wide := navPlaces(a, 160, false) for _, id := range shown { if !strings.Contains(wide, id.word()) { - t.Fatalf("the wide bar is missing %q: %q", id.word(), wide) + t.Fatalf("the wide nav is missing %q: %q", id.word(), wide) } } - narrow := plain(a.placeTabBar(24, false, a.pal)) - if ansi.StringWidth(narrow) > 24 { - t.Fatalf("the narrow bar runs past its frame: %q", narrow) + narrow := navPlaces(a, 40, false) + if ansi.StringWidth(plain(a.navLine(40, a.pal))) > 40 { + t.Fatalf("the narrow nav runs past its frame: %q", narrow) } // AND WHAT SURVIVES IS THE PLACE YOU ARE STANDING IN. Everything else is - // something you can still reach; this is the one fact the bar exists for. + // something you can still reach; this is the one fact the row exists for. if !strings.Contains(narrow, a.page.word()) { - t.Fatalf("the narrow bar dropped the place you are on: %q", narrow) + t.Fatalf("the narrow nav dropped the place you are on: %q", narrow) } missing := 0 for _, id := range shown { if !strings.Contains(narrow, id.word()) { missing++ + if !pagesHold(a.navMore.folded, id) { + t.Fatalf("%q left the narrow nav and is not behind `more`: %q", id.word(), narrow) + } } } - if want := tokens.GlyphCollapsed + " " + itoa(missing); missing == 0 || !strings.Contains(narrow, want) { - t.Fatalf("the narrow bar left %d of its four words off and should end in %q: %q", missing, want, narrow) + if missing == 0 || missing != len(a.navMore.folded) || !strings.HasSuffix(narrow, a.navMoreWord(a.pal)) { + t.Fatalf("the narrow nav left %d of its words off and should end in `more ▾` over them: %q, %v", missing, narrow, a.navMore.folded) } } @@ -300,10 +314,10 @@ func TestTheMapDrawsInTheCellsThatWereAlreadyThere(t *testing.T) { t.Fatalf("the map moved the frame: %d rows became %d", len(before), len(after)) } // THE NUMBERS ARE ON THE TABS, and the three places off the bar are drawn - // after the four with theirs: the map is the one surface whose job is to show - // every key, so `alt+5`…`alt+7` are on it. - if bar := after[placeTabRow]; !strings.Contains(bar, "1 home") || !strings.Contains(bar, "4 settings") || - !strings.Contains(bar, "5 standing") || !strings.Contains(bar, "7 search") { + // after the six with theirs: the map is the one surface whose job is to show + // every key, so `alt+7`…`alt+9` are on it. + if bar := after[navRow]; !strings.Contains(bar, "1 home") || !strings.Contains(bar, "2 teams") || !strings.Contains(bar, "3 chats") || + !strings.Contains(bar, "6 settings") || !strings.Contains(bar, "7 standing") || !strings.Contains(bar, "9 search") { t.Fatalf("the map put no numbers on the tab bar: %q", bar) } // AND THE CHORD LIST IS THE HINT LINE. @@ -699,7 +713,7 @@ func TestATabWearsTheCountTheSeamGivesIt(t *testing.T) { pageSpend.word(): 9, pageStanding.word(): 0, } - bar := plain(a.placeTabBar(160, false, a.pal)) + bar := navPlaces(a, 160, false) if !strings.Contains(bar, "sessions 2") { t.Fatalf("the tasks tab does not wear its count: %q", bar) } @@ -760,15 +774,9 @@ func TestEveryPlaceReachesEveryOtherPlace(t *testing.T) { } } -// placeAt is a place's position in [pages], which is the digit that jumps to it. -func placeAt(id page) int { - for i, at := range pages() { - if at == id { - return i - } - } - return -1 -} +// placeAt is a place's position on the bar, which is the digit that jumps to +// it less one. +func placeAt(id page) int { return placeDigitOf(id) - 1 } // AND THE NUMBERS WORK FROM THE CONVERSATION, which is the screen a person // spends most of the day on and was the one surface they did not work from. @@ -782,9 +790,9 @@ func TestTheNumbersOpenAPlaceFromTheConversationToo(t *testing.T) { if a.at(pageHome) { t.Fatal("esc did not put the conversation back") } - drive(t, a, key("alt+2")) + drive(t, a, key(placeChord(pageTasks))) if a.page != pageTasks || !a.at(pageTasks) { - t.Fatalf("alt+2 from the conversation landed on %q (open %v)", a.page.word(), a.at(pageTasks)) + t.Fatalf("%s from the conversation landed on %q (open %v)", placeChord(pageTasks), a.page.word(), a.at(pageTasks)) } drive(t, a, key("esc")) drive(t, a, key(placeChord(pageStanding))) @@ -800,18 +808,20 @@ func TestTheNumbersOpenAPlaceFromTheConversationToo(t *testing.T) { } } -// THE TAB BAR CARRIES ITS FOUR WORDS AT EVERY WIDTH A PERSON ACTUALLY USES, and -// only those four: `home tasks spend settings` (DESIGN.md's law 10). The ladder +// THE TAB BAR CARRIES ITS SIX WORDS AT EVERY WIDTH A PERSON ACTUALLY USES, and +// only those six: `home teams chats sessions spend settings` (DESIGN.md's law +// 10, with teams after home by the teams page ruling, c-2, and the chats third, +// the owner's order). The ladder // that gives words up is for terminals narrower than any of these -// ([app.placeTabBar]); at 80 columns and up nothing is dropped. Standing, +// (topnav.go); at 80 columns and up nothing is folded. Standing, // memory and search are rooms reached by command, by their digit and by the // map — not words on the row a person reads a hundred times a day. func TestTheTabBarCarriesTheFourAtEveryUsableWidth(t *testing.T) { a := placeApp(t) for _, width := range []int{80, 120, 200} { - bar := plain(a.placeTabBar(width, false, a.pal)) - if !strings.Contains(bar, "home sessions spend settings") { - t.Fatalf("at %d columns the bar is not the four places in order: %q", width, bar) + bar := navPlaces(a, width, false) + if !placeWordsInOrder(bar, "home", "teams", "chats", "sessions", "spend", "settings") { + t.Fatalf("at %d columns the bar is not the six places in order: %q", width, bar) } for _, id := range []page{pageStanding, pageMemory, pageSearch} { if strings.Contains(bar, id.word()) { @@ -822,7 +832,24 @@ func TestTheTabBarCarriesTheFourAtEveryUsableWidth(t *testing.T) { // AND A ROOM OFF THE BAR IS ON IT WHILE YOU STAND IN IT. A bar with no word // lit is a bar that does not know where you are. walkTo(t, a, pageMemory) - if bar := plain(a.placeTabBar(120, false, a.pal)); !strings.Contains(bar, "settings memory") { + if bar := navPlaces(a, 120, false); !strings.Contains(bar, "settings memory") { t.Fatalf("standing in memory, the bar does not say so: %q", bar) } } + +// placeWordsInOrder reports whether every word stands in text, each after the +// one before it and apart from its neighbours by spaces alone. +func placeWordsInOrder(text string, words ...string) bool { + at := 0 + for i, word := range words { + n := strings.Index(text[at:], word) + if n < 0 { + return false + } + if i > 0 && strings.TrimSpace(text[at:at+n]) != "" { + return false + } + at += n + len(word) + } + return true +} diff --git a/internal/tui3/palette.go b/internal/tui3/palette.go index c12953f9f9..efa0e15d55 100644 --- a/internal/tui3/palette.go +++ b/internal/tui3/palette.go @@ -3254,7 +3254,11 @@ func (a *app) overlayRows(width, n int) []string { case a.menu.open: return a.menu.rows(width, n, a.pal, hover, a.chords) case a.comp.open: - return a.comp.rows(width, n, a.pal, hover) + head := "" + if a.hot.kind == hoverOverlay { + head = a.hot.key + } + return a.comp.rows(width, n, a.pal, hover, head) } return nil } diff --git a/internal/tui3/pastechip.go b/internal/tui3/pastechip.go index 39301e347f..a8d35596fd 100644 --- a/internal/tui3/pastechip.go +++ b/internal/tui3/pastechip.go @@ -161,7 +161,8 @@ func (a *app) removePaste(s segment, held *pasteChip) { } func (a *app) pasteDraftBlock(width, rows int) ([]string, int, int) { - block, x, y := draftBlockWithTags(&a.input, a.pal, width, rows, "", a.roomLead(width), a.input.demotedTags, a.draftInk()) + block, x, y := draftBlockWithTags(&a.input, a.pal, width, rows, a.trafficHint(), a.roomLead(width), a.input.demotedTags, a.draftInk()) + block = a.paintDraftMentions(block) for i, line := range block { plainLine := ansi.Strip(line) for _, held := range a.pastes { diff --git a/internal/tui3/payload_test.go b/internal/tui3/payload_test.go index a586e8df75..49f4db8518 100644 --- a/internal/tui3/payload_test.go +++ b/internal/tui3/payload_test.go @@ -262,8 +262,8 @@ func TestTheHintGrammarReadsEveryHintThisSurfaceWrites(t *testing.T) { // question rather than written down (homeexchange.go's // [exchangeAnswerWords]): the digits the card drew, then the key that // asks for the box instead. - {"1 yes, set it up · 3 just once · 0 no · c change", - []string{"1", "3", "0", "c"}}, + {"1 Set it up · 3 Only now, don't repeat · 0 Don't set it up · o Change…", + []string{"1", "3", "0", "o"}}, {"1-3 shape · esc never mind", []string{"1-3", "esc"}}, {"y allow · n deny · a always", []string{"y", "n", "a"}}, {"↑↓ move · →← tree · enter open · alt+w wide · esc", diff --git a/internal/tui3/place_chats.go b/internal/tui3/place_chats.go new file mode 100644 index 0000000000..1e0c1a9f02 --- /dev/null +++ b/internal/tui3/place_chats.go @@ -0,0 +1,52 @@ +package tui3 + +import ( + tea "charm.land/bubbletea/v2" +) + +// ── THE WAY BACK TO THE CHATS ─────────────────────────────────────────────── +// +// The places' bar is where a person stands to read the machine, and until this +// it had no word for the one room they came from: the chats, the conversation +// surface with its tab strip. `esc` went back, and nothing on the bar said so. +// So the bar carries `chats`, third, right after home and teams: +// +// home teams chats sessions spend settings +// +// A press on it, its digit and `enter` on it with the bar's cursor all do one +// thing: the place closes and the conversation that was in front is in front +// again, as `esc` does; with no conversation open at all it opens a new chat. +// It is the word the key legend already says for the chats (`alt+k chats`), +// so one word means one thing; `alt+k` itself stays the chats SWITCHER, which +// chooses among them, where this goes back to the one you were in. +// +// IT IS A PLACE IN THE LIST AND NOT A ROOM. It is registered so the bar, the +// digits and the map read it off [placeOrder] like every other word, and +// [app.showPage] turns it into the road out before any place would open; it +// has no rows, no clock and no count. `tab`, which walks the rooms, steps over +// it ([nextPage]). + +// placeChats is the chats' word on the registry. +type placeChats struct{ placeBase } + +func init() { registerPlace(placeChats{}) } + +func (placeChats) id() page { return pageChats } +func (placeChats) word() string { return "chats" } +func (placeChats) cursorAt(a *app) int { return 0 } +func (placeChats) about() string { return "every conversation, one at a time" } + +func (placeChats) hint(a *app) string { return "back to your chats" } +func (placeChats) open(a *app) tea.Cmd { return nil } +func (placeChats) enter(a *app) tea.Cmd { return a.goChats() } + +// goChats is the way back: the place closes and the conversation in front is +// in front again, or, with none open, the new-chat page opens. +func (a *app) goChats() tea.Cmd { + a.showPage(pageNone) + a.touch() + if len(a.tabList()) == 0 && a.canStart() { + return a.openChatStart() + } + return nil +} diff --git a/internal/tui3/place_chats_test.go b/internal/tui3/place_chats_test.go new file mode 100644 index 0000000000..af7ffbb09b --- /dev/null +++ b/internal/tui3/place_chats_test.go @@ -0,0 +1,67 @@ +package tui3 + +import ( + "strings" + "testing" +) + +// THE NAV HAS A WAY BACK TO THE CHATS, third after home and teams, and a press on it, +// its digit and enter on it with the bar's cursor all do one thing: the place +// closes and the conversation that was in front is in front again. +func TestTheChatsOnTheBarGoBackToTheConversation(t *testing.T) { + a := placeApp(t) + front := a.file + bar := navPlaces(a, a.width, false) + if h, c, k := strings.Index(bar, "home"), strings.Index(bar, "chats"), strings.Index(bar, pageTasks.word()); h < 0 || c < h || k < c { + t.Fatalf("the bar does not read home, chats: %q", bar) + } + placeFrameText(a) + var chats placeTabSpan + for _, span := range a.tabs { + if span.id == pageChats { + chats = span + } + } + if chats.to == 0 { + t.Fatalf("the chats word has no span: %+v", a.tabs) + } + cmd, took := a.navPress(chats.from+1, a.tabRow) + if !took { + t.Fatal("the press on chats was not taken") + } + spend(t, a, cmd) + if a.pageShowing() || a.file != front { + t.Fatalf("the press left the router on %q with %q in front", a.page.word(), a.file) + } + a.openHome() + drive(t, a, key(placeChord(pageChats))) + if a.pageShowing() || a.file != front || placeChord(pageChats) != "alt+3" { + t.Fatalf("%s left the router on %q", placeChord(pageChats), a.page.word()) + } + // And `tab`, which walks the rooms, steps over it. + a.openHome() + drive(t, a, key("tab")) + if a.page != pageTeams { + t.Fatalf("tab from home landed on %q", a.page.word()) + } + drive(t, a, key("tab")) + if a.page != pageTasks { + t.Fatalf("tab from teams landed on %q, not past the chats", a.page.word()) + } +} + +// WITH NO CONVERSATION OPEN THE WAY BACK IS A NEW CHAT. +func TestTheChatsWithNothingOpenIsANewChat(t *testing.T) { + lab := newHomeLab(t) + a := lab.app("") + a.width, a.height = 120, 30 + a.start = func(string) (Conversation, error) { return Conversation{}, nil } + a.openHome() + if n := len(a.tabList()); n != 0 { + t.Fatalf("the fixture holds %d conversations", n) + } + drive(t, a, key(placeChord(pageChats))) + if a.pageShowing() || !a.startingChat() { + t.Fatalf("with nothing open the chats left %q up and no new chat (starting %v)", a.page.word(), a.startingChat()) + } +} diff --git a/internal/tui3/place_home.go b/internal/tui3/place_home.go index 35639a80f4..84a0bd19f2 100644 --- a/internal/tui3/place_home.go +++ b/internal/tui3/place_home.go @@ -499,6 +499,8 @@ func (placeHome) box(a *app) *editor { // hint is HOME'S WHOLE LINE, the router's own keys included. At rest that line is // the design's sentence word for word and names four keys exactly (SCREEN 1a, // home.go's [app.homeHint]); the router's tail appended here would make it five. +func (placeHome) about() string { return "what wants you and what is running" } + func (placeHome) hint(a *app) string { return a.homeHint() } // changed is ZERO AND THAT IS THE DESIGN. Home is where the "since you left" diff --git a/internal/tui3/place_memory.go b/internal/tui3/place_memory.go index cdcac06d83..dc19e16fe1 100644 --- a/internal/tui3/place_memory.go +++ b/internal/tui3/place_memory.go @@ -882,6 +882,8 @@ func (placeMemory) note(a *app, width int) []string { // hint is WHAT THE ROW UNDER THE CURSOR CAN BE ASKED FOR (pages.go's // [place.hint]), which on this place is two different sentences: a shelf heading // unrolls and a line is talked about. +func (placeMemory) about() string { return "what the agents remember" } + func (placeMemory) hint(a *app) string { if a.mem.edit != nil { return memoryEditHint diff --git a/internal/tui3/place_search.go b/internal/tui3/place_search.go index f7d4e98bcb..ac0a071c23 100644 --- a/internal/tui3/place_search.go +++ b/internal/tui3/place_search.go @@ -551,20 +551,22 @@ func (placeSearch) key(a *app, msg tea.KeyPressMsg) tea.Cmd { return a.searchKey const ( // searchHitHint is the foot standing on a result: what enter opens, how to // move between them, and that the box is still a search box. - searchHitHint = "enter opens it at that turn · ↑↓ pick · type to search · esc clears the words" + searchHitHint = "enter opens it at that turn · ↑↓ pick · type to search · esc clear the words" // searchAskHint is the foot with nothing to stand on — the teaching page and // a search that found nothing. NOTHING IS NAMED THAT IS NOT BOUND, so // `enter` and `↑↓` are simply absent rather than promised over an empty // body (place_standing.go's hint holds the same argument at more length). - searchAskHint = "type to search · esc clears the words" + searchAskHint = "type to search · esc clear the words" ) // hint is WHAT THE ROW UNDER THE CURSOR CAN BE ASKED FOR (pages.go's // [place.hint]) — and on the teaching page and the no-hit line there is no row, // so the foot says only the two things that are true there. +func (placeSearch) about() string { return "search every conversation" } + func (placeSearch) hint(a *app) string { if a.search.reading.foldAt(a.search.cursor) { - return foldEnterWord(a.search.unfolded) + " · ↑↓ pick · type to search · esc clears the words" + return foldEnterWord(a.search.unfolded) + " · ↑↓ pick · type to search · esc clear the words" } if _, ok := a.search.reading.at(a.search.cursor); ok { return searchHitHint diff --git a/internal/tui3/place_sessions.go b/internal/tui3/place_sessions.go index 60f2244fed..57ccd3b261 100644 --- a/internal/tui3/place_sessions.go +++ b/internal/tui3/place_sessions.go @@ -1878,7 +1878,9 @@ func (placeTasks) rowID(a *app) string { func (placeTasks) window(a *app, key string) (bool, tea.Cmd) { return a.taskSheet.window(a, key), nil } -func (placeTasks) note(a *app, width int) []string { return a.taskSheet.note(a, width) } +func (placeTasks) note(a *app, width int) []string { return a.taskSheet.note(a, width) } +func (placeTasks) about() string { return "every session and task this machine ran" } + func (placeTasks) hint(a *app) string { return a.taskSheet.hint(a) } func (placeTasks) changed(a *app, since time.Time) int { return a.taskSheet.changed(a, since) } diff --git a/internal/tui3/place_settings.go b/internal/tui3/place_settings.go index a7f99df572..2165650e2c 100644 --- a/internal/tui3/place_settings.go +++ b/internal/tui3/place_settings.go @@ -20,9 +20,8 @@ import ( // (docs/design/home-rethink/ARCHITECTURE.md's three layers). // // IT IS THE ONE PLACE WITH A SECOND BAR INSIDE IT, and the two are not a -// repetition: the upper one is the seven places and the lower one is this -// place's own sections. The panel is where [placeTabBar] was lifted from, so -// they are drawn by the same geometry and read as one object at two scales. +// repetition: the nav at the top is the places and the bar in the body is this +// place's own sections. // placeSettings is this place's handle on the registry (pages.go's [place] // states the contract and why the handle holds no state of its own). @@ -40,7 +39,10 @@ func (placeSettings) open(a *app) tea.Cmd { // change when somebody changes them — but the tab bar's numbers are // recomputed on that beat, and a room that armed no clock stopped the whole // bar counting while it was up ([placeSettings.tick]). - return a.armPlaceClock() + // + // OVER --host THE TEAMS TAB READS THE FAR MACHINE, once, off the loop. A + // local launch asks for nothing. + return tea.Batch(a.armPlaceClock(), a.readHostTeamDefaults()) } // tick re-reads nothing and keeps the beat: see the note over [placeSettings.open]. @@ -180,6 +182,8 @@ func (placeSettings) note(a *app, width int) []string { return []string{" " + pal.dim(noteFit(a.sheet.footNote(), width-2))} } +func (placeSettings) about() string { return "how this machine is set" } + func (placeSettings) hint(a *app) string { return a.sheet.keysLine() } // key is the panel's own grammar (settings.go's [app.sheetKey]): the value being @@ -199,9 +203,10 @@ func (placeSettings) key(a *app, msg tea.KeyPressMsg) tea.Cmd { // title bar (connectcaps.go). func (placeSettings) owns(a *app, msg tea.KeyPressMsg) (tea.Cmd, bool) { s := &a.sheet + var cmd tea.Cmd switch { case s.edit != nil: - a.sheetEditKey(msg) + cmd = a.sheetEditKey(msg) case s.sel != nil: a.sheetSelectKey(msg) case s.conn.entry != nil: @@ -210,7 +215,7 @@ func (placeSettings) owns(a *app, msg tea.KeyPressMsg) (tea.Cmd, bool) { return nil, false } a.touch() - return nil, true + return cmd, true } // caretRow is the connections key entry: a box this sheet draws INSIDE the row diff --git a/internal/tui3/place_spend.go b/internal/tui3/place_spend.go index 276420de87..3811b6f125 100644 --- a/internal/tui3/place_spend.go +++ b/internal/tui3/place_spend.go @@ -926,6 +926,8 @@ const ( // hold them ([app.spendWindowKey] asks [placeWindowFits] the same question), and // a foot promising them under a head that is not drawing them would be this // surface advertising a key that does nothing. +func (placeSpend) about() string { return "what the work has cost" } + func (placeSpend) hint(a *app) string { var parts []string stop := a.spendStopAt(a.spend.cursor) diff --git a/internal/tui3/place_standing.go b/internal/tui3/place_standing.go index 90c76febca..a640fa7236 100644 --- a/internal/tui3/place_standing.go +++ b/internal/tui3/place_standing.go @@ -915,7 +915,9 @@ func (placeStanding) rowID(a *app) string { return a.orders.rowID() } func (placeStanding) window(a *app, key string) (bool, tea.Cmd) { return a.orders.window(a, key), nil } -func (placeStanding) note(a *app, width int) []string { return a.orders.note(a, width) } +func (placeStanding) note(a *app, width int) []string { return a.orders.note(a, width) } +func (placeStanding) about() string { return "the standing orders" } + func (placeStanding) hint(a *app) string { return a.orders.hint(a) } func (placeStanding) changed(a *app, since time.Time) int { return a.orders.changed(a, since) } diff --git a/internal/tui3/place_teams.go b/internal/tui3/place_teams.go new file mode 100644 index 0000000000..676a95c84d --- /dev/null +++ b/internal/tui3/place_teams.go @@ -0,0 +1,533 @@ +package tui3 + +import ( + "sort" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TEAMS PLACE ───────────────────────────────────────────────────────── +// +// The handle the registry files (pages.go's [place]), and the keys, the +// pointer and the acts of the page teamspage.go describes. The second place on +// the bar, right after home: `home teams chats sessions spend settings`. +// +// TWO SHAPES, ONE PLACE. With a manager in the pane the page hosts that +// conversation whole (teamspagehost.go): the frame is the conversation's own, +// laid out beside the rail, and the composer has the keyboard; `alt+↑↓` puts it +// on the page's buttons and `esc` gives it back. With no manager in the pane +// (a team without one, a closed team, the `All teams` row, no teams at all) +// the page is drawn in the shared place frame and has the keyboard itself. + +// placeTeams is this place's handle (pages.go's [place] states the contract +// and why the handle holds no state of its own). +type placeTeams struct{ placeBase } + +func init() { registerPlace(placeTeams{}) } + +func (placeTeams) id() page { return pageTeams } +func (placeTeams) word() string { return "teams" } + +// counted is true: what is in here is a pile of things, and a packet waiting +// on the person is news about this place. +func (placeTeams) counted() bool { return true } + +// open loads the teams at the door (the one read made on the loop, and it does +// not block, teamseam.go), settles the selection, brings the selected team's +// manager in front, and arms the router's beat, which the page answers. +func (placeTeams) open(a *app) tea.Cmd { + a.teamsEnsure() + a.tp.focus, a.tp.cur, a.tp.hot = false, teamsRef{}, teamsRef{} + a.tp.answering, a.tp.msg = "", "" + a.tp.top = teamsTopCache{} + a.teamsSettle() + // The keyboard starts on the selected team's row, where `↓` walks from. + // A managed team's page opens with the keyboard on the manager's composer. + a.tp.focus, a.tp.cur = true, teamsRef{act: teamsActSelect, id: a.tp.sel} + if t, ok := a.teamsSelected(); ok && t.Manager != "" && !t.Closed() { + a.tp.focus = false + } + return tea.Batch(a.armPlaceClock(), a.teamsRead(true), a.teamsBringManager()) +} + +// tick is the router's beat: the counts are the router's own, and the page +// reads the store on it only while an open team has a manager. +func (placeTeams) tick(a *app, now time.Time) (bool, tea.Cmd) { + if !a.teamsManaged() { + return true, nil + } + return true, a.teamsRead(true) +} + +// close drops what the page drew; the selection and the +// fold are kept for the next visit, as a place's views are. +func (placeTeams) close(a *app) { + a.tp.focus, a.tp.host, a.tp.targets = false, "", nil + a.tp.answering = "" + a.tp.top = teamsTopCache{} + // A drag, the members card and a move waiting on its line belong to the + // page and go with it; a move made keeps its Undo for the next visit. + a.tdrag, a.tcrew = teamDrag{}, teamCrew{} + a.tmove.pend = teamMovePend{} +} + +func (placeTeams) body(a *app, width, room int) []placeRow { return a.teamsBody(width, room) } + +// ownFrame is the hosted shape: the manager's own conversation beside the +// rail (teamspagehost.go). Every other shape is the shared frame's. +func (placeTeams) ownFrame(a *app, width, height int) ([]string, []placeHit, int, int, bool) { + return a.teamsHostFrame() +} + +// remote is the one line over --host against an engine without the teams +// doors: this window's own file is not the session's, and the page does not +// pretend it is. +func (placeTeams) remote(a *app) string { + if a.teamsOff() { + return teamHostedWord + } + return "" +} + +// stops is every body line with a target on it, top first: the router's +// names for rows, which a scrolled pane does not move. +func (placeTeams) stops(a *app) []int { + out := make([]int, 0, len(a.tp.targets)) + for _, t := range a.tp.targets { + out = append(out, t.line) + } + sort.Ints(out) + return out +} + +// cursorAt is the body line the keyboard is on, the first stop when it is on +// none, so `↑` from the first target reaches the bar. +func (placeTeams) cursorAt(a *app) int { + if t, ok := a.teamsCursorTarget(); ok { + return t.line + } + return 0 +} + +func (placeTeams) rowID(a *app) string { + if !a.tp.focus { + return "" + } + r := a.tp.cur + return itoa(int(r.act)) + ":" + r.id + ":" + r.arg + ":" + r.opt +} + +// note is the page's one line of news, and otherwise the one fact under the +// rows that a person may not see anywhere else: that the manager has the +// keyboard or that the page does. +func (placeTeams) note(a *app, width int) []string { + if a.tp.msg != "" { + return []string{" " + a.pal.dim(noteFit(a.tp.msg, width-2))} + } + return nil +} + +// hint is what the pointer or the cursor is on, with its key, and otherwise +// the page's keys. +func (placeTeams) about() string { return "the teams you hand work to" } + +func (placeTeams) hint(a *app) string { + if a.tmove.on { + return a.teamMoveHint() + } + if a.tsheet.on { + return a.teamSheetHint() + } + if words := a.teamDragHint(); words != "" { + return words + } + if a.tcrew.on { + return a.teamCrewHint() + } + if words := a.teamsTargetHint(); words != "" { + return words + } + if n := len(a.teamsPickedIDs()); n > 0 { + return itoa(n) + " picked · m moves them into… · space picks · esc clears" + } + if a.tp.answering != "" { + return "enter decide · esc put it away" + } + if !a.teamsAny() { + return "o organize · n new team · " + homeDoorWord + } + return "↑↓ walk · enter open · m move into… · space pick · p members · s settings · c close · n new team · o organize · " + homeDoorWord +} + +// changed is how many packets wait on the person, which is the count a person +// wants beside `teams` on the bar. +func (placeTeams) changed(a *app, since time.Time) int { + n := 0 + for _, p := range a.tp.packets { + if p.Waiting() && p.Team == teamstore.Person && p.At.After(since) { + n++ + } + } + return n +} + +// summary is what is behind the place, for home's typed drop-up. +func (placeTeams) summary(a *app) string { + n := 0 + for _, t := range a.wall.teams { + if !t.Root && !t.Closed() { + n++ + } + } + switch n { + case 0: + return "" + case 1: + return "1 team" + } + return itoa(n) + " teams" +} + +// owns is the `Your own answer…` box, which has the whole keyboard while it is +// open, as every box inside a place does. +func (placeTeams) owns(a *app, msg tea.KeyPressMsg) (tea.Cmd, bool) { + if a.tp.answering == "" { + return nil, false + } + return a.teamsAnswerKey(msg), true +} + +// key is the page's own keys, the router's classes read first (placekeys.go). +func (placeTeams) key(a *app, msg tea.KeyPressMsg) tea.Cmd { + cmd, _ := a.teamsKey(msg) + return cmd +} + +// wheel walks the page's buttons exactly as the arrows do, a row a notch. +func (placeTeams) wheel(a *app, delta int) (tea.Cmd, bool) { + step := tea.KeyPressMsg{Code: tea.KeyDown} + if delta < 0 { + step, delta = tea.KeyPressMsg{Code: tea.KeyUp}, -delta + } + for i := 0; i < delta; i++ { + a.teamsKey(step) + } + a.tp.top = teamsTopCache{} + a.touch() + return nil, true +} + +func (placeTeams) enter(a *app) tea.Cmd { + if t, ok := a.teamsCursorTarget(); ok { + return a.teamsDo(t) + } + return nil +} + +// ── THE KEYBOARD ──────────────────────────────────────────────────────────── + +// teamsHasKeys reports whether the page, rather than a hosted composer, has +// the keyboard. +func (a *app) teamsHasKeys() bool { return a.tp.host == "" || a.tp.focus } + +// teamsCursorIndex is the index of the target the cursor is on, -1 for none. +func (a *app) teamsCursorIndex() int { + if !a.tp.focus && a.tp.host != "" { + return -1 + } + for i, t := range a.tp.targets { + if t.ref() == a.tp.cur { + return i + } + } + return -1 +} + +// teamsCursorTarget is the target the cursor is on. +func (a *app) teamsCursorTarget() (teamsTarget, bool) { + if i := a.teamsCursorIndex(); i >= 0 { + return a.tp.targets[i], true + } + return teamsTarget{}, false +} + +// teamsCursorHome puts the cursor on the selected team's rail row, or on the +// first target when that is not drawn. +func (a *app) teamsCursorHome() { + for _, t := range a.tp.targets { + if t.act == teamsActSelect && t.id == a.tp.sel { + a.tp.cur = t.ref() + return + } + } + if len(a.tp.targets) > 0 { + a.tp.cur = a.tp.targets[0].ref() + } +} + +// teamsWalk moves the cursor to the nearest target on the row above (dy -1) +// or below (dy 1), keeping as close to its column as it can, or along its row +// for dx. It reports whether it moved. +func (a *app) teamsWalk(dx, dy int) bool { + at := a.teamsCursorIndex() + if at < 0 { + a.teamsCursorHome() + return true + } + here := a.tp.targets[at] + order := make([]int, len(a.tp.targets)) + for i := range order { + order[i] = i + } + sort.SliceStable(order, func(i, j int) bool { + ti, tj := a.tp.targets[order[i]], a.tp.targets[order[j]] + if ti.y != tj.y { + return ti.y < tj.y + } + return ti.x0 < tj.x0 + }) + // ↑ AND ↓ STAY ON THEIR SIDE: the rail walks the rail and the pane walks + // the pane, so a walk down the teams is never pulled into a card beside + // them. ← and → walk along a row, and past its end cross to the nearest + // target on the other side. + best, bestScore := -1, 1<<30 + for _, i := range order { + t := a.tp.targets[i] + if i == at { + continue + } + var score int + switch { + case dy < 0 && t.y < here.y && t.pane == here.pane: + score = (here.y-t.y)*1000 + abs(t.x0-here.x0) + case dy > 0 && t.y > here.y && t.pane == here.pane: + score = (t.y-here.y)*1000 + abs(t.x0-here.x0) + case dx < 0 && t.y == here.y && t.x0 < here.x0: + score = here.x0 - t.x0 + case dx > 0 && t.y == here.y && t.x0 > here.x0: + score = t.x0 - here.x0 + case dx < 0 && here.pane && !t.pane, dx > 0 && !here.pane && t.pane: + score = 100000 + abs(t.y-here.y)*1000 + abs(t.x0-here.x0) + default: + continue + } + if score < bestScore { + best, bestScore = i, score + } + } + if best < 0 { + return false + } + a.tp.cur = a.tp.targets[best].ref() + return true +} + +// teamsLetters are the page's bare-letter keys, each the button of the same +// word on the selected team. +// +// `m` IS MOVE INTO… (ruling c-12), so starting a manager moved to `M`: the +// ruling names the letter, and a manager is started once per team while a +// team is moved whenever the tree is reshaped. +var teamsLetters = map[string]teamsAct{ + "s": teamsActSettings, "c": teamsActClose, "w": teamsActWall, "n": teamsActNewTeam, + "o": teamsActOrganize, "M": teamsActManager, "r": teamsActReopen, "d": teamsActDelete, +} + +// teamsMoveLetter is `Move into…`, on the selected team or the picked ones. +const teamsMoveLetter = "m" + +// teamsKey is a key while the page has the keyboard. It reports whether it +// took it. +func (a *app) teamsKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { + key := msg.String() + switch key { + case "up", "k": + if !a.tp.focus { + a.tp.focus = true + a.teamsCursorHome() + } else { + // The first target's `↑` is the router's: it reaches the bar + // ([app.barReach]) before this key is asked. + a.teamsWalk(0, -1) + } + a.touch() + return nil, true + case "down", "j": + if !a.tp.focus { + a.tp.focus = true + a.teamsCursorHome() + } else { + a.teamsWalk(0, 1) + } + a.touch() + return nil, true + case "left", "h": + a.tp.focus = true + if !a.teamsWalk(-1, 0) { + a.teamsCursorHome() + } + a.touch() + return nil, true + case "right", "l": + a.tp.focus = true + a.teamsWalk(1, 0) + a.touch() + return nil, true + case "enter", "space": + t, ok := a.teamsCursorTarget() + if !ok { + a.tp.focus = true + a.teamsCursorHome() + a.touch() + return nil, true + } + // SPACE PICKS A TEAM ON THE RAIL, as it picks a tile on the wall, so + // several can be moved with one `Move into…`. + if key == "space" && t.act == teamsActSelect && !t.pane { + if u, ok := a.teamByID(t.id); ok && !u.Root && !u.Closed() { + a.teamsPick(t.id) + return nil, true + } + } + return a.teamsDo(t), true + case teamsMoveLetter: + ids := a.teamsMoveIDs() + if len(ids) == 0 { + return nil, true + } + return a.teamMoveOpen(ids, teamMoveFromPage), true + case teamCrewLetter: + if t, ok := a.teamsSelected(); ok && !t.Closed() { + return a.teamCrewOpen(t.ID), true + } + return nil, true + case "esc": + if len(a.tp.picked) > 0 { + a.tp.picked = nil + a.tp.top = teamsTopCache{} + a.touch() + return nil, true + } + if a.tp.host != "" { + a.tp.focus = false + a.touch() + return nil, true + } + a.leavePlace() + return nil, true + } + if act, ok := teamsLetters[key]; ok { + return a.teamsLetter(act), true + } + return nil, false +} + +// teamsLetter is one of the bare letters: the act on the selected team, when +// the page offers it there. +func (a *app) teamsLetter(act teamsAct) tea.Cmd { + for _, t := range a.tp.targets { + if t.act != act { + continue + } + switch act { + case teamsActNewTeam, teamsActOrganize, teamsActRootManager: + return a.teamsDo(t) + } + if t.id == a.tp.sel { + return a.teamsDo(t) + } + } + if act == teamsActManager { + for _, t := range a.tp.targets { + if t.act == teamsActRootManager { + return a.teamsDo(t) + } + } + } + return nil +} + +// teamsAnswerKey is a key in the `Your own answer…` box. +func (a *app) teamsAnswerKey(msg tea.KeyPressMsg) tea.Cmd { + box := &a.tp.answer + switch msg.String() { + case "esc": + a.tp.answering = "" + box.reset() + case "enter": + words := strings.TrimSpace(box.String()) + id := a.tp.answering + if words == "" { + return nil + } + a.tp.answering = "" + box.reset() + a.touch() + return a.teamsDecide(id, "", words) + case "backspace": + box.deleteBackward() + case "left": + box.left() + case "right": + box.right() + default: + if text := msg.Key().Text; text != "" { + box.insert(text) + } + } + a.touch() + return nil +} + +// ── THE POINTER ───────────────────────────────────────────────────────────── + +// teamsTargetAt is the target under the pointer on the last frame. +func (a *app) teamsTargetAt(x, y int) (teamsTarget, bool) { + for _, t := range a.tp.targets { + if y == t.y && x >= t.x0 && x < t.x1 { + return t, true + } + } + return teamsTarget{}, false +} + +// teamsTargetHint is what the hint line says over the target under the pointer, +// or under the cursor while the page has the keyboard. +func (a *app) teamsTargetHint() string { + if a.tp.hot != (teamsRef{}) { + for _, t := range a.tp.targets { + if t.ref() == a.tp.hot { + return t.hint + } + } + } + if t, ok := a.teamsCursorTarget(); ok { + return t.hint + } + return "" +} + +// teamsHover lights the target under the pointer, repainting only when that +// moved. +func (a *app) teamsHover(x, y int) { + t, _ := a.teamsTargetAt(x, y) + if r := t.ref(); r != a.tp.hot { + a.tp.hot = r + a.tp.top = teamsTopCache{} + a.touch() + } +} + +// teamsPress is a left press on the page: a target does what it says, and the +// keyboard stays where it was. +func (a *app) teamsPress(x, y int) (tea.Cmd, bool) { + t, ok := a.teamsTargetAt(x, y) + if !ok { + return nil, false + } + return a.teamsDo(t), true +} diff --git a/internal/tui3/placebar_test.go b/internal/tui3/placebar_test.go index 30b2e04cae..366c7aee1f 100644 --- a/internal/tui3/placebar_test.go +++ b/internal/tui3/placebar_test.go @@ -99,7 +99,7 @@ func TestTheBarIsARowOnEveryPlace(t *testing.T) { if a.page != place.id { t.Fatalf("at %d columns → on the bar opened %q", width, a.page.word()) } - if want := nextPage(place.id, false); a.bar.at != want { + if want := nextOn(barPages(place.id, false), place.id, false); a.bar.at != want { t.Fatalf("at %d columns → landed the cursor on %q, want %q", width, a.bar.at.word(), want.word()) } // AND `→` DOES NOT OPEN A ROW'S VERBS UP HERE. The strip is a @@ -139,7 +139,12 @@ func TestTheBarIsARowOnEveryPlace(t *testing.T) { // the room rather than merely coming back down. barTop(t, a) drive(t, a, key("right"), key("enter")) - if want := nextPage(place.id, false); a.page != want { + want := nextOn(barPages(place.id, false), place.id, false) + if want == pageChats { + // The way back to the chats opens no room: it leaves them. + want = pageNone + } + if a.page != want { t.Fatalf("at %d columns enter on the bar landed on %q, want %q", width, a.page.word(), want.word()) } if a.bar.on { @@ -163,11 +168,11 @@ func TestTheBarCursorRepaintsTheWordAndMovesNothing(t *testing.T) { a := placeApp(t) before := a.frame beforeFrame, _, _ := before() - beforeRow := strings.Split(beforeFrame, "\n")[placeTabRow] + beforeRow := strings.Split(beforeFrame, "\n")[navRow] barTop(t, a) afterFrame, _, _ := a.frame() - afterRow := strings.Split(afterFrame, "\n")[placeTabRow] + afterRow := strings.Split(afterFrame, "\n")[navRow] if beforeRow == afterRow { t.Fatalf("the bar is painted exactly as it was with the cursor on it: %q", plain(afterRow)) @@ -179,13 +184,13 @@ func TestTheBarCursorRepaintsTheWordAndMovesNothing(t *testing.T) { // rather than merely somewhere in the program's own memory. drive(t, a, key("right")) walked, _, _ := a.frame() - if strings.Split(walked, "\n")[placeTabRow] == afterRow { + if strings.Split(walked, "\n")[navRow] == afterRow { t.Fatal("→ along the bar changed nothing on the frame") } } // AND THE WIDTH LADDER MAY NOT DROP THE WORD THE CURSOR IS ON. The bar gives up -// words as the frame narrows (pages.go's [app.placeTabBar]), and a cursor on a +// words as the frame narrows (topnav.go), and a cursor on a // word that was given up would be a cursor nobody can see — which is SCREEN 3a's // clause said about a row rather than about a key. func TestTheNarrowBarKeepsTheWordTheCursorIsOn(t *testing.T) { @@ -209,7 +214,7 @@ func TestTheNarrowBarKeepsTheWordTheCursorIsOn(t *testing.T) { // ── the bar is not a mode ─────────────────────────────────────────────────── -// `tab`, `shift+tab` AND `alt+1…7` KEEP WORKING FROM THE BAR, and a printable +// `tab`, `shift+tab` AND `alt+1…9` KEEP WORKING FROM THE BAR, and a printable // character goes to the composer with the cursor following it back down. // // A ROW THAT CAPTURED THE KEYBOARD WOULD BE A MODE, and the six classes have no @@ -274,8 +279,9 @@ func TestTheBarCursorWrapsAtBothEnds(t *testing.T) { // ── the pointer on the bar ────────────────────────────────────────────────── -// MOTION OVER A TAB WORD CHANGES THAT WORD'S INK AND NOTHING ELSE ON THE FRAME, -// and motion off it puts the ink back. +// MOTION OVER A TAB WORD CHANGES THAT WORD'S GROUND AND THE HINT LINE AND +// NOTHING ELSE ON THE FRAME, and motion off it puts both back. The hint line +// says what the word opens and its key (topnav.go's [app.headHint]). // // A TAB WORD IS A DOOR AND A DOOR SHOULD LOOK BACK. The bar answered a press and // said nothing at all while a pointer crossed it, so seven words that open seven @@ -285,14 +291,18 @@ func TestHoveringATabWordLiftsItsInkAndNothingElse(t *testing.T) { before, _, _ := a.frame() span := barWordSpan(t, a, pageSettings) - drive(t, a, tea.MouseMotionMsg{X: span.from, Y: placeTabRow}) + drive(t, a, tea.MouseMotionMsg{X: span.from, Y: navRow}) after, _, _ := a.frame() beforeRows, afterRows := strings.Split(before, "\n"), strings.Split(after, "\n") if len(beforeRows) != len(afterRows) { t.Fatalf("the frame changed height under a pointer: %d rows became %d", len(beforeRows), len(afterRows)) } + hint := len(afterRows) - 1 + if got := plain(afterRows[hint]); !strings.Contains(got, placeChord(pageSettings)+" settings") || !strings.Contains(got, placeFor(pageSettings).about()) { + t.Fatalf("the hint line does not say what the hovered word opens: %q", got) + } for at := range beforeRows { - if at == placeTabRow { + if at == navRow || at == hint { continue } if beforeRows[at] != afterRows[at] { @@ -300,13 +310,13 @@ func TestHoveringATabWordLiftsItsInkAndNothingElse(t *testing.T) { at, plain(beforeRows[at]), plain(afterRows[at])) } } - if beforeRows[placeTabRow] == afterRows[placeTabRow] { - t.Fatalf("the hovered word is painted exactly as it was: %q", plain(afterRows[placeTabRow])) + if beforeRows[navRow] == afterRows[navRow] { + t.Fatalf("the hovered word is painted exactly as it was: %q", plain(afterRows[navRow])) } // AND THE CELLS ARE THE SAME CELLS: the ink lifted, the bar did not move. - if plain(beforeRows[placeTabRow]) != plain(afterRows[placeTabRow]) { + if plain(beforeRows[navRow]) != plain(afterRows[navRow]) { t.Fatalf("the hover moved a cell on the bar:\n%q\n%q", - plain(beforeRows[placeTabRow]), plain(afterRows[placeTabRow])) + plain(beforeRows[navRow]), plain(afterRows[navRow])) } // AND IT MOVED NOTHING A KEY WOULD HAVE MOVED. if a.page != pageHome { @@ -317,9 +327,13 @@ func TestHoveringATabWordLiftsItsInkAndNothingElse(t *testing.T) { // door claiming to be under a pointer that is somewhere else. drive(t, a, tea.MouseMotionMsg{X: span.from, Y: placeHeadRows + 1}) restored, _, _ := a.frame() - if strings.Split(restored, "\n")[placeTabRow] != beforeRows[placeTabRow] { + if strings.Split(restored, "\n")[navRow] != beforeRows[navRow] { t.Fatalf("the pointer left the bar and the ink stayed lifted:\n%q", - plain(strings.Split(restored, "\n")[placeTabRow])) + plain(strings.Split(restored, "\n")[navRow])) + } + if strings.Split(restored, "\n")[hint] != beforeRows[hint] { + t.Fatalf("the pointer left the bar and the hint line kept its sentence:\n%q", + plain(strings.Split(restored, "\n")[hint])) } } @@ -332,10 +346,10 @@ func TestHoveringTheGapBetweenTabsLiftsNothing(t *testing.T) { if !ok { t.Skip("this bar has no gap between two chips") } - drive(t, a, tea.MouseMotionMsg{X: gap, Y: placeTabRow}) + drive(t, a, tea.MouseMotionMsg{X: gap, Y: navRow}) after, _, _ := a.frame() - if strings.Split(before, "\n")[placeTabRow] != strings.Split(after, "\n")[placeTabRow] { - t.Fatalf("a pointer in the gap lifted a word:\n%q", plain(strings.Split(after, "\n")[placeTabRow])) + if strings.Split(before, "\n")[navRow] != strings.Split(after, "\n")[navRow] { + t.Fatalf("a pointer in the gap lifted a word:\n%q", plain(strings.Split(after, "\n")[navRow])) } } @@ -352,7 +366,7 @@ func TestTheHoverAndTheBarCursorCompose(t *testing.T) { t.Fatal("the cursor walked onto the word this test means to hover") } span := barWordSpan(t, a, pageSettings) - drive(t, a, tea.MouseMotionMsg{X: span.from, Y: placeTabRow}) + drive(t, a, tea.MouseMotionMsg{X: span.from, Y: navRow}) if a.tabHover != pageSettings { t.Fatalf("the pointer is recorded over %q", a.tabHover.word()) @@ -361,7 +375,7 @@ func TestTheHoverAndTheBarCursorCompose(t *testing.T) { t.Fatalf("the hover moved the cursor: it is on %q (up=%v)", a.bar.at.word(), a.bar.on) } // Both marks are on the one row, and the row still says the same four words. - row := strings.Split(mustFrame(a), "\n")[placeTabRow] + row := strings.Split(mustFrame(a), "\n")[navRow] for _, id := range barPages(a.page, false) { if !strings.Contains(plain(row), id.word()) { t.Fatalf("the bar lost %q while wearing two marks: %q", id.word(), plain(row)) @@ -375,20 +389,20 @@ func TestTheHoverAndTheBarCursorCompose(t *testing.T) { func TestTheWheelOverTheBarWalksThePlaces(t *testing.T) { a := placeApp(t) a.frame() - drive(t, a, tea.MouseWheelMsg{X: 4, Y: placeTabRow, Button: tea.MouseWheelDown}) + drive(t, a, tea.MouseWheelMsg{X: 4, Y: navRow, Button: tea.MouseWheelDown}) if want := nextPage(pageHome, false); a.page != want { t.Fatalf("a wheel notch over the bar landed on %q, want %q", a.page.word(), want.word()) } a.frame() - drive(t, a, tea.MouseWheelMsg{X: 4, Y: placeTabRow, Button: tea.MouseWheelUp}) + drive(t, a, tea.MouseWheelMsg{X: 4, Y: navRow, Button: tea.MouseWheelUp}) if a.page != pageHome { t.Fatalf("the wheel back up landed on %q, want home again", a.page.word()) } // AND ONE ROOM A TICK AND NOT THREE. Three would open two rooms nobody asked // to see on the way to the third, and each opening throws away a filter. a.frame() - drive(t, a, tea.MouseWheelMsg{X: 4, Y: placeTabRow, Button: tea.MouseWheelDown}) - drive(t, a, tea.MouseWheelMsg{X: 4, Y: placeTabRow, Button: tea.MouseWheelDown}) + drive(t, a, tea.MouseWheelMsg{X: 4, Y: navRow, Button: tea.MouseWheelDown}) + drive(t, a, tea.MouseWheelMsg{X: 4, Y: navRow, Button: tea.MouseWheelDown}) if want := pages()[2]; a.page != want { t.Fatalf("two notches walked to %q, want %q", a.page.word(), want.word()) } diff --git a/internal/tui3/placebodies.go b/internal/tui3/placebodies.go index d9e3125500..8f8506cb66 100644 --- a/internal/tui3/placebodies.go +++ b/internal/tui3/placebodies.go @@ -36,16 +36,23 @@ import ( // Both keep their bodies exactly as they drew them. What changed is the frame // around them and the keyboard, which is the whole of what that wave claimed. -// placeHeadRows is how many rows every place spends before its body: the pulse, -// the tab bar, the rule, and the blank under it (pages.go's [placeFrame]). +// placeHeadRows is how many rows every place spends before its body: the nav, +// the rule, and the blank under it (pages.go's [placeFrame]). +// +// THE STRIP IS NOT ONE OF THEM. It is a chat's own row, drawn only while a +// conversation is in front (head.go), so a place's body starts one row higher +// than a chat's and a click on that row is the page's. // // IT IS A CONSTANT AND THE POINTER DEPENDS ON IT. A press arrives as a row of // the terminal and has to become a row of the body, and the only honest way to -// subtract the head is to have exactly one number for how tall the head is — -// which is also why the tab bar took the blank row home used to draw rather than -// being added under it. A fifth head row is a change to this constant and to -// nothing else. -const placeHeadRows = 4 +// subtract the head is to have exactly one number for how tall the head is. +// A head row added or removed is a change to this constant and to nothing else. +const placeHeadRows = 3 + +// chatHeadRows is the head while a conversation is in front: the places' three +// rows with the strip between the nav and the rule. A room inside a chat wears +// it too. A place does not. +const chatHeadRows = placeHeadRows + 1 // placeNote is the one line a place says about what it is holding, drawn under // the rule and above the composer (pages.go's [placeFrame] states the law). diff --git a/internal/tui3/placecounts_test.go b/internal/tui3/placecounts_test.go index fb40cd3132..f0614e149a 100644 --- a/internal/tui3/placecounts_test.go +++ b/internal/tui3/placecounts_test.go @@ -58,7 +58,7 @@ func TestATabWearsWhatChangedSinceYouLeftThatPlace(t *testing.T) { // MEMORY IS OFF THE BAR, SO ITS NUMBER IS ON THE MAP — the one row that // draws every place with its digit — and on the bar the moment you stand in // it (pages.go's [barPages]). - if bar := plain(a.placeTabBar(160, true, a.pal)); !strings.Contains(bar, itoa(placeDigitOf(pageMemory))+" memory 3") { + if bar := navPlaces(a, 160, true); !strings.Contains(bar, itoa(placeDigitOf(pageMemory))+" memory 3") { t.Fatalf("the map does not carry the count: %q", bar) } } @@ -76,7 +76,7 @@ func TestAPlaceWithNoLookStampWearsNoNumber(t *testing.T) { if len(brain.asked) != 0 { t.Fatalf("the store was asked for a delta with no origin to measure from: %v", brain.asked) } - bar := plain(a.placeTabBar(160, false, a.pal)) + bar := navPlaces(a, 160, false) for _, digit := range "0123456789" { if strings.ContainsRune(bar, digit) { t.Fatalf("the bar wears a figure with no origin behind it: %q", bar) diff --git a/internal/tui3/placeeverymouse_test.go b/internal/tui3/placeeverymouse_test.go index a5b4be312f..f2af75681c 100644 --- a/internal/tui3/placeeverymouse_test.go +++ b/internal/tui3/placeeverymouse_test.go @@ -39,7 +39,7 @@ func TestClickingATabWordWorksFromEveryPlace(t *testing.T) { if !ok { t.Fatalf("the %s tab is not on the bar the %s place drew", target.word(), place.id.word()) } - if a.tabRow != placeTabRow { + if a.tabRow != navRow { t.Fatalf("the %s place drew its tab bar on row %d", place.id.word(), a.tabRow) } drive(t, a, tea.MouseClickMsg{X: x, Y: a.tabRow, Button: tea.MouseLeft}) diff --git a/internal/tui3/placeeveryone_test.go b/internal/tui3/placeeveryone_test.go index 2c9db05bbf..15261bcf05 100644 --- a/internal/tui3/placeeveryone_test.go +++ b/internal/tui3/placeeveryone_test.go @@ -63,6 +63,12 @@ func everyPlaceTable() []everyPlace { return hits }, }, + { + id: pageTeams, + open: teamsPlaceLab, + cursor: teamsCursorLine, + hits: teamsHits, + }, { id: pageTasks, open: func(t *testing.T) *app { return historyApp(t, 200) }, @@ -293,14 +299,15 @@ func TestTabLeavesEveryPlaceAndComesBack(t *testing.T) { } } -// alt+1…7 JUMPS FROM EVERY PLACE. The numbers are the bar's own order and they +// alt+1…9 JUMPS FROM EVERY PLACE. The numbers are the bar's own order and they // mean the same thing wherever you are standing — or, for a room with nothing // in it, they say why and leave you where you were. What they may never do is // nothing at all. func TestTheNumbersJumpFromEveryPlace(t *testing.T) { for _, place := range everyPlaceTable() { t.Run(place.id.word(), func(t *testing.T) { - for at, id := range pages() { + for _, id := range pages() { + at := placeDigitOf(id) - 1 a := place.open(t) drive(t, a, key("alt+"+itoa(at+1))) switch { @@ -458,7 +465,8 @@ func TestEveryPlaceBringsItsOwnLab(t *testing.T) { t.Fatalf("the %s place is registered and has no lab in everyPlaceTable", id.word()) } } - if len(labs) != len(placeRegistry) { + // The chats are registered for the bar and are no room (place_chats.go). + if len(labs) != len(placeRegistry)-1 { t.Fatalf("%d labs for %d registered places", len(labs), len(placeRegistry)) } } diff --git a/internal/tui3/placehost_test.go b/internal/tui3/placehost_test.go index fd9573278d..72f409cf3c 100644 --- a/internal/tui3/placehost_test.go +++ b/internal/tui3/placehost_test.go @@ -164,7 +164,7 @@ func TestTheTasksPlaceOverHostDrawsTheFarMachinesWork(t *testing.T) { // Settings is NOT one of them, and that is the point of the default being "". // Every row on it is either this surface's own or is read from the far machine's -// profile, and it already says so as it opens ([settingsRemoteWord]) — a place +// profile, and it already says so as it opens ([settingsHostNote]). A place // that drew one dim line instead would have taken working rows away. func TestTheSettingsPlaceIsNotGatedOverHost(t *testing.T) { a := hostedPlaceLab(t) diff --git a/internal/tui3/placejump_test.go b/internal/tui3/placejump_test.go index 867d14e2f1..e57adc1131 100644 --- a/internal/tui3/placejump_test.go +++ b/internal/tui3/placejump_test.go @@ -5,7 +5,7 @@ import ( "testing" ) -// ── alt+1…7 IS THE ONE CLASS THAT BELONGS TO NO PLACE ─────────────────────── +// ── alt+1…9 IS THE ONE CLASS THAT BELONGS TO NO PLACE ─────────────────────── // // placeeveryone_test.go asks the numbers of all seven ROOMS. Nothing asked them // of the surface a person spends most of their time on: the conversation. And @@ -35,7 +35,8 @@ func conversationApp(t *testing.T) *app { // the assertion is the whole of the law: seven digits, seven rooms, from the // surface a person is most often on. func TestTheNumbersJumpFromTheConversation(t *testing.T) { - for at, id := range pages() { + for _, id := range pages() { + at := placeDigitOf(id) - 1 t.Run(id.word(), func(t *testing.T) { a := conversationApp(t) drive(t, a, key("alt+"+string(rune('1'+at)))) diff --git a/internal/tui3/placekeys.go b/internal/tui3/placekeys.go index 7aac05bea1..859a83ffff 100644 --- a/internal/tui3/placekeys.go +++ b/internal/tui3/placekeys.go @@ -20,7 +20,7 @@ import ( // ↑↓ enter esc tab move, open, back out, next place never text // any printable goes to the composer, always never a verb // alt+enter send what you typed off as a task one chord -// alt+1…7 jump straight to a place drawn on the map +// alt+1…9 jump straight to a place drawn on the map // alt+<letter> change how THIS place is shown drawn on the map // shift+←→↑↓ move this place's time window no letters spent // → then a letter act on the row — letters are verbs only here @@ -345,7 +345,8 @@ func placeDigitAt(prefix, key string) (page, bool) { return 0, false } at := int(key[len(prefix)] - '1') - all := pages() + // The digits are the BAR's order, the chats included (place_chats.go). + all := placeOrder if at < 0 || at >= len(all) { return 0, false } diff --git a/internal/tui3/placelaws_test.go b/internal/tui3/placelaws_test.go index 25420d1962..06a5aa4f26 100644 --- a/internal/tui3/placelaws_test.go +++ b/internal/tui3/placelaws_test.go @@ -128,7 +128,7 @@ func TestEveryPlaceIsRegisteredOnceAndInTabOrder(t *testing.T) { } // AND THE WORD REACHES IT TOO, which is what lets the typed surface offer // places beside conversations (SCREEN 1g). - if back, ok := parsePageWord(word); !ok || back != id { + if back, ok := parsePageWord(word); id != pageChats && (!ok || back != id) { t.Fatalf("typing %q does not reach its own place", word) } } @@ -194,7 +194,7 @@ func TestNoPlaceFileMentionsTheBar(t *testing.T) { // forbidden is the ROUTER'S bar reaching into a place file, and each of these // names one piece of it. forbidden := []string{"barCursor", "a.bar.", "barRaise", "barDrop", "barWalk", - "barEnter", "barReach", "barKey(", "tabHover", "placeTabBar", "tabBarAt"} + "barEnter", "barReach", "barKey(", "tabHover", "navLine", "navPress"} for _, name := range placeSourceFiles(t) { if !strings.HasPrefix(name, "place_") { continue @@ -322,7 +322,7 @@ func TestEveryPlaceSpendsTheSameHeadAndFoot(t *testing.T) { // doors rather than counted out again here. wantFor := func(id page, size [2]int) edges { height := size[1] - got := edges{bar: placeTabRow, headRule: 2, blank: placeHeadRows - 1, + got := edges{bar: navRow, headRule: 1, blank: placeHeadRows - 1, footRule: height - placeFootRowsFor(id, height) + 1, box: -1, hint: height - 1} if id == pageHome { got.box = height - 1 - boxFloor(height) @@ -339,8 +339,8 @@ func TestEveryPlaceSpendsTheSameHeadAndFoot(t *testing.T) { rows[i] = ansi.Strip(line) } got := edges{bar: a.tabRow, headRule: -1, blank: -1, footRule: -1, box: -1, hint: len(rows) - 1} - if strings.HasPrefix(rows[2], "──") { - got.headRule = 2 + if len(rows) > 1 && strings.HasPrefix(rows[1], "──") { + got.headRule = 1 } if strings.TrimSpace(rows[placeHeadRows-1]) == "" { got.blank = placeHeadRows - 1 diff --git a/internal/tui3/placemouse.go b/internal/tui3/placemouse.go index 2fd748e45b..fc63a1db85 100644 --- a/internal/tui3/placemouse.go +++ b/internal/tui3/placemouse.go @@ -10,14 +10,15 @@ import ( // Three gestures, one law each, and every one of them is the same law on all // seven places: // -// a press on a tab word goes to that place +// a press on a tab word goes to that place (topnav.go's [app.navPress]) // a press on a body row is `enter` on it: the cursor lands and the row // opens, and a click never spends (pages.go's // [place.press]) // the pointer resting previews the row it is over, and moves nothing — -// over a tab word, that preview is the word's own ink +// over a tab word, that preview is the word's +// hover ground (topnav.go's [app.navHover]) // the wheel walks the cursor, three rows a tick, and over the -// tab bar walks the places, one room a tick +// nav walks the places, one room a tick // // THIS FILE IS THE ARITHMETIC AND NEVER THE PLACES. Which place answers which // gesture is pages.go's — it is the one file that may know them all by name — @@ -31,13 +32,6 @@ import ( // body scrolls, so a span or a line computed independently would open the wrong // room or act on the wrong row exactly when a person could not tell why. -// placeTabRow is the row of the frame the tab bar is drawn on: under the pulse -// and over the rule (pages.go's [placeFrame] draws the ladder). The frame -// records where it actually landed in [app.tabRow], because a frame too short -// for its own contents drops it — this is the number that is true on every -// frame that has one. -const placeTabRow = 1 - // placeWheelRows is how far one turn of the wheel walks a place's cursor. It is // three because three is what every other list on this surface moves by // (app.go's wheel ladder, copy mode, the task page, home), and a wheel that @@ -57,77 +51,8 @@ func placeWheelDelta(button tea.MouseButton) int { return 0 } -// placeTabPress is a press on the tab bar: the place whose chip it landed in. -// -// A TAB WORD IS A DOOR. The bar names seven rooms and bands the one you are -// standing in; a bar that answered a press with nothing would be seven labels, -// which is what the owner met in the built binary. The gap between two chips -// belongs to no room and is swallowed — a bar that rounded a miss to its -// nearest neighbour would open the wrong place for a one-cell slip. -// -// AND PRESSING THE PLACE YOU ARE ALREADY IN DOES NOTHING AT ALL. Going there is -// closing and reopening it, which throws away the filter somebody typed and the -// row they were standing on; pressing where you are standing is not a gesture. -func (a *app) placeTabPress(x, y int) (tea.Cmd, bool) { - // ROW ZERO IS THE PULSE AND CAN NEVER BE THE BAR, so anything under one is - // "no frame has drawn a bar yet" — the state a window is in before its first - // paint, and the state [app.frame] puts it back into for every surface that - // does not go through [placeFrame]. - if !a.pageShowing() || a.tabRow < 1 || y != a.tabRow { - return nil, false - } - for _, span := range a.tabs { - if x < span.from || x >= span.to { - continue - } - if span.id == a.page { - return nil, true - } - return a.showPage(span.id), true - } - // THE REST OF THE ROW IS STILL THE BAR'S. A press in the gap, or out past - // the last chip, is a press on a row that has nothing under it — swallowing - // it is what stops it falling through to a body row it visually is not. - return nil, true -} - -// placeTabHover is the pointer resting over the tab bar: THE WORD UNDER IT LIFTS -// ONE INK TIER AND NOTHING ELSE ON THE FRAME MOVES. -// -// A TAB WORD IS A DOOR AND A DOOR SHOULD LOOK BACK. The bar answered a press -// ([app.placeTabPress]) and said nothing at all while a pointer crossed it, so -// seven words that open seven rooms read as a label strip until somebody -// gambled a click on one. The lift is the selected word's own ink and weight -// with no band under it (pages.go's [app.tabBarAt]) — a band would make the -// hovered word look like the room a person is standing in, and a bar with two -// grounds on it says nothing clearly. -// -// Hovering a tab changes no cursor, place or window. Clicking opens the place; -// leaving the bar puts the ink back. -func (a *app) placeTabHover(x, y int) bool { - if !a.pageShowing() || a.tabRow < 1 || y != a.tabRow { - // THE POINTER LEAVING THE ROW IS NEWS TOO, and it is the half that is easy - // to forget: a word left lifted after the hand moved away is a door that - // claims to be under a pointer that is somewhere else. - a.barHover(pageNone) - return false - } - under := pageNone - for _, span := range a.tabs { - if x >= span.from && x < span.to { - under = span.id - break - } - } - a.barHover(under) - // THE ROW IS THE BAR'S WHETHER OR NOT A WORD WAS UNDER THE POINTER, for - // [app.placeTabPress]'s reason: the gap between two chips belongs to no room, - // and letting it fall through would light a body row the pointer visually is - // not on. - return true -} - -// placeTabWheel is the wheel turned over the tab bar: IT WALKS THE PLACES. +// placeTabWheel is the wheel turned over the nav's row on a place: IT WALKS +// THE PLACES. // // The wheel means "the next one of these" everywhere else on this surface — it // walks a list's cursor, three rows a tick (placeWheelRows) — and over a row @@ -139,7 +64,7 @@ func (a *app) placeTabHover(x, y int) bool { // open two rooms nobody asked to see on its way to the third, and each of those // openings closes the last room and throws away its filter. func (a *app) placeTabWheel(y int, delta int) (tea.Cmd, bool) { - if !a.pageShowing() || a.tabRow < 1 || y != a.tabRow || delta == 0 { + if !a.pageShowing() || a.tabRow < 0 || y != a.tabRow || delta == 0 { return nil, false } return a.walkPage(delta < 0), true diff --git a/internal/tui3/placemouse_test.go b/internal/tui3/placemouse_test.go index 4069439883..d1d9046fb4 100644 --- a/internal/tui3/placemouse_test.go +++ b/internal/tui3/placemouse_test.go @@ -72,7 +72,7 @@ func TestClickingATabWordGoesToThatPlace(t *testing.T) { if !ok { t.Fatal("the spend tab is not on this bar") } - drive(t, a, tea.MouseClickMsg{X: x, Y: placeTabRow, Button: tea.MouseLeft}) + drive(t, a, tea.MouseClickMsg{X: x, Y: navRow, Button: tea.MouseLeft}) if a.page != pageSpend { t.Fatalf("clicking the spend tab left the router on %q", a.page.word()) } @@ -86,23 +86,25 @@ func TestClickingATabWordGoesToThatPlace(t *testing.T) { // The spend place has no box, so what a reopen would reset is its cursor. a.moveSpend(1) was := a.spend.cursor - drive(t, a, tea.MouseClickMsg{X: x, Y: placeTabRow, Button: tea.MouseLeft}) + drive(t, a, tea.MouseClickMsg{X: x, Y: navRow, Button: tea.MouseLeft}) if a.spend.cursor != was { t.Fatalf("pressing the tab you are on reopened the place: the cursor moved from %d to %d", was, a.spend.cursor) } } -// AND A PRESS BETWEEN TWO WORDS DOES NOTHING. The gap belongs to no room, and -// a bar that rounded a miss to its nearest neighbour would be a bar that opens -// the wrong place for a one-cell slip. +// AND A PRESS IN THE NAV'S AIR DOES NOTHING. Two words' buttons touch, each +// owning its own pad cells, so the air on the row is the cells before the +// first button and after the last; they belong to no room, and a row that +// rounded a miss to its nearest neighbour would open the wrong place for a +// one-cell slip. func TestClickingBetweenTwoTabsDoesNothing(t *testing.T) { a := placeApp(t) placeFrameText(a) gap, ok := placeTabGapColumn(a) if !ok { - t.Fatal("this bar has no gap between two chips") + t.Fatal("this nav has no air before its first button") } - drive(t, a, tea.MouseClickMsg{X: gap, Y: placeTabRow, Button: tea.MouseLeft}) + drive(t, a, tea.MouseClickMsg{X: gap, Y: navRow, Button: tea.MouseLeft}) if a.page != pageHome { t.Fatalf("a press in the gap moved to %q", a.page.word()) } @@ -126,7 +128,7 @@ func TestAFrameWithNoTabBarHasNoTabToPress(t *testing.T) { if a.tabRow >= 0 { t.Fatalf("the phone frame claims a tab bar on row %d", a.tabRow) } - drive(t, a, tea.MouseClickMsg{X: 4, Y: placeTabRow, Button: tea.MouseLeft}) + drive(t, a, tea.MouseClickMsg{X: 4, Y: navRow, Button: tea.MouseLeft}) if a.page != pageHome { t.Fatalf("a press on the phone frame's second row went to %q", a.page.word()) } @@ -142,16 +144,18 @@ func placeTabColumnOf(a *app, id page) (int, bool) { return 0, false } -// placeTabGapColumn is a cell between two chips: the last column before the -// second chip begins, which no chip claims. +// placeTabGapColumn is a cell of the nav's air: the last column before the +// first button, between it and the wordmark, which no button claims. func placeTabGapColumn(a *app) (int, bool) { - if len(a.tabs) < 2 { + if len(a.tabs) < 1 || a.tabs[0].from < 1 { return 0, false } - if a.tabs[1].from-1 < a.tabs[0].to { - return 0, false + for _, span := range a.tabs { + if a.tabs[0].from-1 >= span.from && a.tabs[0].from-1 < span.to { + return 0, false + } } - return a.tabs[1].from - 1, true + return a.tabs[0].from - 1, true } // ── the wheel ─────────────────────────────────────────────────────────────── diff --git a/internal/tui3/placewalk_test.go b/internal/tui3/placewalk_test.go index 4d8dee3502..2bbe82d821 100644 --- a/internal/tui3/placewalk_test.go +++ b/internal/tui3/placewalk_test.go @@ -27,7 +27,7 @@ func TestTabWalksEveryPlaceAndEachOneOpens(t *testing.T) { a := placeApp(t) ring := barPages(pageHome, false) seen := map[page]bool{a.page: true} - for range len(ring) { + for range len(ring) - 1 { was := a.page drive(t, a, key("tab")) if a.page == was { @@ -38,13 +38,14 @@ func TestTabWalksEveryPlaceAndEachOneOpens(t *testing.T) { } seen[a.page] = true } - if len(seen) != len(ring) { + // The walk steps over the way back to the chats (place_chats.go). + if len(seen) != len(ring)-1 { t.Fatalf("tab visited %d of the %d places on the bar: %v", len(seen), len(ring), seen) } if a.page != pageHome { t.Fatalf("the circle came back to %q rather than home", a.page.word()) } - for _, id := range pages()[placeBarPlaces:] { + for _, id := range placeOrder[placeBarPlaces:] { drive(t, a, key(placeChord(id))) if a.page != id || !a.pageShowing() { t.Fatalf("%s left the router on %q with the frame %v", placeChord(id), a.page.word(), a.pageShowing()) @@ -104,7 +105,7 @@ func TestThePlaceWithNoStoreOpensAndSaysSoOnTheFrame(t *testing.T) { // was every door onto it. func TestTheTasksPlaceOpensOnAChatThatHasDelegatedNothing(t *testing.T) { a := placeApp(t) - drive(t, a, key("alt+2")) + drive(t, a, key(placeChord(pageTasks))) if a.page != pageTasks || !a.at(pageTasks) { t.Fatal("the tasks place did not open") } diff --git a/internal/tui3/planrail.go b/internal/tui3/planrail.go index a4ccbacb7e..751fe43573 100644 --- a/internal/tui3/planrail.go +++ b/internal/tui3/planrail.go @@ -12,8 +12,8 @@ package tui3 // SO THERE IS ONE RENDERER AND THIS FILE IS ITS ADAPTER. A store row is lent a // [taskNode] ([planRailNode]) carrying only what the store knows — its title, // its state, when it started, what it has cost, and the step it is running — -// and that node is drawn by [app.railEntryRows], the function every node row on -// the column is drawn by. A figure the store does not keep, such as tokens or +// and that node is drawn by [app.railEntryRow], the function every node row on +// the side column is drawn by: one line, its glyph, its name and its time. A figure the store does not keep, such as tokens or // the model, is left unset, and the renderer's emptiness law draws nothing for // it rather than a zero. @@ -224,22 +224,39 @@ func planTwigsOf(rows []session.PlanTaskRow) []*planTwig { } // planRailLines draws a run's parts under a row, each one THROUGH THE NODE -// RENDERER and in the old tree's connectors: `stems` is the ancestry of the row -// they hang from, and `more` says whether rows of that one's own come after -// them, so the last part closes its branch only when nothing else hangs there. +// RENDERER and one line each, as every task on the side column is (sidecol.go): +// depth is how far under the row they hang, two cells a level, which is the +// only shape the column gives a family now that its forest is gone. // // Every line a part draws carries its store id, which is what makes it a door // onto that task's page ([app.openRailPlan]). -func (a *app) planRailLines(kids []*planTwig, stems []bool, more bool, width int) []railLine { +func (a *app) planRailLines(kids []*planTwig, depth, width int) []railLine { var out []railLine - for i, kid := range kids { - after := i < len(kids)-1 || more - at := append(append([]bool(nil), stems...), after) - rows, _, _ := a.railEntryRows(railEntry{node: planRailNode(kid.row), stems: at, root: len(kid.kids) > 0}, width) - for j, text := range rows { - out = append(out, railLine{text: text, entry: -1, plan: kid.row.ID, head: j == 0}) + lead := strings.Repeat(" ", depth) + for _, kid := range kids { + text := a.railEntryRow(railEntry{node: planRailNode(kid.row)}, max(width-len(lead), 0)) + out = append(out, railLine{text: lead + text, entry: -1, plan: kid.row.ID, head: true}) + out = append(out, a.planRailLines(kid.kids, depth+1, width)...) + } + return out +} + +// planPageLines is [app.planRailLines] for a task's page, which has the room +// the side column gave up: under each part's one line stand the lines the +// column moved to its hint ([app.railUnder]), what the part is doing and what +// it is costing, so the page still names a call in flight the way the rail +// once did beside the row. +func (a *app) planPageLines(kids []*planTwig, depth, width int) []railLine { + var out []railLine + lead := strings.Repeat(" ", depth) + room := max(width-len(lead), 0) + for _, kid := range kids { + node := planRailNode(kid.row) + out = append(out, railLine{text: lead + a.railEntryRow(railEntry{node: node}, room), entry: -1, plan: kid.row.ID, head: true}) + for _, under := range a.railUnder(node, max(room-4, 0)) { + out = append(out, railLine{text: lead + " " + under, entry: -1, plan: kid.row.ID}) } - out = append(out, a.planRailLines(kid.kids, at, false, width)...) + out = append(out, a.planPageLines(kid.kids, depth+1, width)...) } return out } @@ -247,12 +264,9 @@ func (a *app) planRailLines(kids []*planTwig, stems []bool, more bool, width int // planRailRoot draws one run whose own row no node on the column carries: its // row, then its parts, every one of them through the node renderer. func (a *app) planRailRoot(twig *planTwig, width int) []railLine { - rows, _, _ := a.railEntryRows(railEntry{node: planRailNode(twig.row), root: len(twig.kids) > 0}, width) - out := make([]railLine, 0, len(rows)) - for j, text := range rows { - out = append(out, railLine{text: text, entry: -1, plan: twig.row.ID, head: j == 0}) - } - return append(out, a.planRailLines(twig.kids, nil, false, width)...) + text := a.railEntryRow(railEntry{node: planRailNode(twig.row)}, width) + out := []railLine{{text: text, entry: -1, plan: twig.row.ID, head: true}} + return append(out, a.planRailLines(twig.kids, 1, width)...) } // ── THE PAGE A RUN'S ROW OPENS ───────────────────────────────────────────── diff --git a/internal/tui3/pulse.go b/internal/tui3/pulse.go index ae4944dc1c..11b940d468 100644 --- a/internal/tui3/pulse.go +++ b/internal/tui3/pulse.go @@ -1,12 +1,13 @@ package tui3 -// THE PULSE: THE ONE LINE AT THE TOP OF EVERY FRAME. +// THE PULSE: THE FAR END OF THE LINE AT THE TOP OF EVERY FRAME. // -// codeaf 2 want you · 4 moving · $0.55 / $20.00 · tue 1:11pm -// codeaf $0.55 / $20.00 · tue 1:11pm +// >● codeaf home teams chats … 2 want you · 4 moving · $0.55 / $20.00 · tue 1:11pm +// >● codeaf home teams chats … $0.55 / $20.00 · tue 1:11pm // -// The program's name on the left, and right-aligned on the other end — quiet -// unless it has a reason not to be — the machine's own vital signs. The first +// The program's name and the places on the left (topnav.go), and right-aligned +// on the other end, quiet unless it has a reason not to be, the machine's own +// vital signs. The first // line is a conversation's and every place's; the second is home's, which leaves // its counts to the panels under it (DESIGN.md's law 11, [pulseBudget]). It is the // watch made visible (docs/HOME-BRIDGE.md): a person who has just sat down learns @@ -50,7 +51,21 @@ package tui3 // sheds a word about the machine. (What this law used to say was "THE CLOCK // ALWAYS DRAWS", and it was read as a width law as well as an emptiness law, // which is how sixty columns came to spend twelve cells on `thu 12:01am` -// while the whole right end went unwritten — see [app.pulseRungs].) +// while the whole right end went unwritten.) +// +// - THE LADDER IS THE NAV'S NOW (topnav.go's [app.navTails]). The line shares +// its row with the places, and the owner ruled the order the row gives +// things up in (2026-09-24): the clock, then the moving count, then the +// words of `2 want you` (never its count), then the places fold, and the +// day's figure is the last clause but one standing. +// +// - AND THE COUNT THAT WANTS YOU NEVER LEAVES THE ROW. It was allowed to, +// for one wave, on the argument that a place's own rows and the strip's +// marks say it too; at eighty columns that left a conversation's frame +// with no number anywhere on its top line for the things stopped on the +// person reading it, which is the one fact a glance at this row is for. +// So `2 want you` shortens to `2 ?` in the same amber before anything +// else is given up, and it outlasts the money and the places. // // - THE ALLOWANCE IS A FRACTION HERE, AND THE OWNER OVERRULED THIS FILE TO PUT // IT THERE. What stood here for four waves was the opposite law, and it read: @@ -78,8 +93,6 @@ package tui3 import ( "strings" "time" - - "github.com/charmbracelet/x/ansi" ) // The words the pulse says, quoted in internal/manual/chat/home.md exactly as @@ -124,110 +137,6 @@ const ( pulseBudget ) -// pulseLine is that line, painted, exactly `width` cells wide at most. -// -// THE NAME NEVER GIVES WAY TO THE SEGMENTS. A frame too narrow to hold both -// draws the name alone: the segments are a glance somebody takes and the name is -// what tells them which program they are looking at, and a top line that clipped -// the second to fit the first would have got the order of those two backwards. -// -// AND THE SEGMENTS GIVE WAY ONE AT A TIME, BY RANK. This line used to be drawn -// ALL OR NOTHING: everything, or the name alone. So a sixty-column frame — a -// split pane, an ssh session from a train — spent twelve of its cells on -// `thu 12:01am` and then, one segment later, threw the whole right end away and -// said nothing about the machine at all. It walks [app.pulseRungs] now, which is -// [rowfit.go]'s ranked-prefix law applied to this line: the widest rung that -// fits is the one drawn, and what a narrow frame shows is a SUBSET of what a -// wide one shows rather than a different line. -func (a *app) pulseLine(width int, pal palette, mode pulseMode) string { - // THE NAME IS STRUCTURE, SO IT WEARS A QUIET ROLE. THE ACCENT BUDGET IS ONE - // THING PER SCREEN and it is always the live one — the row waiting on - // somebody, the work in flight, the card under the cursor. A product name is - // none of those: it is the same word on every frame home has ever drawn, - // which is the definition of a thing the eye learns to skip, and spending the - // loudest hue on it left home with two places claiming to be first. - // - // So it takes the second tier — one rung above the margin it shares the line - // with, so it still reads as the line's head — and keeps the WEIGHT, which is - // what says "this is the title" on a sixteen-colour terminal that has no rungs - // to spend. - // AND IT IS THE ONE NAME, READ OFF THE ONE CONSTANT (styles.go's [product]). - // This line used to hold a second spelling of its own (`pulseName`), which is - // how the surface came to greet a fresh install with one name in the wordmark - // and another in the prose under it. - name := " " + pal.wordmark(width) - for _, tail := range a.pulseRungs(a.now(), pal, mode) { - if tail == "" { - break - } - gap := width - ansi.StringWidth(name) - ansi.StringWidth(tail) - 1 - if gap >= 1 { - return name + strings.Repeat(" ", gap) + tail - } - } - return name -} - -// pulseRungs is every line the right end of the pulse is allowed to be, WIDEST -// FIRST, and it is where this file's ranking is written down. -// -// ── THE RANK, AND THE ARGUMENT FOR IT ── -// -// From the top of the ladder down, the order things are given up in is: the -// clock, then the day's ALLOWANCE, then the day's SPEND, then what is moving, -// and the count of what has stopped on a person is the last thing on the line to -// go. THE ARGUMENT IS ONE SENTENCE: the terminal's own bar, the window manager -// and the wall clock all say what time it is, and nothing anywhere else on this -// machine says that two pieces of work have stopped and will not move until -// somebody looks — so a cell that could carry either carries the one that is -// only available here, and the whole ladder falls out of ranking the segments by -// how much a person could have learned that fact any other way. -// -// Within that, `2 want you` outranks `4 moving` because a thing that has stopped -// needs a person and a thing in flight does not, which is the sort order of the -// list underneath this line said again; and the spend outranks the allowance -// because a figure is a fact and a fraction is that fact plus a bound, so the -// bound is the half that can go while the clause still says something true. -// -// ── AND A DROPPED SEGMENT MAY NOT MAKE THE LINE LIE ── -// -// This is the constraint that shapes the money rungs. The allowance is dropped -// by RESPELLING the money clause — `$0.55 / $20.00` becomes `$0.55`, which is -// what this line said for four waves and is true — and the spend is dropped by -// removing the clause whole, which leaves no `$` on the line at all. What must -// never happen is a narrow frame drawing `$0.00`, or a `/ $20.00` with nothing -// in front of it: either would be the line reporting a figure it had actually -// given up on. (The ONE sanctioned `$0.00` on this surface is the live status -// line of a conversation, so its segments do not jump sideways as money arrives -// — that is what [dollars] returning `$0.00` at zero is for. It is not this -// line, and this line never borrows the exception: the emptiness law keeps a -// zero day off the pulse ([app.pulseParts]) and the ladder never puts one back. -func (a *app) pulseRungs(now time.Time, pal palette, mode pulseMode) []string { - p := a.pulseParts(now, pal, mode) - rung := func(parts ...string) string { - var kept []string - for _, part := range parts { - if part != "" { - kept = append(kept, part) - } - } - return strings.Join(kept, pulseGap) - } - // The rungs, in the order the ladder is climbed down. Two neighbours can come - // out identical — a machine with no allowance set has one money spelling, a - // quiet day has none — and a rung that is the same string as the one above it - // simply fails the same measurement twice, which costs nothing and keeps the - // ladder readable as the list of decisions it is. - return []string{ - rung(p.wants, p.hands, p.money, p.clock), - rung(p.wants, p.hands, p.money), - rung(p.wants, p.hands, p.spend), - rung(p.wants, p.hands), - rung(p.wants), - "", - } -} - // pulseSegments is what the right of the line says, in order and already // painted, with every segment that is not true left out. // @@ -238,8 +147,8 @@ func (a *app) pulseRungs(now time.Time, pal palette, mode pulseMode) []string { // all three at once, which is why the design put them here — it is the whole // machine in four clauses. // -// It is the TOP RUNG of [app.pulseRungs] and it is built out of the same pieces, -// so the widest line this file can draw and the line the ladder starts from can +// It is the TOP RUNG of the nav's ladder ([app.navTails]) and it is built out of +// the same pieces, so the widest line and the line the ladder starts from can // never come to disagree about how a segment is spelled. func (a *app) pulseSegments(now time.Time, pal palette) []string { p := a.pulseParts(now, pal, pulseWhole) @@ -254,12 +163,18 @@ func (a *app) pulseSegments(now time.Time, pal palette) []string { // pulseParts is every clause the top line can carry, each already painted and // each "" where the emptiness law says it is not true. It is ONE FUNCTION rather -// than two so that [app.pulseSegments] and [app.pulseRungs] cannot drift. +// than two so that [app.pulseSegments] and [app.navTails] cannot drift. // // `money` and `spend` are the two spellings of one clause — the fraction and the // figure — and they are the ladder's way of giving up the allowance without // giving up the day's bill. -type pulseParts struct{ wants, hands, money, spend, clock string } +// +// `wants` and `ask` are the two spellings of the other clause that has two: +// `2 want you` and `2 ?`, the same count in the same amber, the second in the +// mark every tab and square waiting on a person wears ([tabSignalGlyph]). It +// is how the ladder keeps the one thing that may never vanish on a row too +// narrow for the words. +type pulseParts struct{ wants, ask, hands, money, spend, clock string } func (a *app) pulseParts(now time.Time, pal palette, mode pulseMode) pulseParts { facts := a.machine @@ -277,6 +192,7 @@ func (a *app) pulseParts(now time.Time, pal palette, mode pulseMode) pulseParts // loudest thing this line can say and it is the first thing on it, which // is the sort order of the list underneath said in one segment. p.wants = pal.warn(itoa(facts.wants) + pulseWantWord) + p.ask = pal.warn(itoa(facts.wants) + " " + tabSignalGlyph(tabNeedsPerson, pal.ascii)) } if facts.hands > 0 { // CYAN, AND THE WHOLE CLAUSE, for the same reason: in flight is one fact. diff --git a/internal/tui3/questiondemo.go b/internal/tui3/questiondemo.go index 3b4bfef47c..a07babda96 100644 --- a/internal/tui3/questiondemo.go +++ b/internal/tui3/questiondemo.go @@ -295,7 +295,7 @@ func demoStandingCard() session.Question { Ask: session.AskChoice, Form: session.FormCard, Asker: session.Asker{Kind: session.AskerModel}, - Head: session.StandingAskLead + "the release notes every Monday at 9am", + Head: session.StandingHeadCheck, Reason: session.StandingAskReason, Stakes: session.StakesReversible, // THE WORDS ARE THE CARD'S OWN CONSTANTS and never a second spelling of diff --git a/internal/tui3/questionkeys.go b/internal/tui3/questionkeys.go index 36e797adf5..2e709fe500 100644 --- a/internal/tui3/questionkeys.go +++ b/internal/tui3/questionkeys.go @@ -6,6 +6,7 @@ import ( "github.com/charmbracelet/x/ansi" "github.com/Agent-Field/codeaf/internal/session" + "github.com/Agent-Field/codeaf/internal/standing" ) // ── ONE KEY GRAMMAR, SPELLED ONCE ─────────────────────────────────────────── @@ -491,6 +492,15 @@ const questionKeyGap = " · " func questionVerbWord(q questionShown, verb questionVerb) string { switch verb.key { case questionCommentKey: + if q.question.Kind == session.QuestionStanding { + // THE CORRECTION BUTTON SAYS WHAT IT IS. A rule's is about where + // the rule reaches. The head is the kind, which is how this row + // knows without a second copy of the words. + if q.question.Head == session.StandingHeadRule { + return session.StandingChangeWord(standing.Item{When: standing.When{Kind: standing.WhenHold}}) + } + return standChangeWord + } if q.question.Ask == session.AskRatify { return "change" } diff --git a/internal/tui3/questionnarrow.go b/internal/tui3/questionnarrow.go index a8c205f83a..10645231ae 100644 --- a/internal/tui3/questionnarrow.go +++ b/internal/tui3/questionnarrow.go @@ -276,10 +276,18 @@ func (a *app) questionNarrowBody(body string, width int) []string { // consequence the card draws beside it is dropped here: a band is a target and // reads at a glance, and a word cut off mid-reach says less than a short one. func (a *app) questionBandWord(word, key string, width int) string { - if room := width - len(questionBandPad) - ansi.StringWidth(key) - 4; ansi.StringWidth(word) > room { - return fit(word, room) + room := width - len(questionBandPad) - ansi.StringWidth(key) - 4 + if ansi.StringWidth(word) <= room { + return word } - return word + // A YES THAT CARRIES A CADENCE LOSES THE CADENCE BEFORE ANY CHARACTER IS + // CUT. "Set it up · every 3 hours" becomes "Set it up", and only then is + // the stem truncated. + plain := session.StandingPlainLabel(word) + if ansi.StringWidth(plain) <= room { + return plain + } + return fit(plain, room) } // questionBandRow is one answer, drawn as a row: the pointer where the pointer diff --git a/internal/tui3/quicktask_test.go b/internal/tui3/quicktask_test.go index c802595085..01b6229dd7 100644 --- a/internal/tui3/quicktask_test.go +++ b/internal/tui3/quicktask_test.go @@ -71,12 +71,12 @@ func TestAQuickRowSaysWhatItIsDoingAndNamesNoBranch(t *testing.T) { } } -// AND A QUICK NODE STARTED FROM A TASK HANGS UNDER THAT TASK. Nesting is +// AND A QUICK NODE STARTED FROM A TASK IS FILED UNDER THAT TASK. Nesting is // [session.TaskNotice.Parent] and nothing else, so a quick node the engine -// files under its caller is drawn on the caller's stem with no surface change — -// which is worth pinning because it is the whole of what "it shows on the rail -// like any task" buys. -func TestAQuickNodeUnderATaskIsDrawnOnItsParentsStem(t *testing.T) { +// files under its caller carries its caller with no surface change. The column +// draws what each piece of work is doing rather than a tree, so the quick node +// is its own one-line row in the running group beside its caller. +func TestAQuickNodeUnderATaskIsFiledUnderItsParent(t *testing.T) { a, _, _ := taskApp(t) a.taskUpdate(update(1, "Ship the port", session.TaskRunning, session.TaskNotice{})) notice := quickNotice() @@ -87,19 +87,14 @@ func TestAQuickNodeUnderATaskIsDrawnOnItsParentsStem(t *testing.T) { t.Fatalf("the quick node's parent is %q, want the task it was started from", got) } rows := railText(a, a.viewHeight()) - child, ok := railRowFor(a, a.viewHeight(), "compare files") - if !ok { - t.Fatalf("the quick node has no row:\n%s", strings.Join(rows, "\n")) - } - // THE STEM IS THE CLAIM. A row drawn flat beside its caller says the two - // pieces of work are unrelated, which is the one thing the rail knows they - // are not. - if !strings.Contains(child, "└─") && !strings.Contains(child, "├─") { - t.Fatalf("the quick node was drawn flat rather than under its parent:\n%s", strings.Join(rows, "\n")) - } - parent, ok := railRowFor(a, a.viewHeight(), "Ship the port") - if !ok || strings.Contains(parent, "└─") || strings.Contains(parent, "├─") { - t.Fatalf("the parent is not the root of the family:\n%s", strings.Join(rows, "\n")) + for _, title := range []string{"compare files", "Ship the port"} { + row, ok := railRowFor(a, a.viewHeight(), title) + if !ok { + t.Fatalf("%q has no row:\n%s", title, strings.Join(rows, "\n")) + } + if strings.Contains(row, "└─") || strings.Contains(row, "├─") { + t.Fatalf("the column drew a tree:\n%s", strings.Join(rows, "\n")) + } } } diff --git a/internal/tui3/railaway_test.go b/internal/tui3/railaway_test.go index 99cb7c3938..dbb2ad5a4c 100644 --- a/internal/tui3/railaway_test.go +++ b/internal/tui3/railaway_test.go @@ -41,7 +41,7 @@ func TestTheTaskColumnClosesAndReopensOnItsKey(t *testing.T) { t.Fatal("a session with five nodes drew no column to close") } full := a.width - if a.bodyWidth() != full-railCols { + if a.bodyWidth() != full-sideColsFor(full) { t.Fatalf("the open column is not charged against the conversation: body=%d", a.bodyWidth()) } @@ -54,7 +54,7 @@ func TestTheTaskColumnClosesAndReopensOnItsKey(t *testing.T) { // glyph of state, and no task's name anywhere (task.go's [app.railGripRows]) // — which is a different thing from the column and is tested as one below. edge := plain(strings.Join(a.railRows(a.viewHeight()), "\n")) - for _, gone := range []string{"Ship the port", "Read the law", railStowHint} { + for _, gone := range []string{"Ship the port", "Read the law", sideTasksWord} { if strings.Contains(edge, gone) { t.Fatalf("a closed column still drew %q:\n%q", gone, edge) } @@ -77,7 +77,7 @@ func TestTheTaskColumnClosesAndReopensOnItsKey(t *testing.T) { if !a.railShowing() { t.Fatal("ctrl+g did not bring the column back") } - if a.bodyWidth() != full-railCols { + if a.bodyWidth() != full-sideColsFor(full) { t.Fatalf("the reopened column is not charged against the conversation: body=%d", a.bodyWidth()) } rail := strings.Join(railText(a, a.viewHeight()), "\n") @@ -88,60 +88,41 @@ func TestTheTaskColumnClosesAndReopensOnItsKey(t *testing.T) { } } -// THE TOP CONTROL NAMES THE KEY, AND THE LINE IS A BUTTON. A door that -// only the keyboard can open is a door half this surface cannot find. +// THE HEADER NAMES THE KEY, AND THE KEY IS A BUTTON. A door that only the +// keyboard can open is a door half this surface cannot find. func TestTheColumnDrawsItsOwnDoorAndThePressClosesIt(t *testing.T) { a, _, _ := taskApp(t) a.profileDir = t.TempDir() railRun(a) rows := railText(a, a.viewHeight()) - if !strings.Contains(strings.Join(rows, "\n"), railStowHint) { - t.Fatalf("the column drew no way out of itself:\n%s", strings.Join(rows, "\n")) - } - // AND THE CHEVRON IS ON IT, pointing the way the column goes. It is the half - // of that line the pointer presses, and the words are the half the keyboard - // reads (task.go's [app.railDoorLine]). - if !strings.Contains(strings.Join(rows, "\n"), railGripOpenGlyph+" "+railStowHint) { - t.Fatalf("the column's door carries no chevron:\n%s", strings.Join(rows, "\n")) + if !strings.HasSuffix(strings.TrimRight(rows[0], " "), sideHideKey) { + t.Fatalf("the column's header names no way out of it: %q", rows[0]) } // The paint is asked of the RAW rows: railText strips ANSI for reading, and // an assertion about a palette run on stripped text passes only where the // palette paints nothing. painted := strings.Join(a.railRows(a.viewHeight()), "\n") - if !strings.Contains(painted, a.pal.data(railStowKey)) || - !strings.Contains(painted, a.pal.dim(" hide")) { - t.Fatalf("the close door does not use the shared hint palette:\n%q", painted) + if !strings.Contains(painted, a.pal.dim(sideHideKey)) { + t.Fatalf("the key is not in the quiet ink of a hint:\n%q", painted) } - // Hiding stays at the top while the task action follows the list. + // The header stays at the top while the task action follows the list. lines, _ := a.railView(a.viewHeight()) - door, task := -1, -1 + task := -1 for i, line := range lines { - if line.stow { - door = i - } if line.door == marginTaskType { task = i } } - if door != 0 || task <= door+1 { - t.Fatalf("hide row %d is not pinned above the list and task action %d", door, task) + if lines[0].side == nil || lines[0].side.key != sideHeadKey || task <= 1 { + t.Fatalf("the header is not pinned above the list and task action %d", task) } - pressed := false - for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - if line, ok := a.railLineAt(y); ok && line.stow { - drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) - pressed = true - break - } - } - if !pressed { - t.Fatal("the column's door was drawn on no pressable line") - } + x, y := sideDoorOf(t, a, sideActHide) + drive(t, a, tea.MouseClickMsg{X: x, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: x, Y: y, Button: tea.MouseLeft}) if !a.railAway || a.railShowing() { - t.Fatal("a press on the door did not close the column") + t.Fatal("a press on the key did not close the column") } } @@ -161,7 +142,7 @@ func TestAClosedColumnStillSaysWhereTheWorkIs(t *testing.T) { if !a.railAway { t.Fatal("ctrl+g did not close the empty column") } - if a.hintWord() == railBackHint { + if a.hintWord() == a.sideBackHint() { t.Fatal("a session with no work at all offered the way back to a roster of nothing") } drive(t, a, ctrlG()) @@ -178,8 +159,8 @@ func TestAClosedColumnStillSaysWhereTheWorkIs(t *testing.T) { if !strings.Contains(strip, "Ship the port") { t.Fatalf("the strip named no running node:\n%s", strip) } - if got := a.hintWord(); got != railBackHint { - t.Fatalf("the legend's hint reads %q, want %q", got, railBackHint) + if got := a.hintWord(); got != a.sideBackHint() { + t.Fatalf("the legend's hint reads %q, want %q", got, a.sideBackHint()) } // AND THE STRIP'S OWN DOOR BRINGS THE COLUMN BACK. Asking for the whole @@ -197,7 +178,7 @@ func TestAClosedColumnStillSaysWhereTheWorkIs(t *testing.T) { func TestTheKeyFallsThroughWhereNoRosterIsOnTheFrame(t *testing.T) { a, _, _ := taskApp(t) a.profileDir = t.TempDir() - // Under railSlimFloor there is no column to lend (task.go's [railColsFor]). + // Under railSlimFloor there is no column to lend (sidecol.go's [sideColsFor]). a.width = railSlimFloor - 20 railRun(a) @@ -308,7 +289,7 @@ func TestTheClosedColumnLeavesAnEdgeYouCanClick(t *testing.T) { if a.railAway || !a.railShowing() { t.Fatal("pressing the edge did not bring the column back") } - if a.bodyWidth() != full-railCols { + if a.bodyWidth() != full-sideColsFor(full) { t.Fatalf("the reopened column is not charged against the conversation: body=%d", a.bodyWidth()) } } @@ -378,34 +359,20 @@ func TestTheChevronClosesAndOpensTheColumnByPointerAlone(t *testing.T) { t.Fatal("a session with five nodes drew no column") } - // THE OPEN LEG: the door line lights under the pointer and closes on a press. - door := -1 - for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - if line, ok := a.railLineAt(y); ok && line.stow { - door = y - } - } - if door < 0 { - t.Fatal("the standing column drew its door on no pressable line") + // THE OPEN LEG: the header's key lights under the pointer and closes the + // column on a press. + x, y := sideDoorOf(t, a, sideActHide) + a.setHover(x, y) + if a.hot.kind != hoverSide || a.hot.key != sideHeadKey || a.hot.index < 0 { + t.Fatalf("the pointer over the column's key lit nothing: %+v", a.hot) } - at := a.bodyWidth() + ansi.StringWidth(railSeam) - a.setHover(at, door) - if !a.hoveringRailDoor() { - t.Fatalf("the pointer over the column's door lit nothing: %+v", a.hot) + if lit := strings.Join(a.railRows(a.viewHeight()), "\n"); !strings.Contains(lit, a.pal.cursor(a.pal.ink(sideHideKey), 0)) { + t.Fatalf("the key did not take its hover ground:\n%q", lit) } - lit := "" - for _, row := range railText(a, a.viewHeight()) { - if strings.Contains(row, railStowHint) { - lit = row - } - } - if !strings.Contains(lit, railGripOpenGlyph) { - t.Fatalf("the lit door lost its chevron: %q", lit) - } - drive(t, a, tea.MouseClickMsg{X: at, Y: door, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: at, Y: door, Button: tea.MouseLeft}) + drive(t, a, tea.MouseClickMsg{X: x, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: x, Y: y, Button: tea.MouseLeft}) if !a.railAway || a.railShowing() { - t.Fatal("pressing the chevron did not close the column") + t.Fatal("pressing the key did not close the column") } // THE CLOSED LEG: the same control, the other way. @@ -416,9 +383,6 @@ func TestTheChevronClosesAndOpensTheColumnByPointerAlone(t *testing.T) { if !strings.Contains(edge, railGripGlyph) { t.Fatalf("the edge carries no chevron:\n%q", edge) } - if strings.Contains(edge, railGripOpenGlyph) { - t.Fatalf("the edge carries the chevron of the other state:\n%q", edge) - } drive(t, a, tea.MouseClickMsg{X: a.bodyWidth(), Y: a.bodyTop(), Button: tea.MouseLeft}) drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth(), Y: a.bodyTop(), Button: tea.MouseLeft}) if a.railAway || !a.railShowing() { diff --git a/internal/tui3/railclick_test.go b/internal/tui3/railclick_test.go index 7048e9fd37..319c7e0252 100644 --- a/internal/tui3/railclick_test.go +++ b/internal/tui3/railclick_test.go @@ -71,13 +71,14 @@ func railFamily(a *app) { unverifiedNotice("finished, but the key table still drops the last key"))) railKinship(a, 1, 2, 3, 5, 6) railKinship(a, 3, 4) - // AND ONE FINISHED ROW WITH NO FAMILY AROUND IT. It is the second row that - // could fold — a landed flat row tucks its own block away - // ([app.railTucks]) — so it is the second row whose leading cell used to - // swallow the press. + // AND ONE FINISHED ROW WITH NO FAMILY AROUND IT, the other shape a row + // used to come in. a.taskUpdate(update(9, "Collect the fixture sources", session.TaskDone, session.TaskNotice{ Elapsed: 8 * time.Second, Merge: mergeWordMerged, })) + // EVERY GROUP OPEN, so every row these tests press is drawn: the folds are + // [TestAFoldIsRememberedForTheSession]'s. + railOpenAll(a) a.paints = 0 } @@ -107,80 +108,25 @@ func railClick(t *testing.T, a *app, x, y int) { // ── DEFECT 2: THE STATE CELL IS NOT A CONTROL ─────────────────────────────── -// THE DEFECT ITSELF, ON BOTH ROWS THAT COULD FOLD. With no pointer registered on -// the row — which is every frame after a room is opened, and every frame on a -// terminal that is not reporting motion — the leading cell draws the node's -// STATE, and pressing a state opens the work it is the state of. -func TestTheStateCellOpensTheTaskWhenNoDisclosureIsDrawnOnIt(t *testing.T) { +// THE STATE CELL OPENS THE WORK IT IS THE STATE OF, on every row. No row of +// the list draws a disclosure any more (the folds are the group headings'), +// so the leading cell of a running row and of a finished one is the row's +// door like every other cell on it. +func TestTheStateCellOpensTheTask(t *testing.T) { a, _, _ := roomApp(t) railFamily(a) - glyph := a.bodyWidth() + ansi.StringWidth(railSeam) - - // Nothing on the column is drawn as a disclosure, which is the precondition - // the whole test rests on: the pointer is nowhere near it. - if drawn := strings.Join(railText(a, a.viewHeight()), "\n"); strings.Contains(drawn, glyphOpen) || - strings.Contains(drawn, glyphShut) { - t.Fatalf("the column drew a disclosure with no pointer on it:\n%s", drawn) - } - - // A FAMILY ROOT. Its leading cell is the spinner, so the press is a press on - // a running task and it opens that task. - rootY := railRowY(t, a, 1) - railClick(t, a, glyph, rootY) - if !a.roomOpen() || a.room.id != 1 { - t.Fatalf("the root's state cell did not open its room: open=%v id=%d", - a.roomOpen(), roomID(a)) - } - if _, ok := railRowFor(a, a.viewHeight(), "Read the parser law"); !ok { - t.Fatalf("the press folded the family instead of opening it:\n%s", - strings.Join(railText(a, a.viewHeight()), "\n")) - } - - // A FINISHED FLAT ROW. It has a block tucked under it, so it was the other - // row whose leading cell folded rather than opening ([app.railTucks]). - if e, ok := railEntryFor(a, 9); !ok || !a.railTucks(e) { - t.Fatalf("the fixture's finished row has nothing tucked under it, so it "+ - "is not the row this test is about: found=%v", ok) - } - doneY := railRowY(t, a, 9) - railClick(t, a, glyph, doneY) - if !a.roomOpen() || a.room.id != 9 { - t.Fatalf("the finished row's state cell did not open its room: open=%v id=%d", - a.roomOpen(), roomID(a)) - } -} - -// AND THE FOLD IS STILL THERE, on the cell that is drawn as one. The affordance -// did not move: it appeared under the pointer before this change and it appears -// under the pointer now, and now it is the ONLY thing the press reads. -func TestTheDisclosureUnderThePointerStillFoldsAndTheRestOfTheRowStillOpens(t *testing.T) { - a, _, _ := roomApp(t) - railFamily(a) - glyph := a.bodyWidth() + ansi.StringWidth(railSeam) - rootY := railRowY(t, a, 1) - - a.setHover(glyph, rootY) - if !strings.Contains(mustRailRow(t, a, "Ship the streaming"), glyphOpen) { - t.Fatalf("the pointer on the root revealed no disclosure:\n%q", - mustRailRow(t, a, "Ship the streaming")) - } - railClick(t, a, glyph, rootY) - if a.roomOpen() { - t.Fatalf("the disclosure walked into the room behind it: id=%d", roomID(a)) - } - if _, ok := railRowFor(a, a.viewHeight(), "Read the parser law"); ok { - t.Fatalf("the disclosure did not fold the family:\n%s", - strings.Join(railText(a, a.viewHeight()), "\n")) + glyph := a.bodyWidth() + ansi.StringWidth(railSeam) + 2 + if drawn := strings.Join(railText(a, a.viewHeight()), "\n"); strings.Contains(drawn, " "+glyphOpen) || + strings.Contains(drawn, " "+glyphShut) { + t.Fatalf("a task row drew a disclosure:\n%s", drawn) } - - // ONE CELL WIDE AND NO WIDER. The cell after it is the row's air, and the row - // is the node's door — a fold that ate the space beside it would be the same - // defect one column over. - a.setHover(glyph+1, rootY) - railClick(t, a, glyph+1, rootY) - if !a.roomOpen() || a.room.id != 1 { - t.Fatalf("the cell beside the disclosure did not open the room: open=%v id=%d", - a.roomOpen(), roomID(a)) + for _, id := range []uint64{1, 9} { + a.closeRoom() + railClick(t, a, glyph, railRowY(t, a, id)) + if !a.roomOpen() || a.room.id != id { + t.Fatalf("node %d's state cell did not open its room: open=%v id=%d", + id, a.roomOpen(), roomID(a)) + } } } @@ -193,18 +139,17 @@ func TestTheRailsLeftEdgeOpensTheRowAtEveryWidthTheHandleCannotAct(t *testing.T) for _, tc := range []struct { width int handle bool - cols int }{ - {100, false, railSlimCols}, - {119, false, railSlimCols}, - {120, true, railCols}, - {160, true, railCols}, + {100, false}, + {119, false}, + {120, true}, + {160, true}, } { a, _, _ := roomApp(t) a.width = tc.width railFamily(a) - if got := a.railWidth(); got != tc.cols { - t.Fatalf("at %d columns the rail is %d wide, want %d", tc.width, got, tc.cols) + if got := a.railWidth(); got != sideColsFor(tc.width) { + t.Fatalf("at %d columns the rail is %d wide, want %d", tc.width, got, sideColsFor(tc.width)) } if got := a.railCanWiden(); got != tc.handle { t.Fatalf("at %d columns the handle claims can-widen=%v, want %v", @@ -315,17 +260,23 @@ func TestAPressBelowTheRosterIsNotTheRostersToSwallow(t *testing.T) { // ── THE COLUMN AS A MAP: SWITCHING, SCROLLING, AND THE SHAPES ─────────────── -// EVERY ROW IS A DOOR AND THE DOOR IS THE ROW UNDER THE POINTER. Root, child, -// grandchild, a row waiting on a person, a finished row, and a flat row — pressed -// on the state cell, on the title, and out in the row's trailing air. +// EVERY ROW IS A DOOR AND THE DOOR IS THE ROW UNDER THE POINTER. Running, +// queued and finished rows in the list, and the row waiting on a person in +// the band over it, pressed on the state cell, on the title, and out in the +// row's trailing air. func TestEveryVisibleRowOfTheColumnOpensTheTaskItDraws(t *testing.T) { a, _, _ := roomApp(t) railFamily(a) seam := a.bodyWidth() + ansi.StringWidth(railSeam) - for _, id := range []uint64{1, 3, 4, 5, 6, 2, 9} { + for _, id := range []uint64{1, 3, 4, 5, 2, 9, 6} { for _, at := range []int{0, 4, a.railRoom() - 1} { a.closeRoom() - y := railRowY(t, a, id) + var y int + if id == 6 { + _, y = sideRowOn(t, a, "task/6") + } else { + y = railRowY(t, a, id) + } railClick(t, a, seam+at, y) if !a.roomOpen() || a.room.id != id { t.Fatalf("column %d of node %d's row opened %d, want %d:\n%s", @@ -350,7 +301,7 @@ func TestPressingAnotherRowWhileARoomIsOpenSwitchesToIt(t *testing.T) { if !a.roomStandingOn(a.tasks[1]) { t.Fatal("the roster does not mark the row the reader walked through") } - for _, next := range []uint64{3, 9, 6, 1} { + for _, next := range []uint64{3, 9, 4, 1} { // THE ROW IS FOUND WITH THE PAGE STILL OPEN, which is the case this is // about: the room pins a header above the body, so the roster's rows are // not where they were before anybody walked in (view.go's @@ -456,9 +407,8 @@ func TestTheStowedColumnsEdgeBringsItBackAndOpensNothing(t *testing.T) { // ── THE ROW ITSELF ────────────────────────────────────────────────────────── // ONE GLYPH LEADS EVERY ROW OF THIS COLUMN AND IT IS THE STATE. The identity ◆ -// is furniture that says "this row is a task" (taskident.go) — which is nothing -// this column has to tell apart, since it holds nothing but tasks — and the two -// cells buy name on the narrowest surface here. +// is furniture that says "this row is a task" (taskident.go), which is nothing +// this column has to tell apart, since its list holds nothing but tasks. func TestTheColumnLeadsWithStateAndSpendsNoCellOnIdentity(t *testing.T) { a, _, _ := taskApp(t) railFamily(a) @@ -469,49 +419,19 @@ func TestTheColumnLeadsWithStateAndSpendsNoCellOnIdentity(t *testing.T) { t.Fatalf("row %d spends a cell on the identity mark:\n%q", i, row) } } - // A FLAT ROW AND A FAMILY ROOT NOW LEAD THE SAME WAY, and in the same number - // of cells: the seam, one state glyph, and the air after it. That is what - // lets the column be read downward as one column of states. - flat, root := mustRailRow(t, a, "Collect the fixture"), mustRailRow(t, a, "Ship the streaming") - want := ansi.StringWidth(railSeam) + 2 - for _, probe := range []struct{ row, title string }{ - {flat, "Collect the fixture"}, {root, "Ship the streaming"}, - } { - if got := leadCells(t, probe.row, probe.title); got != want { - t.Fatalf("the row leads in %d cells, want %d:\n%q", got, want, probe.row) - } - } - - // AND THE UNDER-BLOCK IS SQUARE UNDER THE TITLE IT BELONGS TO. It is indented - // [app.railUnderCols] — two cells for a flat row — which is exactly the lead - // now that the ◆ is gone. It was two cells to the left of the title while the - // marker was there. - a.taskUpdate(update(11, "Fix the loader nil-map", session.TaskRunning, session.TaskNotice{})) - a.tasks[11].tool, a.tasks[11].toolBegan = "bash go test ./...", a.now().Add(-30*time.Second) - rows = railText(a, a.viewHeight()) - at := -1 - for i, row := range rows { - if strings.Contains(row, "Fix the loader") { - at = i + // EVERY ROW LEADS THE SAME WAY, in the same number of cells: the seam, + // the indent under its heading, one state glyph, and the air after it. + // That is what lets the column be read downward as one column of states. + want := ansi.StringWidth(railSeam) + 4 + for _, title := range []string{"Collect the fixture", "Ship the streaming", "Cut the goldens"} { + if got := leadCells(t, mustRailRow(t, a, title), title); got != want { + t.Fatalf("the row leads in %d cells, want %d:\n%q", got, want, mustRailRow(t, a, title)) } } - if at < 0 || at+1 >= len(rows) { - t.Fatalf("the running flat row has no under-row:\n%s", strings.Join(rows, "\n")) - } - head, under := rows[at], rows[at+1] - if !strings.Contains(under, "go test") { - t.Fatalf("the row under the title is not the call it is in:\n%q", under) - } - body := strings.TrimPrefix(under, railSeam) - underLead := ansi.StringWidth(railSeam) + len(body) - len(strings.TrimLeft(body, " ")) - if got := leadCells(t, head, "Fix the loader"); got != underLead { - t.Fatalf("the title starts at cell %d and its call at cell %d:\nhead %q\nunder %q", - got, underLead, head, under) - } } -// leadCells is how many cells a drawn row spends before its name — the seam and -// whatever [app.railLead] put in front of the title. +// leadCells is how many cells a drawn row spends before its name: the seam, +// the indent and the state glyph in front of the title. func leadCells(t *testing.T, row, title string) int { t.Helper() at := strings.Index(row, title) @@ -524,13 +444,13 @@ func leadCells(t *testing.T, row, title string) int { // ── THE WHOLE WAY THROUGH THE TERMINAL ────────────────────────────────────── // AND ONE PRESS AS A TERMINAL ACTUALLY SENDS IT: the SGR bytes, through Bubble -// Tea's decoder and its program loop, onto the leading cell of a family root. -// That cell is the one defect 2 was about, and nothing between the wire and +// Tea's decoder and its program loop, onto the leading cell of a row. That +// cell is the one defect 2 was about, and nothing between the wire and // [app.railPress] gets a chance to make it look right. func TestRawTerminalBytesOnARootsStateCellOpenThatTask(t *testing.T) { a, _, _ := roomApp(t) railFamily(a) - x, y := a.bodyWidth()+ansi.StringWidth(railSeam), railRowY(t, a, 1) + x, y := a.bodyWidth()+ansi.StringWidth(railSeam)+2, railRowY(t, a, 1) input, keyboard := io.Pipe() ctx, cancel := context.WithCancel(context.Background()) @@ -569,16 +489,3 @@ func TestRawTerminalBytesOnARootsStateCellOpenThatTask(t *testing.T) { } } } - -// ── small readers ─────────────────────────────────────────────────────────── - -// railEntryFor is the roster's entry for one node, which is what the questions -// about a row's shape ([app.railTucks]) are asked of. -func railEntryFor(a *app, id uint64) (railEntry, bool) { - for _, e := range a.railEntries() { - if e.node != nil && e.node.id == id { - return e, true - } - } - return railEntry{}, false -} diff --git a/internal/tui3/railgroups_test.go b/internal/tui3/railgroups_test.go new file mode 100644 index 0000000000..9323a02513 --- /dev/null +++ b/internal/tui3/railgroups_test.go @@ -0,0 +1,325 @@ +package tui3 + +import ( + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── THE ROSTER'S GROUPS ───────────────────────────────────────────────────── +// +// The column files every task under what it is doing (task.go's +// [app.railEntries]): the running work always open, and the queued, waiting +// and finished work folded to one heading until the person opens it, and then +// remembered open for the session. Every task is one line; what a row used to +// say under it is the hint line's. These are the whole of that claim: the +// shape, the order, the fold and its memory, the two hands that reach it. + +// railKinship hands a node to a parent, in the alphabet the seam speaks +// (taskstrip.go's [taskNode.ParentID]). +func railKinship(a *app, parent uint64, kids ...uint64) { + for _, id := range kids { + a.tasks[id].parent = itoa(int(parent)) + } +} + +// railRun plants one adaptive run: a root the person started, and the tree its +// planner spawned under it. The column does not draw the tree; it draws what +// each node is doing, newest first in each group: +// +// 1 Ship the port running +// ├─ 2 Read the law done +// ├─ 3 Write the tree running +// │ └─ 4 Cut goldens queued +// └─ 5 Wire the seam queued +func railRun(a *app) { + a.taskUpdate(update(1, "Ship the port", session.TaskRunning, session.TaskNotice{})) + a.taskUpdate(update(2, "Read the law", session.TaskDone, session.TaskNotice{})) + a.taskUpdate(update(3, "Write the tree", session.TaskRunning, session.TaskNotice{})) + a.taskUpdate(update(4, "Cut the goldens", session.TaskQueued, session.TaskNotice{})) + a.taskUpdate(update(5, "Wire the seam", session.TaskQueued, session.TaskNotice{})) + railKinship(a, 1, 2, 3, 5) + railKinship(a, 3, 4) + // The spinner is on the frame clock (tokens.Spinner), so a golden has to say + // which frame it was taken on. + a.paints = 0 +} + +// railText is the roster as a reader sees it, row by row. +func railText(a *app, height int) []string { + rows := a.railRows(height) + out := make([]string, len(rows)) + for i, row := range rows { + out[i] = plain(row) + } + return out +} + +// mustRailRow is [railRowFor] over the whole visible column, for the tests that +// would be lying if the row were missing. +func mustRailRow(t *testing.T, a *app, title string) string { + t.Helper() + row, ok := railRowFor(a, a.viewHeight(), title) + if !ok { + t.Fatalf("the column has no row for %q:\n%s", title, + strings.Join(railText(a, a.viewHeight()), "\n")) + } + return row +} + +// railRowFor is the drawn row a node's title is on, and whether there is one. +func railRowFor(a *app, height int, title string) (string, bool) { + for _, row := range railText(a, height) { + if strings.Contains(row, title) { + return row, true + } + } + return "", false +} + +// railFocusOn walks the roster's cursor onto a node, however far down it is. +func railFocusOn(t *testing.T, a *app, id uint64) { + t.Helper() + railOpenAll(a) + for i := 0; i < 40 && a.railWhere.id != id; i++ { + a.railMove(1) + } + if a.railWhere.id != id { + t.Fatalf("the cursor never reached node %d", id) + } +} + +// railOpenAll opens every group that folds, so each row the tests press is +// drawn. +func railOpenAll(a *app) { + for g := range a.side.open { + a.side.open[g] = true + } +} + +// railHeadY is the screen row group g's heading is drawn on, failing the test +// when the column draws none. +func railHeadY(t *testing.T, a *app, g railGroup) int { + t.Helper() + for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { + if e, ok := a.railEntryAt(y); ok && e.head && e.group == g { + return y + } + } + t.Fatalf("group %s has no heading on the column:\n%s", railHeadWords[g], + strings.Join(railText(a, a.viewHeight()), "\n")) + return -1 +} + +// ONE LINE PER TASK, UNDER THE WORD FOR WHAT IT IS DOING. The header, then +// the running work open, newest first, then the groups that fold, each one +// line with its count and its ▸. No blank row, no connectors, no id. +func TestTheRosterIsOneLinePerTaskUnderItsGroups(t *testing.T) { + a, _, _ := taskApp(t) + railRun(a) + spin := a.railTreeGlyph(a.tasks[3]) + rows := railText(a, 12) + idle := a.railGroupOf(a.tasks[4]) + want := []string{ + "│ Running 2", + "│ " + plain(spin) + " Write the tree", + "│ " + plain(spin) + " Ship the port", + "│ " + railHeadWords[idle] + " 2 " + glyphShut, + "│ Done 1 " + glyphShut, + } + if len(rows) < len(want)+1 { + t.Fatalf("the roster drew %d rows:\n%s", len(rows), strings.Join(rows, "\n")) + } + if !strings.HasPrefix(rows[0], "│ "+sideTasksWord+" 5") || !strings.HasSuffix(strings.TrimRight(rows[0], " "), sideHideKey) { + t.Fatalf("the header is %q", rows[0]) + } + for i, w := range want { + // A running row ends in its age, in the muted ink at the right. + got := strings.TrimSuffix(strings.TrimRight(rows[i+1], " "), " 0s") + got = strings.TrimRight(got, " ") + if got != w { + t.Fatalf("row %d is\n\t%q\nwant\n\t%q\nwhole column:\n%s", i+1, got, w, strings.Join(rows, "\n")) + } + } + // EVERY ROW IS INSIDE THE COLUMN, and none of them is a tree. + for i, row := range rows { + if w := ansi.StringWidth(row); w > a.railWidth() { + t.Fatalf("row %d is %d cells wide, want at most %d:\n%q", i, w, a.railWidth(), row) + } + for _, stem := range []string{"├─", "└─", "#1", "#3"} { + if strings.Contains(row, stem) { + t.Fatalf("row %d still draws the forest's %q:\n%q", i, stem, row) + } + } + } +} + +// THE FOLD IS THE PERSON'S AND IT IS REMEMBERED. A press on a folded heading +// opens it, the next update does not close it, a new task does not close it, +// and a second press folds it again. The running work has no fold at all. +func TestAFoldIsRememberedForTheSession(t *testing.T) { + a, _, _ := roomApp(t) + railRun(a) + a.height = 30 + if _, ok := railRowFor(a, a.viewHeight(), "Read the law"); ok { + t.Fatalf("the finished work came up open:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) + } + x := a.bodyWidth() + ansi.StringWidth(railSeam) + 2 + railClick(t, a, x, railHeadY(t, a, railDone)) + if a.roomOpen() { + t.Fatalf("a press on a heading opened a room: id=%d", roomID(a)) + } + if _, ok := railRowFor(a, a.viewHeight(), "Read the law"); !ok { + t.Fatalf("a press on the heading did not open the group:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) + } + if !strings.Contains(mustRailRow(t, a, "Done 1"), glyphOpen) { + t.Fatalf("the open group does not wear ▾: %q", mustRailRow(t, a, "Done 1")) + } + a.taskUpdate(update(2, "Read the law", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) + a.taskUpdate(update(6, "Port the loader", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) + for _, title := range []string{"Read the law", "Port the loader"} { + if _, ok := railRowFor(a, a.viewHeight(), title); !ok { + t.Fatalf("the group the person opened closed itself on an update:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) + } + } + railClick(t, a, x, railHeadY(t, a, railDone)) + if _, ok := railRowFor(a, a.viewHeight(), "Read the law"); ok { + t.Fatalf("a second press did not fold the group:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) + } + // THE RUNNING WORK DOES NOT FOLD, and its heading says so by wearing no + // mark and taking no press. + run := mustRailRow(t, a, "Running ") + if strings.Contains(run, glyphOpen) || strings.Contains(run, glyphShut) { + t.Fatalf("the running heading wears a fold it does not have: %q", run) + } + railClick(t, a, x, railHeadY(t, a, railRunning)) + if _, ok := railRowFor(a, a.viewHeight(), "Ship the port"); !ok { + t.Fatalf("a press folded the running work:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) + } + // AND THE KEYBOARD REACHES THE SAME FOLD: enter on a heading. + drive(t, a, altT()) + a.railWhere = railSpot{group: int(railDone) + 1} + drive(t, a, key("enter")) + if _, ok := railRowFor(a, a.viewHeight(), "Read the law"); !ok { + t.Fatalf("enter on the heading did not open the group:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) + } + if a.roomOpen() { + t.Fatal("enter on a heading opened a room") + } +} + +// THE HEADING'S HOVER GROUND IS ITS PRESS. The pointer on a folded heading +// lights it and names what a press does; the pointer on the running heading +// lights nothing, because a press there does nothing. +func TestAHeadingLightsOnlyWhereItFolds(t *testing.T) { + a, _, _ := taskApp(t) + railRun(a) + x := a.bodyWidth() + ansi.StringWidth(railSeam) + 2 + a.setHover(x, railHeadY(t, a, railDone)) + if a.hot.kind != hoverRailGroup || railGroup(a.hot.index) != railDone { + t.Fatalf("the pointer on the Done heading resolved to %+v", a.hot) + } + if got := a.sideHoverWords(); !strings.Contains(got, "Show what is done") { + t.Fatalf("the hint over the folded heading reads %q", got) + } + a.setHover(x, railHeadY(t, a, railRunning)) + if a.hot.kind == hoverRailGroup { + t.Fatalf("the running heading lit as a fold: %+v", a.hot) + } +} + +// A ROW IS ONE LINE WHATEVER THE WORK IS DOING. The call a running task is in +// used to hang under its row; it is the hint line's now, with the whole name. +func TestARunningRowIsOneLineAndItsCallIsOnTheHint(t *testing.T) { + a, _, advance := taskApp(t) + railRun(a) + a.tasks[3].tool, a.tasks[3].toolBegan = "bash go test ./...", a.now().Add(-24*time.Second) + advance(0) + rows := railText(a, 14) + for _, row := range rows { + if strings.Contains(row, "go test") { + t.Fatalf("the call is drawn on the column:\n%s", strings.Join(rows, "\n")) + } + } + if hint := railHint(a, 3); !strings.Contains(hint, "Write the tree") || !strings.Contains(hint, "go test") { + t.Fatalf("the hint over the running row reads %q", hint) + } +} + +// THE COLUMN WIDENS ON DEMAND. alt+w takes the wide tier while the column +// holds the keyboard, the column is charged against the conversation, the +// footer's hint is a button that does the same, and /new gives it back. +func TestTheWidenChordAndHintToggleTheWideTier(t *testing.T) { + a, _, _ := taskApp(t) + railRun(a) + cols := sideColsFor(a.width) + drive(t, a, altT()) + if !strings.Contains(strings.Join(railText(a, 14), "\n"), railWideHint) { + t.Fatalf("the held column did not offer the wide tier:\n%s", strings.Join(railText(a, 14), "\n")) + } + drive(t, a, key(railWidenChord)) + if !a.railWide || a.railWidth() != cols+railWideGain { + t.Fatalf("%s did not widen the column: wide=%v width=%d", railWidenChord, a.railWide, a.railWidth()) + } + if a.bodyWidth() != a.width-cols-railWideGain { + t.Fatalf("the wide column is not charged against the conversation: body=%d", a.bodyWidth()) + } + drive(t, a, key(railWidenChord)) + if a.railWide || a.railWidth() != cols { + t.Fatalf("%s did not give the columns back: wide=%v width=%d", railWidenChord, a.railWide, a.railWidth()) + } + for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { + if line, ok := a.railLineAt(y); ok && line.hint { + drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) + break + } + } + if !a.railWide { + t.Fatalf("a press on the hint did not widen the column") + } + a.dropTasks() + if a.railWide { + t.Fatal("/new kept the wide column") + } +} + +// THE FULLSCREEN ROSTER IS THE SAME COLUMN. Under a hundred columns there is +// no column to lend, so alt+t draws it over the body: the same header, the +// same groups and the same folds, at the width the frame has. +func TestTheFullscreenRosterDrawsTheSameGroups(t *testing.T) { + a, _, _ := taskApp(t) + a.width = 80 + a.touch() + railRun(a) + drive(t, a, altT()) + if !a.railFull() { + t.Fatal("alt+t did not raise the roster over the body") + } + rows := railText(a, a.viewHeight()) + body := strings.Join(rows, "\n") + for _, want := range []string{sideTasksWord + " 5", "Running 2", "Ship the port", "Done 1"} { + if !strings.Contains(body, want) { + t.Fatalf("the fullscreen roster is missing %q:\n%s", want, body) + } + } + for i, row := range rows { + if strings.HasPrefix(row, railSeam) { + t.Fatalf("fullscreen row %d opens with the rail's seam:\n%q", i, row) + } + if w := ansi.StringWidth(row); w > a.width { + t.Fatalf("row %d is %d cells wide on an %d-column frame:\n%q", i, w, a.width, row) + } + } + a.railWhere = railSpot{group: int(railDone) + 1} + drive(t, a, key("enter")) + if !strings.Contains(strings.Join(railText(a, a.viewHeight()), "\n"), "Read the law") { + t.Fatalf("enter on the heading did not open the group over the body:\n%s", + strings.Join(railText(a, a.viewHeight()), "\n")) + } +} diff --git a/internal/tui3/railheader_test.go b/internal/tui3/railheader_test.go index 47ebfbb722..3291155b6a 100644 --- a/internal/tui3/railheader_test.go +++ b/internal/tui3/railheader_test.go @@ -8,6 +8,10 @@ import ( "github.com/Agent-Field/codeaf/internal/session" ) +// THE HEADER HOLDS STILL AND THE TASK ACTION FOLLOWS THE LIST. The column's +// first row is its header, with its key at the right, whatever the column +// holds, however far it is scrolled and however short the frame; the `+ /task` +// action is the row after the last task. func TestSidebarKeepsHideAboveNewTasksAndTaskActionBelow(t *testing.T) { for _, width := range []int{100, 120, 180} { t.Run(fmt.Sprint(width), func(t *testing.T) { @@ -18,14 +22,17 @@ func TestSidebarKeepsHideAboveNewTasksAndTaskActionBelow(t *testing.T) { a.taskUpdate(update(uint64(count), fmt.Sprintf("Task number %d", count), session.TaskRunning, session.TaskNotice{})) } rows, _ := a.railView(20) - if len(rows) != 20 || !rows[0].stow || !strings.Contains(plain(rows[0].text), railStowHint) { - t.Fatalf("hide moved after %d tasks: %+v", count, rows) + if len(rows) != 20 || rows[0].side == nil || rows[0].side.key != sideHeadKey || + !strings.HasSuffix(strings.TrimRight(plain(rows[0].text), " "), sideHideKey) { + t.Fatalf("the header moved after %d tasks: %+v", count, rows) } entries, last, action := a.railEntries(), 0, -1 var ids []uint64 for i, row := range rows { - if row.entry >= 0 && row.head { - ids = append(ids, entries[row.entry].node.id) + if row.entry >= 0 { + if e := entries[row.entry]; !e.head { + ids = append(ids, e.node.id) + } last = i } if row.door == marginTaskType { @@ -35,25 +42,21 @@ func TestSidebarKeepsHideAboveNewTasksAndTaskActionBelow(t *testing.T) { if len(ids) != count || action != last+1 { t.Fatalf("tasks or action are misplaced: ids=%v last=%d action=%d", ids, last, action) } + // NEWEST FIRST, which is what a person arriving at the column + // wants to read first. for i, id := range ids { - if id != uint64(i+1) { - t.Fatalf("tasks are not in creation order: %v", ids) + if id != uint64(count-i) { + t.Fatalf("tasks are not newest first: %v", ids) } } } - a.taskUpdate(update(1, "Task number 1", session.TaskDone, session.TaskNotice{})) - for i, entry := range a.railEntries() { - if entry.node.id != uint64(i+1) { - t.Fatal("completion reordered the task list") - } - } for id := uint64(4); id <= 30; id++ { a.taskUpdate(update(id, fmt.Sprintf("Task number %d", id), session.TaskRunning, session.TaskNotice{})) } a.railTop = 20 for _, height := range []int{1, 4, 8, 20} { rows, _ := a.railView(height) - if len(rows) != height || !rows[0].stow || rows[0].fade != 0 { + if len(rows) != height || rows[0].side == nil || rows[0].side.key != sideHeadKey || rows[0].fade != 0 { t.Fatalf("scrolling or resizing displaced the header at height %d: %+v", height, rows) } } diff --git a/internal/tui3/railmain_test.go b/internal/tui3/railmain_test.go index d170f3a17c..59723b8e8a 100644 --- a/internal/tui3/railmain_test.go +++ b/internal/tui3/railmain_test.go @@ -22,7 +22,7 @@ func TestRailMainReturnsDirectlyFromDeepTask(t *testing.T) { a.openRailRoom(a.tasks[19]) a.railTop = 100 rows := a.railRows(a.viewHeight()) - if len(rows) < 2 || !strings.Contains(plain(rows[0]), railStowHint) || !strings.Contains(plain(rows[1]), railMainWord) { + if len(rows) < 2 || !strings.Contains(plain(rows[0]), sideTasksWord) || !strings.Contains(plain(rows[1]), railMainWord) { t.Fatalf("return door is not pinned: %v", rows) } x, y := a.bodyWidth()+ansi.StringWidth(railSeam)+6, a.bodyTop()+1 diff --git a/internal/tui3/railsize_test.go b/internal/tui3/railsize_test.go index 0755c91d51..c1c1162be3 100644 --- a/internal/tui3/railsize_test.go +++ b/internal/tui3/railsize_test.go @@ -16,12 +16,12 @@ func TestRailSeamClickTogglesTheWideTier(t *testing.T) { drive(t, a, tea.MouseClickMsg{X: a.railLeft(), Y: y, Button: tea.MouseLeft}) drive(t, a, tea.MouseReleaseMsg{X: a.railLeft(), Y: y, Button: tea.MouseLeft}) - if !a.railWide || a.railWidth() != railWideCols { + if !a.railWide || a.railWidth() != sideColsFor(a.width)+railWideGain { t.Fatalf("seam press did not widen the rail: wide=%v width=%d", a.railWide, a.railWidth()) } drive(t, a, tea.MouseClickMsg{X: a.railLeft(), Y: y, Button: tea.MouseLeft}) drive(t, a, tea.MouseReleaseMsg{X: a.railLeft(), Y: y, Button: tea.MouseLeft}) - if a.railWide || a.railWidth() != railCols { + if a.railWide || a.railWidth() != sideColsFor(a.width) { t.Fatalf("second seam press did not narrow the rail: wide=%v width=%d", a.railWide, a.railWidth()) } } diff --git a/internal/tui3/railtree_test.go b/internal/tui3/railtree_test.go deleted file mode 100644 index cdd1a5cc08..0000000000 --- a/internal/tui3/railtree_test.go +++ /dev/null @@ -1,548 +0,0 @@ -package tui3 - -import ( - "strings" - "testing" - "time" - - tea "charm.land/bubbletea/v2" - "github.com/charmbracelet/x/ansi" - - "github.com/Agent-Field/codeaf/internal/session" - "github.com/Agent-Field/codeaf/internal/tui2/tokens" -) - -// ── THE ROSTER'S FOREST ───────────────────────────────────────────────────── -// -// The column used to file every node under one of five state headings, which -// scattered one adaptive run across four sections of itself. It draws families -// now (task.go's [app.railEntries]), and these are the whole of that claim: the -// shape, the order, the fold and its default, the two hands that reach it. - -// railKinship hands a node to a parent, in the alphabet the seam speaks -// (taskstrip.go's [taskNode.ParentID]). -func railKinship(a *app, parent uint64, kids ...uint64) { - for _, id := range kids { - a.tasks[id].parent = itoa(int(parent)) - } -} - -// railRun plants one adaptive run: a root the person started, and the tree its -// planner spawned under it. -// -// THE NODES ARRIVE IN ID ORDER AND THE COLUMN DOES NOT DRAW THEM IN IT. A -// family's members keep their creation order: -// -// 1 Ship the port running -// ├─ 2 Read the law done -// ├─ 3 Write the tree running -// │ └─ 4 Cut goldens queued -// └─ 5 Wire the seam queued -func railRun(a *app) { - a.taskUpdate(update(1, "Ship the port", session.TaskRunning, session.TaskNotice{})) - a.taskUpdate(update(2, "Read the law", session.TaskDone, session.TaskNotice{})) - a.taskUpdate(update(3, "Write the tree", session.TaskRunning, session.TaskNotice{})) - a.taskUpdate(update(4, "Cut the goldens", session.TaskQueued, session.TaskNotice{})) - a.taskUpdate(update(5, "Wire the seam", session.TaskQueued, session.TaskNotice{})) - railKinship(a, 1, 2, 3, 5) - railKinship(a, 3, 4) - // The spinner is on the frame clock (tokens.Spinner), so a golden has to say - // which frame it was taken on. - a.paints = 0 -} - -// railText is the roster as a reader sees it, row by row. -func railText(a *app, height int) []string { - rows := a.railRows(height) - out := make([]string, len(rows)) - for i, row := range rows { - out[i] = plain(row) - } - return out -} - -// mustRailRow is [railRowFor] over the whole visible column, for the tests that -// would be lying if the row were missing. -func mustRailRow(t *testing.T, a *app, title string) string { - t.Helper() - row, ok := railRowFor(a, a.viewHeight(), title) - if !ok { - t.Fatalf("the column has no row for %q:\n%s", title, - strings.Join(railText(a, a.viewHeight()), "\n")) - } - return row -} - -// railRowFor is the drawn row a node's title is on, and whether there is one. -func railRowFor(a *app, height int, title string) (string, bool) { - for _, row := range railText(a, height) { - if strings.Contains(row, title) { - return row, true - } - } - return "", false -} - -// railFocusOn walks the roster's cursor onto a node, however far down it is. -func railFocusOn(t *testing.T, a *app, id uint64) { - t.Helper() - for i := 0; i < 40 && a.railWhere.id != id; i++ { - a.railMove(1) - } - if a.railWhere.id != id { - t.Fatalf("the cursor never reached node %d", id) - } -} - -// A FAMILY IS DRAWN WHOLE AND THE CONNECTORS ARE IN THE ROW. One row per node, -// children indented under the thing that spawned them, whatever state each of -// them is in — the settled rows are what make the unsettled ones legible. -// -// It is a byte comparison on purpose: a tree is alignment, and a test that only -// asked "does it contain ├─" would pass on a tree whose second level had -// drifted a cell. -func TestAFamilyIsDrawnWholeUnderItsRoot(t *testing.T) { - a, _, _ := taskApp(t) - railRun(a) - spin := tokens.Spinner(0) - want := []string{ - "│ " + railGripOpenGlyph + " " + railStowHint, - "│ ", - "│ " + spin + " Ship the port #1", - "│ ├─ " + glyphDone + " Read the law #2", - "│ ├─ " + spin + " Write the tree #3", - "│ │ └─ " + glyphQueued + " Cut the goldens #4", - "│ └─ " + glyphQueued + " Wire the seam #5", - } - got := railText(a, 12) - if len(got) < len(want) { - t.Fatalf("the family drew %d rows:\n%s", len(got), strings.Join(got, "\n")) - } - for i := range want { - if got[i] != want[i] { - t.Fatalf("row %d is\n\t%q\nwant\n\t%q\nwhole column:\n%s", i, got[i], want[i], strings.Join(got, "\n")) - } - } - // EVERY ROW IS INSIDE THE COLUMN, connectors and all. - for i, row := range got { - if w := ansi.StringWidth(row); w > railCols { - t.Fatalf("row %d is %d cells wide, want at most %d:\n%q", i, w, railCols, row) - } - } - // EVERY ROW ON THIS COLUMN WEARS ITS STATE AND NOTHING ELSE: the column of - // glyphs is read downward, and the identity ◆ is not spent on any row of it — - // tree or flat (task.go's [app.railLead]). - for i, row := range got { - if strings.Contains(row, plain(a.taskMark(identFor(2)))) { - t.Fatalf("row %d carries the identity cell as well as the state:\n%q", i, row) - } - } -} - -// State changes must not reorder families somebody is reading. -func TestAFamilyKeepsItsCreationOrderAcrossStates(t *testing.T) { - a, _, _ := taskApp(t) - // A settled family, then a running one, then a family with a conflicted branch in - // it — all remain in the order they were created. - a.taskUpdate(update(1, "Cut the trailer", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) - a.taskUpdate(update(2, "Trim silence", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) - a.taskUpdate(update(3, "Ship the port", session.TaskRunning, session.TaskNotice{})) - a.taskUpdate(update(4, "Write the tree", session.TaskRunning, session.TaskNotice{})) - a.taskUpdate(update(5, "Port the parser", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) - a.taskUpdate(update(6, "Render titles", session.TaskFailed, session.TaskNotice{ - Merge: mergeWordConflicted, Branch: "task/render", - })) - railKinship(a, 1, 2) - railKinship(a, 3, 4) - railKinship(a, 5, 6) - // Every family open, so the order can be read off the rows themselves. - for _, id := range []uint64{1, 3, 5} { - a.railSetOpen(a.tasks[id], true) - } - - rail := strings.Join(railText(a, 20), "\n") - at := -1 - for _, want := range []string{"Cut the trailer", "Trim silence", "Ship the port", "Write the tree", - "Port the parser", "Render titles"} { - found := strings.Index(rail, want) - if found < 0 { - t.Fatalf("the roster has no %q row:\n%s", want, rail) - } - if found < at { - t.Fatalf("%q is out of order:\n%s", want, rail) - } - at = found - } -} - -// THE FOLD HAS A DEFAULT WORTH HAVING AND THE PERSON MAY OVERRULE IT. A family -// with anything live in it opens; a family that has entirely settled is one row -// with a count on it; and whatever a person says about either one sticks. -func TestAFamilyOpensWhileItIsLiveAndFoldsOnceItSettles(t *testing.T) { - a, _, _ := taskApp(t) - railRun(a) - if _, ok := railRowFor(a, 12, "Cut the goldens"); !ok { - t.Fatalf("a live family came up folded:\n%s", strings.Join(railText(a, 12), "\n")) - } - - // The whole run lands. Nothing under it is going anywhere, so it stands as one - // row — a hundred and forty-eight settled nodes are a fact, not a hundred and - // forty-eight rows. - for _, id := range []uint64{1, 2, 3, 4, 5} { - a.taskUpdate(update(id, a.tasks[id].title, session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) - } - rows := railText(a, 12) - if _, ok := railRowFor(a, 12, "Cut the goldens"); ok { - t.Fatalf("a settled family stayed open:\n%s", strings.Join(rows, "\n")) - } - if _, ok := railRowFor(a, 12, "Ship the port"); !ok { - t.Fatalf("the folded family lost its own row:\n%s", strings.Join(rows, "\n")) - } - - // AND THE PERSON'S ANSWER STICKS. Opened by hand, it stays open through the - // next update — the default is the design and the map is the correction of it. - a.railSetOpen(a.tasks[1], true) - a.taskUpdate(update(2, "Read the law", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) - if _, ok := railRowFor(a, 12, "Read the law"); !ok { - t.Fatalf("the fold a person opened closed itself again:\n%s", strings.Join(railText(a, 12), "\n")) - } - a.railSetOpen(a.tasks[1], false) - if _, ok := railRowFor(a, 12, "Read the law"); ok { - t.Fatalf("the fold a person closed stayed open:\n%s", strings.Join(railText(a, 12), "\n")) - } -} - -// A FOLDED FAMILY WEARS THE WORST THING UNDER IT AND SAYS HOW MUCH IT IS -// STANDING FOR. The row is the whole subtree now, so its one cell is the -// subtree's news and its trailing slot is the count rather than the handle. -func TestAFoldedFamilyWearsItsWorstGlyphAndCountsWhatItHides(t *testing.T) { - a, _, _ := taskApp(t) - railRun(a) - // Everything settles except one node, which did not come off. - for _, id := range []uint64{1, 2, 3, 5} { - a.taskUpdate(update(id, a.tasks[id].title, session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) - } - a.taskUpdate(update(4, "Cut the goldens", session.TaskFailed, session.TaskNotice{ - Report: "the tests did not build", - })) - row, ok := railRowFor(a, 12, "Ship the port") - if !ok { - t.Fatalf("the folded family has no row:\n%s", strings.Join(railText(a, 12), "\n")) - } - // FOUR NODES HIDDEN, and the failure is what the one cell says — the root - // itself merged clean. - if !strings.Contains(row, glyphShut+" +4") { - t.Fatalf("the folded row does not count what it hides:\n%q", row) - } - if !strings.HasPrefix(row, "│ "+glyphBad+" ") { - t.Fatalf("the folded row does not wear the worst glyph under it:\n%q", row) - } - if strings.Contains(row, "#1") { - t.Fatalf("the folded row spent its trailing slot twice:\n%q", row) - } - // AND IT IS ONE ROW. A folded family that still said what it was doing would - // be a fold that hid nothing. - if rows := railText(a, 12); strings.Contains(strings.Join(rows[:1], ""), mergeWordMerged) { - t.Fatalf("the folded row kept its under-block:\n%s", strings.Join(rows, "\n")) - } -} - -// →← ARE THE TREE'S OWN GRAMMAR: → opens a folded family and then steps into it, -// ← folds an open one and walks up out of a leaf. -func TestTheTreeGrammarOpensStepsInFoldsAndWalksUp(t *testing.T) { - a, _, _ := roomApp(t) - railRun(a) - drive(t, a, altT()) - railFocusOn(t, a, 1) - - // ← on an open root folds it and leaves the cursor where the family now is. - drive(t, a, key("left")) - if _, ok := railRowFor(a, 12, "Read the law"); ok { - t.Fatalf("← did not fold the family:\n%s", strings.Join(railText(a, 12), "\n")) - } - if a.railWhere.id != 1 { - t.Fatalf("← left the cursor on %+v, want the root it folded", a.railWhere) - } - // → on a folded root opens it, and → again steps onto the first child. - drive(t, a, key("right")) - if _, ok := railRowFor(a, 12, "Read the law"); !ok { - t.Fatalf("→ did not open the family:\n%s", strings.Join(railText(a, 12), "\n")) - } - if a.railWhere.id != 1 { - t.Fatalf("→ opened the family and moved the cursor to %+v", a.railWhere) - } - drive(t, a, key("right")) - if a.railWhere.id != 2 { - t.Fatalf("→ stepped to %+v, want the first child created", a.railWhere) - } - - // ← FROM A LEAF JUMPS TO THE PARENT ROW. A cursor left pointing at nothing is - // a position that means nothing. - railFocusOn(t, a, 4) - drive(t, a, key("left")) - if a.railWhere.id != 3 { - t.Fatalf("← from the grandchild landed on %+v, want its parent", a.railWhere) - } - // And enter is the one activating key: it opens that node's room. - drive(t, a, key("enter")) - if !a.roomOpen() || a.room.id != 3 { - t.Fatalf("enter did not open the focused node's room: open=%v", a.roomOpen()) - } -} - -// THE DISCLOSURE IS THE FOLD AND THE REST OF THE ROW IS THE DOOR. One row, two -// targets, and which one a press meant is a question about the column it landed -// in AND about what the frame actually drew there (room.go's [app.railPress]). -func TestPressingTheGlyphCellFoldsAndPressingTheTitleOpensTheRoom(t *testing.T) { - a, _, _ := roomApp(t) - railRun(a) - rootY := -1 - for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - if node := a.railNodeAt(y); node != nil && node.id == 1 { - rootY = y - break - } - } - if rootY < 0 { - t.Fatalf("the family's root is not on screen:\n%s", strings.Join(railText(a, a.viewHeight()), "\n")) - } - glyph := a.bodyWidth() + ansi.StringWidth(railSeam) - - // THE POINTER IS ON THE ROW FIRST, and that is not fixture ceremony: it is the - // only state in which that cell is a disclosure at all. At rest it draws the - // root's STATE, and a state is not a control — which is what - // [TestTheStateCellOpensTheTaskWhenNoDisclosureIsDrawnOnIt] holds the other - // end of. - a.setHover(glyph, rootY) - if !strings.Contains(mustRailRow(t, a, "Ship the port"), glyphOpen) { - t.Fatalf("the cell about to be pressed is not drawn as a disclosure:\n%q", - mustRailRow(t, a, "Ship the port")) - } - - // The disclosure folds the family and opens no room. - drive(t, a, tea.MouseClickMsg{X: glyph, Y: rootY, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: glyph, Y: rootY, Button: tea.MouseLeft}) - if a.roomOpen() { - t.Fatal("a press on the disclosure cell walked into the room behind it") - } - if _, ok := railRowFor(a, a.viewHeight(), "Read the law"); ok { - t.Fatalf("a press on the disclosure cell did not fold the family:\n%s", - strings.Join(railText(a, a.viewHeight()), "\n")) - } - // THE ▸ +N EXPANDS IN PLACE, which is the other half of the same affordance. - line, ok := a.railLineAt(rootY) - if !ok || !line.badge.pressable() { - t.Fatalf("the folded row recorded no badge to press: %+v", line) - } - drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + ansi.StringWidth(railSeam) + line.badge.from, - Y: rootY, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + ansi.StringWidth(railSeam) + line.badge.from, - Y: rootY, Button: tea.MouseLeft}) - if _, ok := railRowFor(a, a.viewHeight(), "Read the law"); !ok { - t.Fatalf("a press on the count did not expand the family:\n%s", - strings.Join(railText(a, a.viewHeight()), "\n")) - } - if a.roomOpen() { - t.Fatal("a press on the count opened a room as well") - } - - // And anywhere else on the row is that node's door. - drive(t, a, tea.MouseClickMsg{X: glyph + 6, Y: rootY, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: glyph + 6, Y: rootY, Button: tea.MouseLeft}) - if !a.roomOpen() || a.room.id != 1 { - t.Fatalf("a press on the title did not open the room: open=%v", a.roomOpen()) - } -} - -// THE DISCLOSURE IS THE POINTER'S. Nothing on the column says "fold me" at rest -// — a triangle on every root would be a column of widgets — and the moment the -// pointer is over a family root, its state cell becomes the triangle. -func TestTheDisclosureIsRevealedUnderThePointerAndOnlyOnRoots(t *testing.T) { - a, _, _ := taskApp(t) - railRun(a) - rows := strings.Join(railText(a, 12), "\n") - if strings.Contains(rows, glyphOpen) || strings.Contains(rows, glyphShut) { - t.Fatalf("the column drew a disclosure nobody was pointing at:\n%s", rows) - } - - rootY, leafY := -1, -1 - for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - switch node := a.railNodeAt(y); { - case node == nil: - case node.id == 1: - rootY = y - case node.id == 2: - leafY = y - } - } - if rootY < 0 || leafY < 0 { - t.Fatalf("the family is not on screen: root=%d leaf=%d", rootY, leafY) - } - a.setHover(a.bodyWidth()+4, rootY) - if a.hot.kind != hoverRail || a.hot.id != 1 { - t.Fatalf("the pointer over the roster resolved to %+v", a.hot) - } - row, _ := railRowFor(a, a.viewHeight(), "Ship the port") - if !strings.Contains(row, glyphOpen) { - t.Fatalf("the root under the pointer revealed no disclosure:\n%q", row) - } - // A LEAF HAS NOTHING TO DISCLOSE, and it still takes the hover step, because - // every row of this column is a door. - a.setHover(a.bodyWidth()+4, leafY) - row, _ = railRowFor(a, a.viewHeight(), "Read the law") - if strings.Contains(row, glyphOpen) || strings.Contains(row, glyphShut) { - t.Fatalf("a leaf offered a fold it does not have:\n%q", row) - } - background := "\x1b[48;5;" + itoa(int(hueCursor.idx)) + "m" - if !strings.Contains(a.railRows(a.viewHeight())[leafY-a.bodyTop()], background) { - t.Fatalf("the row under the pointer took no hover step:\n%q", row) - } - // A FOLDED ROOT SHOWS ITS COUNT AT REST AND ITS TRIANGLE UNDER THE POINTER. - a.railSetOpen(a.tasks[1], false) - a.setHover(a.bodyWidth()+4, rootY) - row, _ = railRowFor(a, a.viewHeight(), "Ship the port") - if !strings.Contains(row, glyphShut) { - t.Fatalf("the folded root under the pointer did not point at what it hides:\n%q", row) - } -} - -// THE UNDER-BLOCK HANGS FROM THE STEM IT BELONGS TO. A node's telemetry sits -// between that node's row and its next sibling's, so a block indented with plain -// spaces would put a gap in the line the eye is following down the family. -func TestUnderRowsCarryTheStemTheyHangFrom(t *testing.T) { - a, _, advance := taskApp(t) - railRun(a) - a.tasks[3].tool, a.tasks[3].toolBegan = "bash go test ./...", a.now().Add(-24*time.Second) - advance(0) - - rows := railText(a, 14) - at := -1 - for i, row := range rows { - if strings.Contains(row, "Write the tree") { - at = i - } - } - if at < 0 || at+1 >= len(rows) { - t.Fatalf("the running child has no under-row:\n%s", strings.Join(rows, "\n")) - } - under := rows[at+1] - if !strings.Contains(under, "go test") { - t.Fatalf("the under-row is not the call the node is in:\n%q", under) - } - // The row hangs under "├─ ", so the stem continues where the elbow was, and - // the node's own stem carries on down to its child. - if want := "│ │ │ "; !strings.HasPrefix(under, want) { - t.Fatalf("the under-row opens %q, want the stems %q:\n%s", under, want, strings.Join(rows, "\n")) - } - // A SETTLED NODE IN A TREE IS ONE LINE: the merge word under every landed row - // would be a column of history inside a shape somebody is reading for shape. - for _, row := range rows { - if strings.Contains(row, mergeWordMerged) { - t.Fatalf("a settled row in a family kept its under-block:\n%s", strings.Join(rows, "\n")) - } - } -} - -// THE COLUMN WIDENS ON DEMAND AND OFFERS IT ONLY WHEN IT WOULD HELP. The hint is -// earned by a title the indent cut, it disappears the moment the column is wide, -// and it is pressable because a hint only one hand can use is half a hint. -func TestTheWidenHintIsEarnedByTheIndentAndTogglesTheWideTier(t *testing.T) { - a, _, _ := taskApp(t) - railRun(a) - // Nothing is cut yet: the names in this run fit their indent. - if strings.Contains(strings.Join(railText(a, 14), "\n"), railWideHint) { - t.Fatalf("the column offered the wide tier with nothing to gain:\n%s", - strings.Join(railText(a, 14), "\n")) - } - - // A deep node with a long name is a title the indent cuts. - a.taskUpdate(update(6, "Cut the goldens", session.TaskRunning, session.TaskNotice{})) - railKinship(a, 4, 6) - // The roster draws the NAME (taskident.go cuts it), so the long one is written - // onto the node rather than sent through the notice. - a.tasks[6].title = "Cut the goldens for the tree" - rail := strings.Join(railText(a, 14), "\n") - if !strings.Contains(rail, railWideHint) { - t.Fatalf("a title cut by its own indent did not offer the wide tier:\n%s", rail) - } - - // alt+w takes it, and the column is charged against the conversation like the - // other two tiers. It is a chord and no longer the bare letter `w`, because a - // bare letter beside a message box is a letter out of somebody's sentence - // (chordfocus.go). - drive(t, a, altT(), key(railWidenChord)) - if !a.railWide || a.railWidth() != railWideCols { - t.Fatalf("%s did not widen the column: wide=%v width=%d", railWidenChord, a.railWide, a.railWidth()) - } - if a.bodyWidth() != a.width-railWideCols { - t.Fatalf("the wide column is not charged against the conversation: body=%d", a.bodyWidth()) - } - wide := strings.Join(railText(a, 14), "\n") - if !strings.Contains(wide, "Cut the goldens for the tree") { - t.Fatalf("the wide column still cut the name it was widened for:\n%s", wide) - } - if strings.Contains(wide, railWideHint) { - t.Fatalf("the wide column went on offering to widen:\n%s", wide) - } - drive(t, a, key(railWidenChord)) - if a.railWide || a.railWidth() != railCols { - t.Fatalf("%s did not give the columns back: wide=%v width=%d", railWidenChord, a.railWide, a.railWidth()) - } - - // AND THE HINT IS A BUTTON. A press on that line widens the column. - for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - if line, ok := a.railLineAt(y); ok && line.hint { - drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + 4, Y: y, Button: tea.MouseLeft}) - break - } - } - if !a.railWide { - t.Fatalf("a press on the hint did not widen the column") - } - // AND IT GOES WITH THE SESSION. A column widened for a tree that no longer - // exists is a charge on a conversation that never asked for it. - a.dropTasks() - if a.railWide { - t.Fatal("/new kept the wide column") - } -} - -// THE FULLSCREEN ROSTER IS THE SAME FOREST. Under a hundred columns there is no -// column to lend, so ctrl+t draws the whole thing over the body — the same -// families, the same folds, at the width the frame actually has. -func TestTheFullscreenRosterDrawsTheSameTree(t *testing.T) { - a, _, _ := taskApp(t) - a.width = 80 - a.touch() - railRun(a) - drive(t, a, altT()) - if !a.railFull() { - t.Fatal("ctrl+t did not raise the roster over the body") - } - rows := railText(a, a.viewHeight()) - body := strings.Join(rows, "\n") - for _, want := range []string{"Ship the port", "├─ ", "└─ ", "Cut the goldens"} { - if !strings.Contains(body, want) { - t.Fatalf("the fullscreen roster is missing %q:\n%s", want, body) - } - } - // THE SEAM IS A SEAM AND NOT A BORDER, so it is not drawn where there is - // nothing on the other side of it (task.go's [app.railRows]). - for i, row := range rows { - if strings.HasPrefix(row, railSeam) { - t.Fatalf("fullscreen row %d opens with the rail's seam:\n%q", i, row) - } - } - for i, row := range rows { - if w := ansi.StringWidth(row); w > a.width { - t.Fatalf("row %d is %d cells wide on an %d-column frame:\n%q", i, w, a.width, row) - } - } - // The fold is the same fold, from the same key. - drive(t, a, key("left")) - if strings.Contains(strings.Join(railText(a, a.viewHeight()), "\n"), "Cut the goldens") { - t.Fatalf("← did not fold the family over the body:\n%s", - strings.Join(railText(a, a.viewHeight()), "\n")) - } -} diff --git a/internal/tui3/railview_test.go b/internal/tui3/railview_test.go index 8ccc2017dc..e68e3ff71a 100644 --- a/internal/tui3/railview_test.go +++ b/internal/tui3/railview_test.go @@ -5,7 +5,6 @@ import ( "testing" tea "charm.land/bubbletea/v2" - "github.com/charmbracelet/x/ansi" "github.com/Agent-Field/codeaf/internal/session" "github.com/Agent-Field/codeaf/internal/standing" @@ -21,8 +20,8 @@ import ( // // Three laws come out of that, and these are them: // -// - A ROW THAT HAS LANDED IS ONE LINE, and what it had to say is tucked behind -// the fold the column already had rather than thrown away. +// - A ROW THAT HAS LANDED IS ONE LINE, and what it had to say is on the hint +// line when the pointer is on it rather than thrown away. // - THE SECTIONS UNDER THE ROSTER ARE RESERVED, not stacked. A list that can // grow without limit starves anything below it, every time. // - THE WHEEL MOVES THE LIST UNDER THE POINTER, which is the oldest thing a @@ -64,11 +63,12 @@ func railBuild(i int) string { } // railLanded fills a session with landed jobs, which is the shape the column was -// drowning in. +// drowning in, with the finished group opened so that every one is drawn. func railLanded(a *app, n int) { for i := 1; i <= n; i++ { a.taskUpdate(railLandedTask(uint64(i), railBuild(i))) } + railOpenAll(a) } // ── 1. a landed row is one line ───────────────────────────────────────────── @@ -87,22 +87,21 @@ func TestALandedRowSpendsOneLineOnTheColumn(t *testing.T) { } } // AND THE HISTORY UNDER THEM IS NOT DRAWN. The log path is what a settled job - // used to spend its second row on; it is behind the fold now (see below), and + // used to spend its second row on; it is the hint line's now (see below), and // a column that still drew it would not have fitted the thirteen rows above. if strings.Contains(text, railReportOf(1)) { t.Fatalf("a landed row still spends a line on its own history:\n%s", text) } } -// WORK THAT IS STILL GOING IS UNTOUCHED, which is what says the rule above is -// about what is OVER and not about the column having gone quiet. The fold is -// offered on a row that has landed and on no other: a person cannot tuck away -// the one thing they opened the column to watch. +// WORK THAT IS STILL GOING IS ONE LINE TOO, and the row is its door: the +// column draws one row for one running node under its heading, and the hint +// line over it names it whole. // // It used to be said about a running background JOB, whose second line was the // path its output was going to. That line is gone from this column with the jobs -// themselves — a job's log is on the job's own page now (jobpage.go) — so what -// is left to pin is the rule the job row was only ever an example of. +// themselves (a job's log is on the job's own page now, jobpage.go), so what is +// left to pin is the rule the job row was only ever an example of. func TestARunningRowKeepsWhatItIsDoing(t *testing.T) { a, _, _ := taskApp(t) a.taskUpdate(update(4, "Collect the sources", session.TaskRunning, session.TaskNotice{ @@ -110,96 +109,49 @@ func TestARunningRowKeepsWhatItIsDoing(t *testing.T) { })) entries := a.railEntries() - if len(entries) != 1 { - t.Fatalf("the column drew %d rows for one running node", len(entries)) + if len(entries) != 2 || !entries[0].head || entries[1].node == nil || entries[1].node.id != 4 { + t.Fatalf("the column drew %d rows for one running node: %+v", len(entries), entries) } - if a.railTucks(entries[0]) { - t.Fatal("a row that is still going offers the fold that is meant for work that is over") + if hint := railHint(a, 4); !strings.Contains(hint, "Collect the sources") { + t.Fatalf("the hint over the running row reads %q", hint) } } -// AND A ROW THAT HAS NOT STARTED KEEPS ITS SENTENCE TOO. `waits:` is the only -// place this surface says what is in the way of a flat node, and queued is not -// settled. +// AND A ROW THAT HAS NOT STARTED KEEPS ITS SENTENCE. `waits:` is the only +// place this surface says what is in the way of a flat node, and it is on the +// hint line over the row. func TestAQueuedRowStillSaysWhatItWaitsOn(t *testing.T) { a, _, _ := taskApp(t) a.taskUpdate(update(1, "Collect sources", session.TaskRunning, session.TaskNotice{})) a.taskUpdate(update(2, "Mix audio", session.TaskQueued, session.TaskNotice{DependsOn: []uint64{1}})) - if text := strings.Join(railText(a, 20), "\n"); !strings.Contains(text, "waits: Collect sources") { - t.Fatalf("a queued row lost the sentence saying what is in its way:\n%s", text) + if hint := railHint(a, 2); !strings.Contains(hint, "waits: Collect sources") { + t.Fatalf("a queued row lost the sentence saying what is in its way: %q", hint) } } -// NOTHING IS THROWN AWAY — IT IS TUCKED. → opens a landed row's own block, ← -// puts it back, and both are the keys a family already folds on: one fold -// vocabulary down the whole column. -func TestALandedRowGivesItsBlockBackWhenItIsOpened(t *testing.T) { +// NOTHING IS THROWN AWAY. What a landed row used to spend its second line on +// is on the hint line when the pointer is on it, and only that row's. +func TestALandedRowGivesItsBlockToTheHintLine(t *testing.T) { a, _, _ := taskApp(t) railLanded(a, 3) - a.railTake(true) - railFocusOn(t, a, 2) - - a.railOut() - text := strings.Join(railText(a, 20), "\n") - if !strings.Contains(text, railReportOf(2)) { - t.Fatalf("→ on a landed row disclosed nothing:\n%s", text) - } - // AND ONLY THAT ROW'S. The gesture is per row, exactly as a family's fold is - // per family. - if strings.Contains(text, railReportOf(1)) || strings.Contains(text, railReportOf(3)) { - t.Fatalf("opening one row opened its neighbours:\n%s", text) - } - - a.railIn() - if text := strings.Join(railText(a, 20), "\n"); strings.Contains(text, railReportOf(2)) { - t.Fatalf("← did not tuck the block back away:\n%s", text) + hint := railHint(a, 2) + if !strings.Contains(hint, dollars(railCostOf(2))) { + t.Fatalf("the hint over a landed row does not say what it cost: %q", hint) } -} - -// THE POINTER IS OFFERED THE SAME FOLD, in the cell the state was in — which is -// the affordance law this column already keeps for a family root: the triangle -// arrives when there is a hand on the row and never before. -func TestALandedRowOffersItsDisclosureUnderThePointer(t *testing.T) { - a, _, _ := taskApp(t) - railLanded(a, 3) - - line, y := marginLine(t, a, func(l railLine) bool { - return strings.Contains(plain(l.text), railBuild(2)) - }) - if strings.Contains(plain(line.text), glyphShut) { - t.Fatalf("a row nobody is pointing at already wears the disclosure:\n%q", plain(line.text)) + if strings.Contains(hint, dollars(railCostOf(1))) || strings.Contains(hint, dollars(railCostOf(3))) { + t.Fatalf("one row's hint carried its neighbours': %q", hint) } - - x := a.railLeft() + 3 - drive(t, a, tea.MouseMotionMsg{X: x, Y: y}) - lit, _ := marginLine(t, a, func(l railLine) bool { + // AND THE POINTER READS THE SAME HINT, on the row the pointer is on. + _, y := marginLine(t, a, func(l railLine) bool { return strings.Contains(plain(l.text), railBuild(2)) }) - if !strings.Contains(plain(lit.text), glyphShut) { - t.Fatalf("the row under the pointer offers no way into what it is holding:\n%q", plain(lit.text)) - } - - // AND THE PRESS ON THAT CELL IS THE FOLD, which is hover.go's own law: the - // set that lights is the set that acts. - drive(t, a, tea.MouseClickMsg{X: a.railLeft() + ansi.StringWidth(railSeam), Y: y, Button: tea.MouseLeft}) - if text := strings.Join(railText(a, 20), "\n"); !strings.Contains(text, railReportOf(2)) { - t.Fatalf("a press on the disclosure opened nothing:\n%s", text) - } -} - -// A ROW WITH NOTHING BEHIND IT OFFERS NOTHING. A triangle that answered a press -// with silence would teach a person that the cell means nothing. -func TestALandedRowWithNothingToSayOffersNoDisclosure(t *testing.T) { - a, _, _ := taskApp(t) - a.taskUpdate(update(7, "Fix the nil-map crash", session.TaskDone, session.TaskNotice{})) - - entries := a.railEntries() - if len(entries) != 1 { - t.Fatalf("the column drew %d rows for one node", len(entries)) + drive(t, a, tea.MouseMotionMsg{X: a.railLeft() + 3, Y: y}) + if a.hot.kind != hoverRail || a.hot.id != 2 { + t.Fatalf("the pointer on the row resolved to %+v", a.hot) } - if a.railTucks(entries[0]) { - t.Fatal("a row with no block behind it still offers the fold") + if got := a.sideHoverWords(); got != hint { + t.Fatalf("the pointer's hint %q is not the row's %q", got, hint) } } @@ -239,15 +191,17 @@ func TestTheStandingSectionIsNotStarvedByALongRoster(t *testing.T) { } } -// The blank spacer under the hide control stays while tasks scroll. -func TestTheTasksSpacerStaysWhileTheRosterScrolls(t *testing.T) { +// THE HEADER STAYS WHILE THE TASKS SCROLL, and the first row of the list is +// right under it with no spacer between. +func TestTheHeaderStaysWhileTheRosterScrolls(t *testing.T) { a, _, _ := taskApp(t) railLanded(a, 40) a.railScroll(12) rows := railText(a, 20) - if len(rows) < 2 || !strings.Contains(rows[0], railStowHint) || strings.TrimSpace(strings.TrimPrefix(rows[1], "│")) != "" { - t.Fatalf("the spacer changed while scrolling:\n%s", strings.Join(rows, "\n")) + if len(rows) < 2 || !strings.Contains(rows[0], sideTasksWord+" 40") || + strings.TrimSpace(strings.TrimPrefix(rows[1], "│")) == "" { + t.Fatalf("the header moved while scrolling:\n%s", strings.Join(rows, "\n")) } } diff --git a/internal/tui3/railwork_test.go b/internal/tui3/railwork_test.go index 2e110ca2d3..43b7f97a8d 100644 --- a/internal/tui3/railwork_test.go +++ b/internal/tui3/railwork_test.go @@ -68,6 +68,7 @@ func TestAWorkerIsDrawnOnceByTheFamilyThatOwnsIt(t *testing.T) { // The same two hands, as the engine announced them: a row each, under 7. a.taskUpdate(update(8, "Read the law", session.TaskQueued, session.TaskNotice{Parent: 7})) a.taskUpdate(update(9, "Write the tests", session.TaskRunning, session.TaskNotice{Parent: 7})) + railOpenAll(a) text := strings.Join(railText(a, a.viewHeight()), "\n") for _, title := range []string{"Build the rail", "Read the law", "Write the tests"} { diff --git a/internal/tui3/railworkername_test.go b/internal/tui3/railworkername_test.go index ce3aa68ca5..6758be802d 100644 --- a/internal/tui3/railworkername_test.go +++ b/internal/tui3/railworkername_test.go @@ -50,7 +50,7 @@ func TestARunSaysItIsFormingWhileItHasNothingToShowYet(t *testing.T) { a.taskUpdate(update(1, "competitive intelligence on the three vendors", session.TaskRunning, session.TaskNotice{Doing: "forming the work"})) - if drawn := strings.Join(railText(a, a.viewHeight()), "\n"); !strings.Contains(drawn, "forming the work") { + if drawn := strings.Join(railText(a, a.viewHeight()), "\n") + "\n" + railHint(a, 1); !strings.Contains(drawn, "forming the work") { t.Fatalf("the run's row says nothing while its workers are being formed:\n%s", drawn) } @@ -61,7 +61,7 @@ func TestARunSaysItIsFormingWhileItHasNothingToShowYet(t *testing.T) { a.taskUpdate(update(2, "pricing sheet", session.TaskRunning, session.TaskNotice{Parent: 1})) railKinship(a, 1, 2) - drawn := strings.Join(railText(a, a.viewHeight()), "\n") + drawn := strings.Join(railText(a, a.viewHeight()), "\n") + "\n" + railHint(a, 1) if strings.Contains(drawn, "forming the work") { t.Fatalf("the run still says it is forming with a worker on the board:\n%s", drawn) } diff --git a/internal/tui3/render.go b/internal/tui3/render.go index c64b134ddb..cf561d9a60 100644 --- a/internal/tui3/render.go +++ b/internal/tui3/render.go @@ -67,6 +67,10 @@ const ( // row nothing in the conversation produced — the line is drawn between two // blocks, and it exists only while the mode is up. hitRewind + // hitThread is a line of a thread card (teamthreadcard.go): the words of a + // manager's message or of a member's answer, which a press lays out in + // full and a second press folds again. The row's open field says whose. + hitThread ) // row is one visible screen row and what it points at. It is the single @@ -104,6 +108,8 @@ type row struct { // Picture controls retain their index and original-file action through gutter layout. pictureIndex int pictureOpen hudSpan + // open is a [hitThread] row's message, by team and entry id. + open string } // toolWindow is how many of a turn's tool calls stay on screen. Three is the @@ -741,6 +747,10 @@ func (a *app) deckRows(d deck, width int) ([]row, bool) { // the cells that open it — a press on its number landed in the sentence // beside it. That was true of every moved row with a link in it before this // pass moved every row; it is not true of any row now. + // THE TEAM HALF OF THE LINK PASS, over the rows as they were laid out and + // before the indent law moves them with their spans (teamlink.go). + a.teamLinkPass(out, es) + a.mentionLinkPass(out, es) if workIndent(width) != "" { cols := workIndentCols(width) for i := range out { @@ -922,6 +932,11 @@ func (a *app) entryRows(d deck, i, width int) []string { // out of the per-frame path; tool rows make the opposite trade because their // lines already bypass this cache. key := renderedEntryKey{identity: e.identity, width: width, ink: a.inkState} + // A TEAM NOTE DRAWS ANSWERS OUT OF THE TRAFFIC CACHE (teamthreadcard.go), so + // its rows go stale when that cache moves, and only then. + if a.teamNoteStale(e, width) { + e.stale = true + } if e.built && e.rowKey == key && !e.stale { return e.rows } @@ -1222,6 +1237,9 @@ func (a *app) renderEntry(i int, e *entry, width int) []string { case entryHarness: return a.harnessFeedRows(e.harness, width, a.sel == i) + case entryTeam: + return a.teamCardRows(*e, width) + case entryNote: // A LINE MAY BE QUIET; THE FACT IT CARRIES MAY NOT BE (payload.go). The // lane keeps its dim prose and its dim lead — a note is still the surface @@ -1250,6 +1268,11 @@ func (a *app) renderEntry(i int, e *entry, width int) []string { body := wrap(e.text, room) if e.block { body = noteBlockLines(e.text, room) + } else if e.sheet { + // /help is a column. A wrap that starts the next row at the margin + // makes the sentence look like a new key. Continuations keep the + // column the first row's sentence already sits in. + body = wrapSheet(e.text, room) } out := make([]string, 0, len(body)) walk := factWalk{words: e.facts} @@ -1980,6 +2003,7 @@ func (a *app) statusRows(width int) []string { // where they landed (foot.go). The ledger's doors are the seam's now and // are cleared there; the deck records its own. a.modelSpan = hudSpan{} + a.dockClear() if a.startingChat() { return []string{a.pal.dim(fit("New chat · first message starts the conversation", width))} } @@ -3716,6 +3740,12 @@ func (a *app) footHint(width int) string { if hint := a.hintWord(); hint != "" { return hint } + // A WORD OF THE HEAD UNDER THE POINTER says what it opens and its key + // (topnav.go's [app.headHint]), under a state's own keys and over every + // resting sentence. + if hint := a.headHint(); hint != "" { + return hint + } // AND UNDER THE STATES, BUT OVER EVERY TIP AND DOOR: THE CHORD THAT DID NOT // ARRIVE. A Mac whose Option key is composing accents answers the switcher's // chord with the character `˚`, and the legend's own door would go on naming @@ -3920,6 +3950,9 @@ func (a *app) hintWord() string { // enter belongs to the LINE rather than to the list (input.go). return "tab take · enter run · esc" case a.menu.open || a.comp.open: + if hint := a.mentionHeadHint(); hint != "" { + return hint + } return "↑↓ · enter · esc" case a.shaping(): // The widening answer is part-way given and the block is on its second @@ -3995,7 +4028,7 @@ func (a *app) hintWord() string { // It costs no rows, for the reason the line above it costs none: this is // the legend, which is on the frame in every state. return spellOutHint - case a.railAway && a.railAvail(): + case a.railAway && a.railAvail() && a.headHint() == "": // THE COLUMN IS AWAY AND THIS SESSION HAS RUN SOMETHING (task.go's // [app.railStow]). It ranks LAST, under every state above it, because it is // the only line here that is not about the next keystroke — it is where the @@ -4008,8 +4041,10 @@ func (a *app) hintWord() string { // there. This is that sign. With nothing run at all it stays quiet — the // column a person closed was empty, ctrl+g still brings it back, and a // standing hint about a roster of nothing is the emptiness law broken in - // the one slot a person reads most. - return railBackHint + // the one slot a person reads most. A word of the head under the pointer + // outranks it too ([app.footHint] asks [app.headHint] next): the pointer + // is on a word, and the line says that word. + return a.sideBackHint() } return "" } @@ -4125,6 +4160,82 @@ func wrap(text string, width int) []string { return out } +// wrapSheet is [wrap] for a column sheet such as /help. Each source line keeps +// its own column: a row that already starts in spaces stays there, and a row +// whose sentence begins after a gap of spaces continues under that sentence. +// A continuation that fell back to column 0 read as a new key. +func wrapSheet(text string, width int) []string { + if width < 4 { + width = 4 + } + text = strings.ReplaceAll(text, "\t", " ") + var out []string + for _, para := range strings.Split(text, "\n") { + if para == "" { + out = append(out, "") + continue + } + out = append(out, wrapSheetLine(para, width)...) + } + return out +} + +// wrapSheetLine wraps one sheet row so every piece starts at the same column +// as the sentence on the first piece. +func wrapSheetLine(line string, width int) []string { + at := sheetColumn(line) + if at <= 0 || at >= width-4 { + return strings.Split(ansi.Wrap(line, width, ""), "\n") + } + head, rest := splitCells(line, at) + if strings.TrimSpace(rest) == "" { + return []string{line} + } + body := strings.Split(ansi.Wrap(rest, width-at, ""), "\n") + if len(body) == 0 { + return []string{line} + } + pad := strings.Repeat(" ", at) + out := make([]string, len(body)) + out[0] = head + body[0] + for i := 1; i < len(body); i++ { + out[i] = pad + body[i] + } + return out +} + +// sheetColumn is where a sheet row's sentence starts, in cells. A row that +// already begins with spaces is hanging there. Otherwise it is the cell after +// the first gap of two or more spaces, which is the column the key's sentence +// is padded to. Zero means the row has no column to keep. +func sheetColumn(line string) int { + lead := 0 + for _, r := range line { + if r != ' ' { + break + } + lead++ + } + if lead > 0 { + return lead + } + gap := 0 + col := 0 + for _, r := range line { + if r == ' ' { + gap++ + col++ + continue + } + if gap >= 2 { + return col + } + gap = 0 + col += ansi.StringWidth(string(r)) + } + return 0 +} + // noteBlockLines is [wrap]'s opposite number for a block whose own line // structure is the meaning: the text's own lines, each one FITTED to the width // and none of them re-flowed. diff --git a/internal/tui3/replay.go b/internal/tui3/replay.go index 87b1200411..c2c49c50fb 100644 --- a/internal/tui3/replay.go +++ b/internal/tui3/replay.go @@ -772,6 +772,12 @@ func (a *app) replayBlocks(entries []session.DisplayEntry, shape replayShape) ([ if text == "" { continue } + // A LINE THE TEAM SENT IS A CARD, headed by who said it to whom + // (teamcard.go), and never the person's `›`. + if len(e.Team) > 0 || strings.HasPrefix(text, teamAsideLead) { + blocks = append(blocks, entry{kind: entryTeam, text: text, team: e.Team, turn: turn}) + continue + } // A LINE THE SESSION WROTE GOES IN THE SESSION'S OWN LANE — the dim // "· " row this surface says everything of its own in ([feed.note]) — // and NOT above a "›" as though somebody had typed it. diff --git a/internal/tui3/rewindsheet.go b/internal/tui3/rewindsheet.go index b419ac0fb8..a173e1f166 100644 --- a/internal/tui3/rewindsheet.go +++ b/internal/tui3/rewindsheet.go @@ -82,7 +82,7 @@ const ( // which is the task page's own law about its foot ([app.taskSheetKeysLine]). rewindSheetKeys = "esc close · ↑↓ move · enter picks the point" rewindSheetPickedKeys = "esc close · ↑↓ move · enter again rewinds here" - rewindSheetSearchKeys = "esc clears the search · ↑↓ move · enter picks the point" + rewindSheetSearchKeys = "esc clear the search · ↑↓ move · enter picks the point" // rewindSheetSearchWord opens the line that says what was typed, and // rewindSheetSearchNone is what that line adds when the search has taken every // row off the page. A filtered page with nothing on it and nothing said is a diff --git a/internal/tui3/room.go b/internal/tui3/room.go index 560fb4e2f5..de299defef 100644 --- a/internal/tui3/room.go +++ b/internal/tui3/room.go @@ -2275,13 +2275,9 @@ func (a *app) goHome() { // // A ROW IS A DOOR AND ONLY A DRAWN CONTROL IS ANYTHING ELSE. Anywhere on a // node's row opens that node's room, which is what every row of this column has -// always done, and the cells that mean something else are the ones the frame put -// there to be pressed and no others: a folded root's `▸ +N`, where the count is -// what says something is hidden, and the glyph cell ON THE FRAMES WHERE IT IS -// DRAWN AS A DISCLOSURE, which is while the pointer is on a row that can fold. -// Both come from spans the layout recorded (task.go's [app.railEntryRows]), so -// the target is always exactly what is on screen; the press does not ask what -// KIND of row it hit, because a row that could fold is not a fold control. +// always done; a group's heading opens or folds its group; and the side +// column's own rows answer through the doors their layout recorded +// (sidecol.go), so the target is always exactly what is on screen. // // The press moves the roster's cursor to what was pressed but does NOT take the // keyboard: clicks focus what was clicked, and the draft is where this surface @@ -2324,16 +2320,18 @@ func (a *app) railPress(x, y int) (tea.Cmd, bool) { a.roomPanelTake(line.roomAction) return nil, true } + // THE SIDE COLUMN'S OWN ROWS ANSWER FOR THEMSELVES: the header's words and + // its key, a band item, a row of the Traffic and the doors on each + // (sidecol.go). A row with nothing to press takes the press to do nothing. + if line.side != nil { + if !line.side.pressable() && line.side.doorAt(a.sideLineCol(x)) < 0 { + return nil, true + } + return a.sidePress(line.side, a.sideLineCol(x)) + } // THE FOOTER'S ONE OFFER IS PRESSABLE, because a hint that names a key and // cannot be pressed is a hint that is only for one of the two hands // (task.go's [app.railFootRows]). - // AND THE LAST LINE IS THE COLUMN'S DOOR, for the same reason one rung up: a - // line that names ctrl+g and cannot be clicked is an affordance for one of the - // two hands (task.go's [railStowHint]). - if line.stow { - a.railStow(true) - return nil, true - } // AND THE DOOR ONTO THE TASK PAGE IS THE THIRD OF THEM, on the same terms: it // names a chord, so it has to answer to the hand that does not type chords // ([taskSheetPastHint], taskview.go). It leaves the column exactly as it is — @@ -2372,30 +2370,22 @@ func (a *app) railPress(x, y int) (tea.Cmd, bool) { return a.openRailPlan(line.plan, nil), true } e, ok := a.railEntryAt(y) - if !ok || e.node == nil { + if !ok { return nil, true } a.railWhere = railSpotOf(e) - at := x - a.railLeft() - ansi.StringWidth(railSeam) - // THE WHOLE ROW IS THE NODE'S DOOR AND THE TWO EXCEPTIONS ARE DRAWN. A press - // falls through to the room unless it landed on something the frame put there - // to be pressed — the `▸ +N` a folded root wears at rest, and the disclosure - // the glyph cell becomes under the pointer — and BOTH are read from spans the - // layout recorded rather than from a question about what kind of row this is - // (task.go's [app.railEntryRows]). Asking the row's kind was the bug: a family - // root and a landed row with a block tucked under it CAN fold, so their - // leading cells folded on every press, while the cell they folded from was - // drawing the row's state on every frame where the pointer was not already on - // it. A person aiming at a task got a list that jumped instead of a page. - switch { - case line.badge.holds(at): - a.railSetOpen(e.node, true) - case line.glyph.holds(at): - a.railToggle(e.node) - default: - return a.openRailRoom(e.node), true + // A GROUP'S HEADING OPENS THE GROUP OR FOLDS IT, anywhere on the row, and + // the running work's heading, which does not fold, takes the press to do + // nothing. EVERY OTHER ROW IS A NODE, and the whole row is its door. + if e.head { + a.sideToggleGroup(e.group) + return nil, true + } + if e.node == nil { + return nil, true } - return a.takeRoomPump(), true + a.sideAck(e.node) + return a.openRailRoom(e.node), true } // railSeamAt reports whether a pointer is on the visible two-cell handle — which @@ -2424,7 +2414,7 @@ func (a *app) railSeamAt(x, y int) bool { // in the roster's last thirty columns: the box did not focus, the hint did not // act, and nothing at all happened. Below the region a press is somebody else's. func (a *app) railAt(x, y int) bool { - if !a.railFull() && (!a.railShowing() || x < a.bodyWidth()) { + if !a.railFull() && (!a.railShowing() || x < a.bodyWidth() || x >= a.bodyWidth()+a.railWidth()) { return false } top := a.bodyTop() diff --git a/internal/tui3/roomclick_test.go b/internal/tui3/roomclick_test.go index 33c0508fc2..d9e58f6014 100644 --- a/internal/tui3/roomclick_test.go +++ b/internal/tui3/roomclick_test.go @@ -34,13 +34,26 @@ func bandSeq() string { return "\x1b[48;5;" + itoa(int(hueSelected.idx)) + "m" } // walked into, not which row it happened to be on. func clickRailNode(t *testing.T, a *app, id uint64) { t.Helper() + // THE ROW IS PRESSED WHERE IT IS DRAWN: under its group, opened first, or + // in the band when it needs the person (sidecol.go). + railOpenAll(a) + for _, key := range []string{"task/" + itoa(int(id)), "fail/" + itoa(int(id))} { + if a.sideRowOf(key) == nil { + a.railRows(a.viewHeight()) + } + if a.sideRowOf(key) != nil { + x, y := sideRowOn(t, a, key) + drive(t, a, tea.MouseClickMsg{X: x, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: x, Y: y, Button: tea.MouseLeft}) + return + } + } top := a.bodyTop() for y := top; y < top+a.viewHeight(); y++ { if node := a.railNodeAt(y); node != nil && node.id == id { // Past the seam and past the state cell, on the title. The two cells - // before it are the column's handle at this width, and the one after - // them is the fold while the pointer is on it (task.go's - // [app.railLead]) — this press wants neither. + // before it are the column's handle at this width, and this press + // does not want it. drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + ansi.StringWidth(railSeam) + 6, Y: y, Button: tea.MouseLeft}) drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + ansi.StringWidth(railSeam) + 6, @@ -188,8 +201,8 @@ func roomID(a *app) uint64 { return a.room.id } -// AND THE COLUMN'S OWN DOOR IS STILL PRESSABLE FROM INSIDE A ROOM — the last -// line of the roster, which names ctrl+g (task.go's [railStowHint]). +// AND THE COLUMN'S OWN DOOR IS STILL PRESSABLE FROM INSIDE A ROOM: the key +// at the right of its header, which names alt+l (sidecol.go's [sideHideKey]). func TestTheColumnsStowLineStillAnswersFromInsideARoom(t *testing.T) { a, _, _ := roomApp(t) a.profileDir = t.TempDir() @@ -198,18 +211,9 @@ func TestTheColumnsStowLineStillAnswersFromInsideARoom(t *testing.T) { if !a.roomOpen() { t.Fatal("the rail did not open a room") } - at := -1 - for y := a.bodyTop(); y < a.bodyTop()+a.viewHeight(); y++ { - if line, ok := a.railLineAt(y); ok && line.stow { - at = y - break - } - } - if at < 0 { - t.Fatal("the column drew no door out of itself") - } - drive(t, a, tea.MouseClickMsg{X: a.bodyWidth() + 2, Y: at, Button: tea.MouseLeft}) - drive(t, a, tea.MouseReleaseMsg{X: a.bodyWidth() + 2, Y: at, Button: tea.MouseLeft}) + x, y := sideDoorOf(t, a, sideActHide) + drive(t, a, tea.MouseClickMsg{X: x, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: x, Y: y, Button: tea.MouseLeft}) if a.railShowing() { t.Fatal("a press on the column's own door did not put it away") } diff --git a/internal/tui3/roomcrumb_contract_test.go b/internal/tui3/roomcrumb_contract_test.go index 3c2ce80c88..733bea7fdd 100644 --- a/internal/tui3/roomcrumb_contract_test.go +++ b/internal/tui3/roomcrumb_contract_test.go @@ -474,7 +474,7 @@ func TestTheConversationDrawsNoTrailRowOfItsOwn(t *testing.T) { // THE CONVERSATION'S HEAD IS THE PLACES' HEAD — pulse, strip, rule, blank — // and the four rows are charged together (head.go). A room opened from here // would lay its trail on the first row under them. - want := placeHeadRows + want := chatHeadRows if a.headHeight() != want || a.bodyTop() != want || a.roomHeadRow() != want { t.Fatalf("the strip is drawn but not budgeted: head=%d top=%d row=%d want=%d", a.headHeight(), a.bodyTop(), a.roomHeadRow(), want) diff --git a/internal/tui3/roomcrumbs.go b/internal/tui3/roomcrumbs.go index 5b1c5d13cf..bf20d5199c 100644 --- a/internal/tui3/roomcrumbs.go +++ b/internal/tui3/roomcrumbs.go @@ -411,7 +411,8 @@ func (a *app) roomTrail() string { // headLabelAt is the column a pinned label starts on. It is two cells for both // room labels: [app.legendLine] opens the room's header with the border's own // `─ `, keeping the crumb over the transcript's words. The navigation strip -// uses [tabLead] instead so its Home target aligns with the places bar. +// starts here too, and the places bar with it ([placeBarLead]), so the home +// target sits in the same cells on the dashboard and in a conversation. // // It is stated once because the crumb spans are measured from the label's start // and pressed in the terminal's own columns, and a bar that recorded one and read diff --git a/internal/tui3/roomorch_transcript_test.go b/internal/tui3/roomorch_transcript_test.go index c7a064a340..c11ffe2a33 100644 --- a/internal/tui3/roomorch_transcript_test.go +++ b/internal/tui3/roomorch_transcript_test.go @@ -70,8 +70,9 @@ func TestRunRailNodeDoorsOpenItsFocusedCard(t *testing.T) { t.Fatalf("the focused node card is not on the run page:\n%s", got) } + // The newest row is first under its heading: the node, then its run. a = adaptiveRailApp(t) - clickRailDoor(t, a, 1) + clickRailDoor(t, a, 0) if !a.orchShowing("r1") || a.orchOf().card != "rfcs" { t.Fatalf("click opened %+v, want run r1 focused on rfcs", a.orchOf()) } @@ -79,7 +80,7 @@ func TestRunRailNodeDoorsOpenItsFocusedCard(t *testing.T) { func TestRunRailRootDoorOpensTheRunPage(t *testing.T) { a := adaptiveRailApp(t) - clickRailDoor(t, a, 0) + clickRailDoor(t, a, 1) if !a.orchShowing("r1") { t.Fatalf("root click did not open run r1: %+v", a.orchOf()) } diff --git a/internal/tui3/roompanel.go b/internal/tui3/roompanel.go index 84ff90ad69..be36846558 100644 --- a/internal/tui3/roompanel.go +++ b/internal/tui3/roompanel.go @@ -38,7 +38,6 @@ func (a *app) roomPanelView(height int) ([]railLine, int) { width := a.railRoom() entries := a.railEntries() focus := a.railFocusIndex(entries) - a.railCramped = false lines := a.railLines(entries, width) controls := a.roomControlRows(width) foot, marks := a.railFootRows(width, height) diff --git a/internal/tui3/roompanel_test.go b/internal/tui3/roompanel_test.go index cbced1b2c1..6b8613f8f4 100644 --- a/internal/tui3/roompanel_test.go +++ b/internal/tui3/roompanel_test.go @@ -227,7 +227,6 @@ func TestDeepTaskPanelKeepsAncestorClicksAndControlScope(t *testing.T) { n := &taskNode{id: id, title: name, label: name, parent: fmt.Sprint(parent), state: session.TaskRunning, model: "z-ai/glm-5.3"} a.tasks[id] = n a.taskOrder = append(a.taskOrder, id) - a.railSetOpen(a.tasks[parent], true) parent = id } for _, width := range []int{100, 120, 160} { @@ -244,7 +243,7 @@ func TestDeepTaskPanelKeepsAncestorClicksAndControlScope(t *testing.T) { lines, _ := a.railView(a.viewHeight()) found := false for row, line := range lines { - if line.head && line.entry >= 0 && entries[line.entry].node.id == 129 { + if line.head && line.entry >= 0 && entries[line.entry].node != nil && entries[line.entry].node.id == 129 { found = true drive(t, a, tea.MouseClickMsg{X: width - 2, Y: a.topHeight() + row, Button: tea.MouseLeft}) if a.room.id != 129 { diff --git a/internal/tui3/settings.go b/internal/tui3/settings.go index 9c4a025073..f9a2152155 100644 --- a/internal/tui3/settings.go +++ b/internal/tui3/settings.go @@ -5,6 +5,7 @@ import ( "os" "path/filepath" "sort" + "strconv" "strings" tea "charm.land/bubbletea/v2" @@ -18,6 +19,7 @@ import ( "github.com/Agent-Field/codeaf/internal/roles" "github.com/Agent-Field/codeaf/internal/session" "github.com/Agent-Field/codeaf/internal/standing" + teamstore "github.com/Agent-Field/codeaf/internal/teams" ) // THE SETTINGS PANEL: /settings, or ctrl+, — the FIRST of the three fullscreen @@ -101,6 +103,12 @@ const ( // tabTasks is how work you can walk away from is run — how it starts, how it // is checked, how much of it happens at once, and on whose hands. tabTasks = "Tasks" + // tabTeams is what every team inherits when it says nothing of its own: + // who answers a member's question, what a team may spend in a day, what a + // new sub-team is given, and how deep teams may nest. A team's own + // overrides are on its card on the teams page; these are the defaults its + // `· from Settings` points at. + tabTeams = "Teams" // tabProviders is which model answers what. tabProviders = "Providers" ) @@ -112,23 +120,27 @@ const ( // Spending, Safety and Tasks stand between Display and Providers, and Spending // leads the three: "what may it spend" is asked before "on which machine", and // before either of the two questions that used to share its tab. +// +// Teams follows Tasks: both are about work you hand off, and its defaults are +// read after the question of how one task runs. var settingTabs = []string{tabSession, tabContext, tabWorkspace, tabDisplay, - tabSpending, tabSafety, tabTasks, tabProviders, tabConnections} + tabSpending, tabSafety, tabTasks, tabTeams, tabProviders, tabConnections} -// settingTabCategory is the ONE-TO-ONE map between the three new tabs and the -// three registry categories behind them, and it is the seam that keeps the skin +// settingTabCategory is the ONE-TO-ONE map between the four newer tabs and the +// four registry categories behind them, and it is the seam that keeps the skin // honest about the one source of truth. // // The other tabs are a reading of the ROWS and not of the categories — "session // ceiling" is a dollar figure that answers "what may THIS conversation do" — and -// that stays true of them. These three are different: the registry's own words -// for them (`spending`, `safety`, `tasks`) are already the product's words for +// that stays true of them. These four are different: the registry's own words +// for them (`spending`, `safety`, `tasks`, `teams`) are already the product's words for // them, so a row that is filed under one and drawn under another would be two // answers to one question. chrome_test.go pins the map in both directions. var settingTabCategory = map[string]string{ tabSpending: config.CategorySpending, tabSafety: config.CategorySafety, tabTasks: config.CategoryTasks, + tabTeams: config.CategoryTeams, } // settingWidget is how a row is ANSWERED, which is not quite how it reads. @@ -771,6 +783,34 @@ var settingUI = map[string]settingMeta{ "context window and goes lean under 32,000 tokens; lean and full say so yourself, " + "for a provider that reports a window its model does not really have.", }, + // ── Teams ─────────────────────────────────────────────────────────────── + // The five defaults every team inherits, in the order a person reaches + // for them (DESIGN.md section 8, the settings tab's Teams group). + config.KeyTeamsQuestionsUp: { + tab: tabTeams, label: "questions go to the manager", widget: widgetToggle, + about: "a member's clarifying question goes to its manager first; you are asked only " + + "what no manager can answer. Permission prompts always come to you.", + }, + config.KeyTeamsWake: { + tab: tabTeams, label: "team messages wake", widget: widgetToggle, + about: "a manager's directive starts an idle member's turn, and a member's reply " + + "starts the manager's. Off, messages wait for the next turn.", + }, + config.KeyTeamsCapUSDDay: { + tab: tabTeams, label: "daily cap per team", widget: widgetText, + about: "what a team and the teams under it may spend in a day before its manager " + + "asks you whether to go on. Blank or 0 is no cap.", + }, + config.KeyTeamsSubSharePct: { + tab: tabTeams, label: "sub-team share", widget: widgetText, + about: "the share of its parent's cap a new sub-team starts with. Teams that " + + "already exist keep theirs.", + }, + config.KeyTeamsDepthLimit: { + tab: tabTeams, label: "team depth", widget: widgetText, + about: "how many levels of teams a manager may build, the top team counting as one. " + + "1 means no sub-teams.", + }, } func init() { @@ -958,6 +998,19 @@ func (i sheetItem) restful() bool { return i.head == "" && i.read == nil } // frame nothing. type sheet struct { tab int + // host is the machine the session runs on over --host, "" otherwise. + host string + // teamDefaultsWrite says the teams seam can change that machine's `teams.` + // rows ([TeamsSeam.ApplyDefault]). False over --host against an engine + // without the door, and the Teams tab stays read-only. + teamDefaultsWrite bool + // farTeams is that machine's five defaults, once the seam has answered. + // Nil until then, and nil on a local launch. + farTeams *teamstore.Defaults + // hostNote is the settings sentence already written into the transcript + // for this visit. The same words are not written again when the tab + // moves between two tabs that share a disk. + hostNote string registry *config.Settings // profileDir is retained only for live explanations derived from several @@ -1273,16 +1326,6 @@ func (a *app) openSettings() { a.showPage(pageSettings) } // raiseSettings builds the panel. It is [placeSettings]'s `open` and nothing // else calls it, which is what makes the router the one road in. func (a *app) raiseSettings() { - // THE PANEL OPENS AND SAYS WHOSE ROWS THESE ARE. Over --host it edits this - // machine's profile, and only some of these rows are about this machine: the - // mouse, the timestamps, the draft and the history are the surface's own and - // apply; the tool gate, the spend rail and the auxiliary models are the - // SESSION's, and the session reads them from the profile on the other machine. - // Closing the panel would take the working half away; opening it silently - // would let somebody turn a gate off and watch it stay on (host.go). - if a.hosted() { - a.note(settingsRemoteWord) - } // The day's own figure, read once for the whole of this visit (see // [app.spentTodayUSD]). a.readDayCost() @@ -1292,9 +1335,15 @@ func (a *app) raiseSettings() { // [app.spentThisSessionUSD], issue #269). It is a tail read // ([session.UsageCache]) and it happens once per visit, never on a draw. a.readTreeSpend() + write := false + if a.hosted() && a.teamsDisk.door.present() && a.teamsDisk.door.ApplyDefault != nil && a.teamsDisk.door.Defaults != nil { + write = true + } a.sheet = sheet{ - registry: a.registry(), - profileDir: a.profileDir, + host: a.host, + teamDefaultsWrite: write, + registry: a.registry(), + profileDir: a.profileDir, // AND WHAT THIS PROJECT DOES WITH A QUESTION WHILE NOBODY IS THERE. The // rows are the engine's rather than the registry's (settingsautonomy.go), // and a page that asked the engine per frame would be paying for an @@ -1316,9 +1365,32 @@ func (a *app) raiseSettings() { } a.sheet.rows = a.sheet.registry.Rows() a.sheet.build() + // WHOSE ROWS, SAID FOR THE TAB ON SHOW. Over --host the note is + // [settingsHostNote]: this machine on every tab but Teams, and the far + // machine on Teams when the seam can write it. It is said after the sheet + // exists, because the sentence is a reading of that sheet. Closing the + // panel would take the working rows away; opening it silently would let + // somebody turn a gate off and watch it stay on (host.go). + a.saySettingsHost() a.touch() } +// saySettingsHost writes the hosted settings sentence when it is not the one +// already in the transcript. A local launch says nothing. Moving between two +// tabs that share a disk says nothing again. +func (a *app) saySettingsHost() { + if !a.hosted() { + return + } + onTeams := a.sheet.tab >= 0 && a.sheet.tab < len(settingTabs) && settingTabs[a.sheet.tab] == tabTeams + word := settingsHostNote(onTeams, a.host, a.sheet.teamDefaultsWrite, a.sheet.farTeams != nil) + if word == a.sheet.hostNote { + return + } + a.sheet.hostNote = word + a.note(word) +} + // closeSettings is the DOOR out of the panel, and it goes through the router. func (a *app) closeSettings() { if a.at(pageSettings) { @@ -1744,8 +1816,12 @@ func (s *sheet) changed(item sheetItem) bool { case config.SettingModel, config.SettingPercent: return false } + value := item.row.Value() + if raw, ok := s.farTeamValue(item.row.Key); ok { + value = raw + } was, known := s.defaults[item.row.Key] - return known && was != item.row.Value() + return known && was != value } // ── the roles ─────────────────────────────────────────────────────────────── @@ -2095,10 +2171,12 @@ func (a *app) sheetKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { // only in the message one (editundo.go). if editorUndo(&s.query, msg.String()) { s.build() + a.saySettingsHost() return nil, true } if editorWordKill(&s.query, msg.String()) { s.build() + a.saySettingsHost() return nil, true } @@ -2113,6 +2191,7 @@ func (a *app) sheetKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { if s.searching() { s.query.reset() s.build() + a.saySettingsHost() return nil, true } if a.connEsc() { @@ -2199,6 +2278,7 @@ func (a *app) sheetKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { s.build() } } + a.saySettingsHost() return nil, true } @@ -2258,6 +2338,14 @@ func (a *app) activate() tea.Cmd { return a.startModelConnect(modelConnectionStatus(source, true), true) } s.msg = "" + // OVER --host THE TEAMS DEFAULTS ARE THAT MACHINE'S. With the seam's write + // door they are edited there, the same keys the local tab writes. Without + // it an edit here would change this laptop's file and no team anybody is + // running, so the row says so instead. + if s.host != "" && item.meta.tab == tabTeams && !s.teamDefaultsWrite { + s.msg = s.hostTeamsLockedWord() + return nil + } if item.autonomy != nil { return a.autonomyRowNext(item.autonomy) } @@ -2278,9 +2366,16 @@ func (a *app) activate() tea.Cmd { switch item.meta.widget { case widgetToggle: next := "on" - if item.row.Value() == "on" { + cur := item.row.Value() + if raw, ok := s.farTeamValue(item.row.Key); ok { + cur = raw + } + if cur == "on" { next = "off" } + if cmd := a.writeHostTeamDefault(item, next); cmd != nil || s.hostTeamRow(item) { + return cmd + } a.applySetting(item, next) case widgetCycle: @@ -2336,6 +2431,9 @@ func (a *app) activate() tea.Cmd { default: value := item.row.Value() + if raw, ok := s.farTeamValue(item.row.Key); ok { + value = raw + } if value == item.row.EmptyLabel { // The empty label is what the row SAYS when it holds nothing // ("none", "follows the conversation"). Putting that word in the box @@ -2520,29 +2618,34 @@ func (a *app) applySetting(item sheetItem, raw string) { // sheetEditKey drives the text submenu. enter saves, an empty box clears the // row, esc leaves it exactly as it was. -func (a *app) sheetEditKey(msg tea.KeyPressMsg) { +func (a *app) sheetEditKey(msg tea.KeyPressMsg) tea.Cmd { s := &a.sheet edit := s.edit // The word and line jumps are the surface's, said once (editkeys.go). if editorMotion(&edit.box, msg.String()) { - return + return nil } // AND ctrl+z TAKES BACK WHAT WAS TYPED, in every box on this surface and not // only in the message one (editundo.go). if editorUndo(&edit.box, msg.String()) { - return + return nil } switch msg.String() { case "esc": s.edit = nil case "enter": row, ok := s.registry.Row(edit.key) + raw := edit.box.String() s.edit = nil if !ok { - return + return nil } meta, _ := settingMetaFor(row) - a.applySetting(sheetItem{row: row, meta: meta}, edit.box.String()) + item := sheetItem{row: row, meta: meta} + if cmd := a.writeHostTeamDefault(item, raw); cmd != nil || s.hostTeamRow(item) { + return cmd + } + a.applySetting(item, raw) case "backspace": edit.box.deleteBackward() case "delete": @@ -2570,6 +2673,146 @@ func (a *app) sheetEditKey(msg tea.KeyPressMsg) { edit.box.insert(text) } } + return nil +} + +// hostTeamRow reports whether this row is a Teams default edited on the far +// machine. The local registry is not the writer then. +func (s *sheet) hostTeamRow(item sheetItem) bool { + return s.host != "" && s.teamDefaultsWrite && item.meta.tab == tabTeams +} + +// hostTeamsLockedWord is the one line an older engine gets: the tab can be +// read and cannot be changed over this connection. +func (s *sheet) hostTeamsLockedWord() string { + if s.farTeams != nil { + return "changing them is not available over this connection" + } + return "the teams on " + s.host + " inherit that machine's Settings; change them there" +} + +// farTeamValue is one Teams row as the registry's Value would read it from the +// far machine's defaults. The bool is false until that read has landed, and +// false for every other row. +func (s *sheet) farTeamValue(key string) (string, bool) { + if s.farTeams == nil { + return "", false + } + d := s.farTeams + switch key { + case config.KeyTeamsQuestionsUp: + if d.QuestionsUp { + return "on", true + } + return "off", true + case config.KeyTeamsWake: + if d.Wake { + return "on", true + } + return "off", true + case config.KeyTeamsCapUSDDay: + if d.CapUSDDay == 0 { + return "no cap", true + } + return "$" + strconv.FormatFloat(d.CapUSDDay, 'f', -1, 64), true + case config.KeyTeamsDepthLimit: + return strconv.Itoa(d.DepthLimit), true + case config.KeyTeamsSubSharePct: + return strconv.Itoa(int(d.SubShare*100 + 0.5)), true + } + return "", false +} + +// hostedTeamReading is that value as the row draws it, with the unit the +// registry would add and the provenance the team card uses for a value that +// comes from these rows ([teamstore.Origin.Words], `from Settings`). +func (s *sheet) hostedTeamReading(item sheetItem) (string, bool) { + raw, ok := s.farTeamValue(item.row.Key) + if !ok { + return "", false + } + value := raw + switch item.row.Key { + case config.KeyTeamsDepthLimit: + unit := "levels" + if raw == "1" { + unit = "level" + } + value = raw + " " + unit + case config.KeyTeamsSubSharePct: + value = raw + "%" + } + if words := (teamstore.Origin{Kind: teamstore.OriginSettings}).Words(); words != "" { + value += " · " + words + } + return value, true +} + +// readHostTeamDefaults asks the seam for the far machine's `teams.` rows, off +// the loop. It is nil locally and against an engine that cannot answer. +func (a *app) readHostTeamDefaults() tea.Cmd { + if !a.hosted() { + return nil + } + door := a.teamsDisk.door + if !door.present() || door.Defaults == nil { + return nil + } + read := door.Defaults + return a.besideLine(func() func(bool) tea.Cmd { + d, err := read() + return func(here bool) tea.Cmd { + if !here || !a.at(pageSettings) { + return nil + } + if err != nil { + a.sheet.msg = err.Error() + a.touch() + return nil + } + a.sheet.farTeams = &d + a.sheet.build() + a.saySettingsHost() + a.touch() + return nil + } + }) +} + +// writeHostTeamDefault sends one Teams row through the seam, off the loop. +// A nil command with [sheet.hostTeamRow] false means this row is local and +// the caller writes it the usual way. +func (a *app) writeHostTeamDefault(item sheetItem, raw string) tea.Cmd { + if !a.sheet.hostTeamRow(item) { + return nil + } + if a.sheet.farTeams == nil { + return nil + } + door := a.teamsDisk.door.ApplyDefault + if door == nil { + a.sheet.msg = a.sheet.hostTeamsLockedWord() + return nil + } + key := item.row.Key + return a.offLoop(func() func(bool) tea.Cmd { + d, err := door(key, raw) + return func(here bool) tea.Cmd { + if !here || !a.at(pageSettings) { + return nil + } + if err != nil { + a.sheet.msg = err.Error() + } else { + copied := d + a.sheet.farTeams = &copied + a.sheet.msg = "" + } + a.sheet.build() + a.touch() + return nil + } + }) } // sheetSelectKey drives the model picker while a slot row owns it. Only the two @@ -2694,6 +2937,7 @@ func (a *app) sheetPress(x, y int) tea.Cmd { a.sheet.cursor, a.sheet.top, a.sheet.msg = 0, 0, "" a.sheet.conn.armed, a.sheet.conn.entry = false, nil a.sheet.build() + a.saySettingsHost() a.touch() } case sheetHitRow: @@ -2755,9 +2999,7 @@ func (a *app) sheetFrame(width, height int) ([]string, []sheetHit, int, int) { // row is gone — the place tab bar above says `settings` — and so is its keys // line, which is the one hint every place shares now. ITS OWN TAB BAR STAYS, // as the first row of its body, and the two bars are not a repetition: the - // upper one is the seven places and the lower one is this place's sections. - // The panel is where [placeTabBar] was lifted from, so they are drawn by the - // same geometry and read as one object at two scales. + // nav at the top is the places and this one is this place's sections. s := &a.sheet pal := a.pal lines, hits, caretX, caretY := placeFrame(a, width, height, @@ -2858,9 +3100,9 @@ func tabChipCols(title string) int { return ansi.StringWidth(title) + tabPadCols // account, were also unreachable by eye: nobody discovers a tab they have never // seen. // -// SCROLLING, NOT COLLAPSING, AND HERE IS WHY. The place bar solves the same -// squeeze by giving words up in a stated order until only the word you are -// standing in is left ([app.placeTabBar]'s width ladder), and that is right +// SCROLLING, NOT COLLAPSING, AND HERE IS WHY. The nav solves the same squeeze +// by folding words into `more ▾` in a stated order until only the word you are +// standing in is left (topnav.go's width ladder), and that is right // THERE because its words are rooms — each one is a door you reach by name, the // bar is a list of the ones worth naming, and a room with something new in it // earns its cells over a room with nothing. These nine are not a list of doors; @@ -3206,6 +3448,9 @@ func (s *sheet) rowLinesWithin(item sheetItem, selected, hovered bool, width, bo // beside the default, rather than spelled again by every surface that draws // a number ([config.Setting.Reading]). value := item.row.Reading() + if hosted, ok := s.hostedTeamReading(item); ok { + value = hosted + } if value == "" { value = "—" } @@ -3370,6 +3615,21 @@ func (s *sheet) footNote() string { if s.onConnections() { return s.connFootNote() } + // THE TEAMS TAB IS DEFAULTS, and says where the exceptions live: a team's + // own overrides are on its card on the teams page (teamsheet.go). Over + // --host it says whose defaults the teams there really read. + if settingTabs[s.tab] == tabTeams { + if s.host != "" && !s.teamDefaultsWrite { + if s.farTeams != nil { + return "on " + s.host + " the teams inherit that machine's Settings · changing them is not available over this connection" + } + return "on " + s.host + " the teams inherit that machine's Settings · these are this one's, shown and not edited" + } + if s.host != "" { + return "a team can override any of these on its card · saved on " + s.host + } + return "a team can override any of these on its card · saved to your profile" + } if item, ok := s.current(); ok { if name, pinned := item.row.PinnedBy(); pinned { return "held by " + name + " — unset it to change this here" diff --git a/internal/tui3/settingspend_test.go b/internal/tui3/settingspend_test.go index e84ee601f8..8864d679a1 100644 --- a/internal/tui3/settingspend_test.go +++ b/internal/tui3/settingspend_test.go @@ -127,7 +127,7 @@ func TestSafetyAndTasksHoldWhatSpendingLetGoAndWorkspaceNamesNoMoney(t *testing. } // AND THE BAR READS IN THE DESIGN'S ORDER. want2 := []string{tabSession, tabContext, tabWorkspace, tabDisplay, - tabSpending, tabSafety, tabTasks, tabProviders, tabConnections} + tabSpending, tabSafety, tabTasks, tabTeams, tabProviders, tabConnections} if strings.Join(settingTabs, " ") != strings.Join(want2, " ") { t.Fatalf("the tab bar reads %v", settingTabs) } diff --git a/internal/tui3/settingsteams_host_test.go b/internal/tui3/settingsteams_host_test.go new file mode 100644 index 0000000000..94a6d3429d --- /dev/null +++ b/internal/tui3/settingsteams_host_test.go @@ -0,0 +1,139 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/Agent-Field/codeaf/internal/config" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// AN EDIT OVER A HOST SEAM LANDS IN THE FAR PROFILE and nowhere on this +// machine. The row says where the value came from in the same words the team +// card uses for a value inherited from these defaults. +func TestTeamsSettingsOverAHostSeamLandInTheFarProfile(t *testing.T) { + a := placeApp(t) + laptop := a.profileDir + far := t.TempDir() + a.host = "spark" + a.teamsDisk.door = localTeams(far, &a.teamsDisk.watch) + before := teamstore.DefaultsAt(laptop) + drive(t, a, key(placeChord(pageSettings))) + openTeamsTab(t, a) + if a.sheet.farTeams == nil || !a.sheet.teamDefaultsWrite { + t.Fatal("the Teams tab did not take the far defaults as editable") + } + if note := a.sheet.footNote(); !strings.Contains(note, "saved on spark") { + t.Fatalf("the Teams tab says %q", note) + } + if screen := placeFrameText(a); !strings.Contains(screen, "from Settings") { + t.Fatalf("the row does not say where the value came from:\n%s", screen) + } + if item, ok := a.sheet.current(); !ok || item.row.Key != config.KeyTeamsQuestionsUp { + t.Fatalf("the cursor is not on questions: %+v", item.row.Key) + } + drive(t, a, key("enter")) + got := teamstore.DefaultsAt(far) + if got.QuestionsUp { + t.Fatal("the far profile still has questions going up") + } + if after := teamstore.DefaultsAt(laptop); after != before { + t.Fatalf("the laptop profile changed: %+v", after) + } + if words := (&teamstore.File{}).Effective("missing", got).QuestionsUpFrom.Words(); words != "from Settings" { + t.Fatalf("provenance %q", words) + } + + drive(t, a, key("down"), key("down"), key("enter"), key("4"), key("enter")) + if cap := teamstore.DefaultsAt(far).CapUSDDay; cap != 4 { + t.Fatalf("the far cap is %v", cap) + } + if teamstore.DefaultsAt(laptop) != before { + t.Fatal("the cap write touched the laptop profile") + } +} + +// AN OLDER ENGINE KEEPS THE TAB READ-ONLY and says so in one line. The far +// profile is not written, and neither is this machine's. +func TestTeamsSettingsOverAnOlderEngineStayReadOnly(t *testing.T) { + a := placeApp(t) + laptop := a.profileDir + far := t.TempDir() + door := localTeams(far, &a.teamsDisk.watch) + door.ApplyDefault = nil + a.host = "spark" + a.teamsDisk.door = door + beforeLap := teamstore.DefaultsAt(laptop) + beforeFar := teamstore.DefaultsAt(far) + drive(t, a, key(placeChord(pageSettings))) + openTeamsTab(t, a) + if a.sheet.teamDefaultsWrite { + t.Fatal("an older engine's Teams tab is editable") + } + if a.sheet.farTeams == nil { + t.Fatal("the tab did not show the far defaults it can still read") + } + if note := a.sheet.footNote(); !strings.Contains(note, "not available over this connection") { + t.Fatalf("the Teams tab says %q", note) + } + before := a.sheet.items[a.sheet.cursor].row.Value() + drive(t, a, key("enter")) + if a.sheet.edit != nil || !strings.Contains(a.sheet.msg, "not available over this connection") { + t.Fatalf("a Teams row took an edit (msg %q)", a.sheet.msg) + } + if after := a.sheet.items[a.sheet.cursor].row.Value(); after != before { + t.Fatalf("the row changed from %q to %q", before, after) + } + if teamstore.DefaultsAt(far) != beforeFar || teamstore.DefaultsAt(laptop) != beforeLap { + t.Fatal("a refused edit was written") + } +} + +// THE NOTE FOLLOWS THE TAB. A local tab says the rows are this machine's. The +// Teams tab, over a seam that can write, says they are saved on the far +// machine and does not repeat the local claim. +func TestSettingsNoteFollowsTheTabOverAHostSeam(t *testing.T) { + a := placeApp(t) + far := t.TempDir() + a.host = "spark" + a.teamsDisk.door = localTeams(far, &a.teamsDisk.watch) + drive(t, a, key(placeChord(pageSettings))) + local := lastNote(t, a) + if local != settingsLocalWord { + t.Fatalf("local tab note = %q", local) + } + if strings.Contains(local, "spark") { + t.Fatalf("the local tab named the far machine: %q", local) + } + for settingTabs[a.sheet.tab] != tabTeams { + drive(t, a, key("right")) + } + if !a.sheet.teamDefaultsWrite { + t.Fatal("the seam did not make the Teams tab writable") + } + got := lastNote(t, a) + if got != "these rows are saved on spark." { + t.Fatalf("Teams tab note = %q", got) + } + if strings.Contains(got, "this machine") { + t.Fatalf("the Teams tab still claims this machine: %q", got) + } + drive(t, a, key("left")) + if settingTabs[a.sheet.tab] == tabTeams { + t.Fatal("left did not leave the Teams tab") + } + if again := lastNote(t, a); again != settingsLocalWord { + t.Fatalf("back on a local tab the note is %q", again) + } +} + +func openTeamsTab(t *testing.T, a *app) { + t.Helper() + for i, title := range settingTabs { + if title == tabTeams { + a.sheet.tab = i + } + } + a.sheet.cursor = 0 + a.sheet.build() +} diff --git a/internal/tui3/sidecol.go b/internal/tui3/sidecol.go new file mode 100644 index 0000000000..ae856a64d6 --- /dev/null +++ b/internal/tui3/sidecol.go @@ -0,0 +1,1002 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE SIDE COLUMN: ONE COLUMN, TWO SOURCES ──────────────────────────────── +// +// The right of every conversation is one column with one header, and the +// header is two words: +// +// │ Tasks 14 · Traffic 3 new alt+l +// │ ? @security asks: ship at p99 180ms? the needs-you band +// │ ✗ parser bench failed a failure, in ink +// │ ──────────────────────────────────────────── +// │ Running 4 +// │ ⠙ rebase onto dev 2m +// │ Queued 3 ▸ +// │ Done 7 ▸ +// +// THERE USED TO BE TWO COLUMNS AND A SPECIAL CASE BETWEEN THEM. An ordinary +// chat had the task column; a chat with a team manager in front had the +// Traffic instead, with the manager's own tasks behind a `Traffic · Tasks 2` +// word. Now there is this one component and it has two sources: the +// conversation's own work ([sideTasks], task.go's roster) and what passes in +// its team ([sideTraffic], sidetraffic.go). A chat that is in no team has only +// the first, and its header is the one word. +// +// THE CURRENT WORD IS BOLD INK AND THE OTHER IS DIM, and each is a door with a +// hover ground and a hint. The other word keeps its count, so what arrived in +// the Traffic while the tasks are in front is still on screen (`Traffic 3 +// new`). Which word is in front is remembered for the session per kind of chat +// ([sideState.view]): a manager chat opens on the Traffic, every other chat on +// the tasks. +// +// THE BAND IS WHAT NEEDS THE PERSON NOW, from both sources ([app.sideBand]): +// a question or a packet waiting on them, a task whose next step is theirs, +// and a failure nobody has looked at yet. Amber is ONLY for the first kind, +// the items blocked on the person; a failure is a ✗ in ordinary ink. The band +// shows [sideBandCap] rows and then `+N more`, is gone entirely when there is +// nothing in it, and an item in it is not drawn again in the list under it. +// It pushes the list down and never the conversation: the column's width does +// not move for anything drawn in it. +// +// NOTHING HERE MOVES THE CONVERSATION. The column's width is decided by the +// frame's width and the person's own widen answer and by nothing it shows +// ([app.railColumns]), so switching words, folding a group, a row arriving +// and the band appearing all happen inside the column. Nothing here takes the +// keyboard either: alt+t hands it to the column, as it always has, and esc +// gives it back (task.go's [app.railKey]). +// +// THE FRAME DRAWS MEMORY. The Traffic is the cache teamtraffic.go's clock +// keeps, the tasks are the roster's nodes, and the rows the Traffic view lays +// are kept between frames ([sideTrafficCache]) until what they are drawn from +// moves. + +// The two sources, as the column's view. +const ( + sideTasks = 1 + sideTraffic = 2 +) + +// The three kinds of chat, which is what the view is remembered by. +const ( + sideKindPlain = iota + sideKindMember + sideKindManager + sideKinds +) + +// Geometry. +const ( + // The column takes a quarter of the frame, between sideColsMin and + // sideColsMax, and never leaves the conversation under sideBodyFloor. It + // is the same at every view and in every kind of chat: at 110 columns it + // is 28, at 120 it is 30 (the task column's old width), at 160 it is 40. + // A quarter and not the Traffic's old three tenths, because this is now + // the column of every chat and the conversation beside it is the page. + sideColsMin = 28 + sideColsMax = 40 + sideBodyFloor = 56 + // sideBandCap is how many rows the band draws before `+N more`. + sideBandCap = 3 +) + +// The header's words. +const ( + sideTasksWord = "Tasks" + sideTrafficWord = "Traffic" + sideNewWord = "new" + sideWordSep = " · " + // sideHideKey is the column's own key, named at the right of its header. + // ctrl+g ([railStowKey]) is the same key under its older name. + sideHideKey = trafficKey +) + +// sideState is the column's memory for the session: which word is in front +// per kind of chat, which task groups and work threads the person opened, +// which failures they have looked at, and where the Traffic's `new` line +// stands. It is this window's and in memory only. +type sideState struct { + view [sideKinds]int + // open is each foldable task group the person opened. + open [railGroupCount]bool + // threads is each work thread laid open, by [sideThreadKey], and moved + // counts the presses that changed it, which the rows' cache keys on. + threads map[string]bool + moved int + // acked is every failed task the person has opened since it failed. + acked map[uint64]bool + // bandAll says the band draws every item instead of [sideBandCap]. + bandAll bool + // divider is, per team, the newest entry the person had seen when the + // Traffic came into view, which is where the `new` line is drawn; up is + // the team whose Traffic is in view now, so the line holds still while it + // is being read. + divider map[string]string + up string + // asks is the band's reading of the Traffic, kept until the log moves. + asks sideAskCache + // traffic is the Traffic view's rows as last laid. + traffic sideTrafficCache + // last is the band and Traffic rows the last layout drew, for the hint + // line, and pinned how many rows at its top were the header, the band and + // the way back to the main chat, which nothing is laid above. + last []*sideRow + pinned int +} + +// ── A ROW AND WHAT A PRESS ON IT DOES ─────────────────────────────────────── + +// The acts a row or a door of the column does. +const ( + sideActNone = iota + // sideActOpen opens task id. + sideActOpen + // sideActJump takes the person to Traffic entry entry in member key's + // conversation. key is the chat the message belongs to (teamrail.go's + // [app.trafficBelongsTo]). Already in front, it scrolls in place. + sideActJump + // sideActThread lays work thread key open or folds it. + sideActThread + // sideActBand shows every band item, or folds them back to three. + sideActBand + // sideActView brings word view to the front. + sideActView + // sideActHide puts the column away. + sideActHide + // sideActTeams opens the teams page, where a packet is answered. + sideActTeams +) + +// sideAct is what a press does. +type sideAct struct { + kind int + id uint64 + key string + entry string + view int +} + +// sideDoor is a target narrower than its row: a word of the header, a handle, +// a thread's ▸. span is in the row's own columns. +type sideDoor struct { + span hudSpan + hint string + act sideAct +} + +// sideRow is one row of the band or the Traffic view: its identity, which is +// what the hover and the keyboard hold, what the hint line says over it, what +// a press on it does, and its doors. +type sideRow struct { + key string + hint string + act sideAct + doors []sideDoor +} + +// doorAt is the door under column x of the row, -1 for none. +func (r *sideRow) doorAt(x int) int { + for i, d := range r.doors { + if d.span.holds(x) { + return i + } + } + return -1 +} + +// pressable reports whether a press anywhere on the row does something. +func (r *sideRow) pressable() bool { return r.act.kind != sideActNone } + +// ── WHICH CHAT, WHICH WORD, HOW WIDE ──────────────────────────────────────── + +// sideColsFor is the column the frame lends at width, 0 when the +// conversation would be left too narrow for one. +func sideColsFor(width int) int { + if width < railSlimFloor { + return 0 + } + cols := min(max(width/4, sideColsMin), sideColsMax) + if width-cols < sideBodyFloor { + return 0 + } + return cols +} + +// sideTeam is the team the chat in front is in, as the column reads it: the +// team it manages, or the managed team it is a member of with its handle. +// Plain for a chat in no managed team, and on a window that cannot read the +// engine's teams ([app.teamsOff]). Frame-safe and allocation free. +func (a *app) sideTeam() (team, int, string) { + if a.teamsOff() || !a.wall.loaded || len(a.wall.teams) == 0 { + return team{}, sideKindPlain, "" + } + if t, ok := a.teamFrontManaged(); ok { + return t, sideKindManager, "" + } + front := a.frontTabKey() + for _, t := range a.wall.teams { + if t.Manager == "" || t.Manager == front { + continue + } + if m, ok := t.Member(front); ok && m.Handle != "" { + return t, sideKindMember, m.Handle + } + } + return team{}, sideKindPlain, "" +} + +// sideKind is the kind of chat in front. +func (a *app) sideKind() int { + _, kind, _ := a.sideTeam() + return kind +} + +// sideView is the word in front: the person's own choice for this kind of +// chat, else the Traffic in a manager chat and the tasks everywhere else. A +// chat in no team has only the tasks. +func (a *app) sideView() int { + kind := a.sideKind() + if kind == sideKindPlain { + return sideTasks + } + if v := a.side.view[kind]; v != 0 { + return v + } + if kind == sideKindManager { + return sideTraffic + } + return sideTasks +} + +// sideSetView brings view to the front and remembers it for this kind of +// chat. It moves nothing but what the column draws: the keyboard stays where +// it was, and a cursor on a row the other view does not have goes to the +// view's first row. +func (a *app) sideSetView(view int) { + kind := a.sideKind() + if kind == sideKindPlain || a.sideView() == view { + return + } + a.side.view[kind] = view + a.side.up = "" + a.dropHover() + if a.railHold { + a.railWhere = railSpot{} + if spots := a.railSpots(); len(spots) > 0 { + a.railWhere = spots[0] + } + } + a.touch() +} + +// sideStep switches to the other word, which is what ← and → do while the +// column holds the keyboard. +func (a *app) sideStep() { + if a.sideView() == sideTasks { + a.sideSetView(sideTraffic) + return + } + a.sideSetView(sideTasks) +} + +// sideAway reports whether the person has put the column away: the saved +// answer, and on the teams page the page's own, which starts folded because +// the page has a rail of its own on the left (teamspagehost.go). +func (a *app) sideAway() bool { + if a.teamsHosting() { + return !a.tp.traffic + } + return a.railAway +} + +// sideToggle is alt+l: the column goes away or comes back where the frame +// lends it one, and on a frame too narrow for one it is laid over the body +// and taken off again ([app.railFull]). +func (a *app) sideToggle() bool { + if a.railShowing() || a.railStowed() { + a.railStow(a.railShowing()) + return true + } + if a.railFull() { + a.railTake(false) + return true + } + if a.railAvail() && !a.railQuiet() { + a.railTake(true) + return a.railHold + } + return false +} + +// ── THE HEADER ────────────────────────────────────────────────────────────── + +// sideHeadRow is the column's first line, width wide, and its doors: the two +// words, and the key that puts the column away at the right. +func (a *app) sideHeadRow(width int) (string, *sideRow) { + t, kind, handle := a.sideTeam() + view := a.sideView() + row := &sideRow{key: sideHeadKey} + hot := -1 + if a.hot.kind == hoverSide && a.hot.key == sideHeadKey { + hot = a.hot.index + } + var b strings.Builder + used := 0 + // word paints one word of the header: its label bold ink when it is in + // front and dim when it is not, its count the same except that a zero is + // always dim and a count of new rows (fresh) is always ink, so what arrived + // behind the other word is still read. + word := func(label, count string, fresh bool, current bool, act sideAct, hint string) { + text := label + " " + count + if fresh { + text += " " + sideNewWord + } + var painted string + switch { + case current: + painted = a.pal.bold(a.pal.ink(label + " ")) + default: + painted = a.pal.dim(label + " ") + } + switch { + case count == "0": + painted += a.pal.dim(count) + case fresh: + painted += a.pal.ink(count + " " + sideNewWord) + case current: + painted += a.pal.bold(a.pal.ink(count)) + default: + painted += a.pal.dim(count) + } + w := ansi.StringWidth(text) + if act.kind != sideActNone { + if hot == len(row.doors) { + painted = a.pal.cursor(painted, 0) + } + row.doors = append(row.doors, sideDoor{span: hudSpan{from: used, to: used + w}, hint: hint, act: act}) + } + b.WriteString(painted) + used += w + } + team := kind != sideKindPlain + tasksAct, trafficAct := sideAct{}, sideAct{} + if team { + tasksAct = sideAct{kind: sideActView, view: sideTasks} + trafficAct = sideAct{kind: sideActView, view: sideTraffic} + } + word(sideTasksWord, itoa(len(a.taskOrder)), false, view == sideTasks, tasksAct, "Show this chat's tasks"+hintSegment+"click") + if team { + n, fresh := a.sideTrafficCount(t, kind, handle) + // WITH THE TRAFFIC IN FRONT NOTHING IN IT IS NEW TO THE WORD: the `new` + // line in the view says where the unread rows end. + if view == sideTraffic { + fresh = 0 + } + count, isNew := itoa(n), fresh > 0 + if isNew { + count = itoa(fresh) + } + // A NARROW COLUMN LOSES THE WORD `new` FIRST, and keeps the count. + full := ansi.StringWidth(sideWordSep + sideTrafficWord + " " + count + " " + sideNewWord) + if isNew && used+full > width { + isNew = false + } + b.WriteString(a.pal.dim(sideWordSep)) + used += ansi.StringWidth(sideWordSep) + hint := "Show the team's traffic" + if kind == sideKindMember { + hint = "Show the traffic with @" + handle + } + if fresh > 0 { + hint += hintSegment + itoa(fresh) + " new" + } + word(sideTrafficWord, count, isNew, view == sideTraffic, trafficAct, hint+hintSegment+"click") + } + // THE WAY OUT IS THE LAST WORD, the key itself, and it is a door. + // Spelled the way this keyboard's caps say it: `opt+l` on a Mac. + key := a.chords.say(sideHideKey) + // It keeps one cell of air from the words, which is what lets `Tasks 14 · + // Traffic 8 alt+l` stand in the twenty-eight columns of a 110 frame. + if gap := width - used - ansi.StringWidth(key); gap >= 1 { + b.WriteString(strings.Repeat(" ", gap)) + used += gap + hint := "Hide this column" + hintSegment + key + if a.railFull() { + hint = "Close this column" + hintSegment + key + } + door := len(row.doors) + painted := a.pal.dim(key) + if hot == door { + painted = a.pal.cursor(a.pal.ink(key), 0) + } + row.doors = append(row.doors, sideDoor{span: hudSpan{from: used, to: used + ansi.StringWidth(key)}, hint: hint, act: sideAct{kind: sideActHide}}) + b.WriteString(painted) + } + return fit(b.String(), width), row +} + +// sideHeadKey is the header row's identity for the hover. +const sideHeadKey = "head" + +// sideTrafficCount is the Traffic word's count, and how many of those rows +// arrived since the person last had the Traffic in front of them: every drawn +// message of team t, or in a member's chat the ones involving that member. +func (a *app) sideTrafficCount(t team, kind int, handle string) (int, int) { + rows := a.traffic.rows[t.ID] + seen := a.traffic.seen[t.ID] + n, fresh := 0, 0 + for i := range rows { + e := &rows[i] + if !trafficShown(*e) || e.Wake() { + continue + } + if kind == sideKindMember && !sideInvolves(*e, handle) { + continue + } + n++ + if e.ID > seen { + fresh++ + } + } + return n, fresh +} + +// sideInvolves reports whether an entry is to or from a member's handle, or +// to the whole team. +func sideInvolves(e teamstore.Entry, handle string) bool { + if e.From == handle || e.To == teamstore.ToEveryone { + return true + } + if e.To == handle { + return true + } + if e.To == teamstore.ToSeveral { + for _, h := range e.Handles { + if h == handle { + return true + } + } + } + return false +} + +// ── THE BAND ──────────────────────────────────────────────────────────────── + +// sideBandItem is one thing that needs the person now. +type sideBandItem struct { + key string + // ask says the item is blocked on the person, which is what the amber is + // for; every other item is a failure. mark is its one cell: a task's own + // state glyph, and the needs-a-person `?` for a question from the team. + ask bool + mark string + words string + age string + act sideAct + hint string +} + +// sideBandFails reports whether a task is a failure the band carries: work +// this window watched fail on its own, that the person has not opened since. +// A stop the person made is not a failure waiting on them, and a failure a +// reopened conversation replayed is history, not news. +func (a *app) sideBandFails(node *taskNode) bool { + return node != nil && node.state == session.TaskFailed && !node.stopped && !node.restored && !a.side.acked[node.id] +} + +// sideBand is every item that needs the person now, blocked items first: +// the team's questions waiting on them, packets put to them, tasks whose next +// step is theirs, then failures nobody has looked at. Newest first in each. +func (a *app) sideBand() []sideBandItem { + var out []sideBandItem + t, kind, handle := a.sideTeam() + if kind != sideKindPlain { + for _, e := range a.sideAsks(t, kind, handle) { + // THE BAND READS `from → to` TOO: the member that asked, the + // manager's mark, then the question. In this member's own chat + // the member is `you`. The whole row stays amber, because it is + // the one thing that needs the person. + from := a.trafficAddr(e.From) + if kind == sideKindMember && e.From == handle { + from = "you" + } + q := strings.TrimSpace(strings.TrimPrefix(strings.Join(strings.Fields(e.Text), " "), "asks:")) + words := from + " " + a.linearMark("→", "->") + " " + a.teamManagerMark() + " " + q + self := "" + if kind == sideKindMember { + self = handle + } + age := a.trafficAge(e) + act := sideAct{kind: sideActJump, key: a.trafficBelongsTo(t, e), entry: e.ID} + hint := trafficOpenHint(a.trafficSenderWord(e.From, self), age, q) + out = append(out, sideBandItem{key: "ask/" + t.ID + "/" + e.ID, ask: true, mark: homeAskGlyph, words: words, age: age, act: act, hint: hint}) + } + if kind == sideKindManager { + for _, p := range a.tp.packets { + if !p.Waiting() || p.Team != teamstore.Person || p.Origin != t.ID { + continue + } + words := "decide: " + strings.Join(strings.Fields(p.Question), " ") + out = append(out, sideBandItem{key: "packet/" + p.ID, ask: true, mark: homeAskGlyph, words: words, + act: sideAct{kind: sideActTeams}, hint: words + hintSegment + "click opens the teams page to decide"}) + } + } + } + members := a.railMembers() + for _, node := range members[railAttention] { + status := a.taskStatus(node) + words := node.title + if word := status.RowWord(); word != "" { + words += railSep + word + } + // A RUN HELD AT ITS GATE WEARS THE GATE'S MARK here as in the list + // ([app.railTreeGlyph]). + mark := a.taskStateMark(node) + if node.Paused() { + mark = ansi.Strip(a.stripPausedGlyph()) + } + out = append(out, sideBandItem{key: "task/" + itoa(int(node.id)), ask: true, mark: mark, words: words, + act: sideAct{kind: sideActOpen, id: node.id}}) + } + for _, node := range members[railDone] { + if !a.sideBandFails(node) { + continue + } + words := node.title + if word := a.taskStatus(node).Word; word != "" { + words += " " + word + } + out = append(out, sideBandItem{key: "fail/" + itoa(int(node.id)), mark: a.taskStateMark(node), words: words, + act: sideAct{kind: sideActOpen, id: node.id}}) + } + return out +} + +// sideTaskOf is the task a band row's key names, 0 for a row that is not a +// task's. +func sideTaskOf(key string) uint64 { + for _, lead := range []string{"task/", "fail/"} { + if rest, ok := strings.CutPrefix(key, lead); ok { + id := uint64(0) + for _, c := range rest { + if c < '0' || c > '9' { + return 0 + } + id = id*10 + uint64(c-'0') + } + return id + } + } + return 0 +} + +// sideBandRows lays the band width wide: at most [sideBandCap] items and a +// `+N more` row, or every item when the person asked for them, and a rule +// under them. Nothing at all when nothing needs the person. +// fitClauses is words cut to width with the ellipsis where they run out, and +// A CUT THAT LEAVES A CLAUSE ITS SEPARATOR AND NOTHING ELSE ends at the clause +// before it instead: `Ship the price table…`, never `Ship the price table · …`, +// which spends three cells on saying there was more. +func fitClauses(words string, width int, tail string) (string, int) { + if ansi.StringWidth(words) <= width { + return words, ansi.StringWidth(words) + } + cut := ansi.Truncate(words, max(width, 0), tail) + body := strings.TrimRight(strings.TrimSuffix(cut, tail), " ·") + if at := strings.LastIndex(body, " · "); at > 0 && ansi.StringWidth(body[at+len(" · "):]) < 4 { + body = strings.TrimRight(body[:at], " ·") + } + if body == "" { + return cut, ansi.StringWidth(cut) + } + cut = body + tail + return cut, ansi.StringWidth(cut) +} + +func (a *app) sideBandRows(width int) []railLine { + items := a.sideBand() + if len(items) == 0 || width < 8 { + return nil + } + shown := items + more := 0 + if !a.side.bandAll && len(items) > sideBandCap+1 { + shown, more = items[:sideBandCap], len(items)-sideBandCap + } + out := make([]railLine, 0, len(shown)+2) + for _, item := range shown { + row := &sideRow{key: item.key, hint: item.hint, act: item.act} + // THE MARK IS THE ITEM'S OWN, and amber only for what is blocked on + // the person: a failure is its ✗ in ordinary ink. + mark, paint := item.mark, a.pal.ask + lead := a.pal.askBold(mark) + if !item.ask { + paint = a.pal.ink + lead = a.pal.ink(mark) + } + // THE AGE SITS AT THE RIGHT, dim, on the same ladder as a Traffic row. + // It is kept ahead of the words, which are the only part that is cut. + ageText := "" + ageW := 0 + if item.age != "" { + ageText = " " + item.age + ageW = ansi.StringWidth(ageText) + } + room := width - ansi.StringWidth(mark) - 1 - ageW + if room < 0 { + ageText, ageW, room = "", 0, width-ansi.StringWidth(mark)-1 + } + // A TRAFFIC ASK KEEPS `from → to` AND CUTS THE QUESTION AT A WORD. A task + // row has no arrow, and still cuts at a clause. + words := item.words + tail := a.linearMark("…", "~") + if at := strings.Index(item.words, " "); at > 0 && (strings.Contains(item.words[:at], "→") || strings.Contains(item.words[:at], "->")) { + prefix := item.words[:at+2] + words = prefix + fitAtWord(item.words[at+2:], max(room-ansi.StringWidth(prefix), 0), tail) + words = strings.TrimRight(words, " ") + } else { + words, _ = fitClauses(item.words, room, tail) + } + w := ansi.StringWidth(words) + line := lead + " " + paint(words) + strings.Repeat(" ", max(room-w, 0)) + if ageW > 0 { + line += a.pal.dim(ageText) + } + out = append(out, railLine{text: line, entry: -1, side: row}) + } + if more > 0 || (a.side.bandAll && len(items) > sideBandCap+1) { + word := "+" + itoa(more) + " more" + hint := "Show all " + itoa(len(items)) + hintSegment + "click" + if more == 0 { + word, hint = "fewer", "Show three"+hintSegment+"click" + } + out = append(out, railLine{text: a.pal.dim(fit(word, width)), entry: -1, + side: &sideRow{key: "band/more", hint: hint, act: sideAct{kind: sideActBand}}}) + } + out = append(out, railLine{text: a.pal.dim(strings.Repeat(a.linearMark("─", "-"), width)), entry: -1}) + return out +} + +// ── THE ASKS IN THE TRAFFIC ───────────────────────────────────────────────── + +// sideAskCache is the Traffic's questions waiting on the person, as last read. +type sideAskCache struct { + team, handle, last string + rows, kind int + asks []teamstore.Entry +} + +// sideAsks is every member of team t that asked the person something and has +// not been answered, newest first: its latest asking event, until anything +// later from it, or from the person to it, says it moved on. In a member's +// chat, that member's only. Read from memory and kept until the log moves. +func (a *app) sideAsks(t team, kind int, handle string) []teamstore.Entry { + rows := a.traffic.rows[t.ID] + last := "" + if len(rows) > 0 { + last = rows[len(rows)-1].ID + } + c := &a.side.asks + if c.team == t.ID && c.handle == handle && c.last == last && c.rows == len(rows) && c.kind == kind { + return c.asks + } + var pending map[string]int + for i := range rows { + e := &rows[i] + switch { + case e.Kind == teamstore.KindEvent && trafficAsking(*e) && e.From != teamstore.FromManager && e.From != teamstore.FromSystem: + if pending == nil { + pending = map[string]int{} + } + pending[e.From] = i + case e.Kind == teamstore.KindYou || e.From == teamstore.FromYou || teamstore.IsRuling(*e): + for _, h := range e.Recipients() { + delete(pending, h) + } + if e.To == teamstore.ToEveryone { + pending = nil + } + case e.Wake(): + // A member woken again on its question is running once more. + delete(pending, strings.TrimPrefix(strings.TrimPrefix(strings.TrimSpace(e.Text), "woke "), "@")) + default: + delete(pending, e.From) + } + } + var asks []teamstore.Entry + for i := len(rows) - 1; i >= 0; i-- { + e := rows[i] + if at, ok := pending[e.From]; !ok || at != i { + continue + } + if kind == sideKindMember && e.From != handle { + continue + } + asks = append(asks, e) + } + *c = sideAskCache{team: t.ID, handle: handle, last: last, rows: len(rows), kind: kind, asks: asks} + return asks +} + +// sideAsked reports whether entry id is one of the band's questions. +func (a *app) sideAsked(t team, kind int, handle, id string) bool { + for _, e := range a.sideAsks(t, kind, handle) { + if e.ID == id { + return true + } + } + return false +} + +// ── THE HEAD OF THE COLUMN, AS THE ROSTER LAYS IT ─────────────────────────── + +// sideHead is the column's pinned rows: the header, and the band under it. +// They stand at the top of every view and scroll with nothing. +func (a *app) sideHead(width int) []railLine { + text, row := a.sideHeadRow(width) + out := []railLine{{text: text, entry: -1, side: row}} + return append(out, a.sideBandRows(width)...) +} + +// sideRemember keeps the rows a layout drew, for the hint line. +func (a *app) sideRemember(lines []railLine) { + a.side.last = a.side.last[:0] + for _, l := range lines { + if l.side != nil { + a.side.last = append(a.side.last, l.side) + } + } +} + +// sideRowOf is the last drawn row with identity key, nil for none. +func (a *app) sideRowOf(key string) *sideRow { + for _, r := range a.side.last { + if r.key == key { + return r + } + } + return nil +} + +// ── UNDER THE HAND ────────────────────────────────────────────────────────── + +// sideLineCol is the column's own column under screen column x. +func (a *app) sideLineCol(x int) int { + return x - a.railLeft() - ansi.StringWidth(railSeam) +} + +// sideHoverAt is the hover the column's own rows answer with: a door of the +// header, a row of the band or of the Traffic, or a door on one. A row with +// nothing to press answers with nothing, so it does not light. +func (a *app) sideHoverAt(x, y int) (hoverAt, bool) { + if !a.railAt(x, y) || a.railSeamAt(x, y) { + return hoverAt{}, false + } + line, ok := a.railLineAt(y) + if !ok { + return hoverAt{}, false + } + if line.side == nil { + if e, ok := a.railEntryAt(y); ok && e.head && e.group != railRunning { + return hoverAt{kind: hoverRailGroup, index: int(e.group)}, true + } + return hoverAt{}, false + } + if door := line.side.doorAt(a.sideLineCol(x)); door >= 0 { + return hoverAt{kind: hoverSide, key: line.side.key, index: door}, true + } + if line.side.pressable() { + return hoverAt{kind: hoverSide, key: line.side.key, index: -1}, true + } + return hoverAt{}, false +} + +// sideHovering reports whether the pointer is on row key as a whole row. +func (a *app) sideHovering(key string) bool { + return key != "" && a.hot.kind == hoverSide && a.hot.key == key && a.hot.index < 0 +} + +// sidePress answers a press on one of the column's own rows at the column's +// column x. +func (a *app) sidePress(row *sideRow, x int) (tea.Cmd, bool) { + a.railWhere = railSpot{key: row.key} + if door := row.doorAt(x); door >= 0 { + return a.sideDo(row.doors[door].act), true + } + return a.sideDo(row.act), true +} + +// sideDo does one act. Nothing here takes the keyboard. +func (a *app) sideDo(act sideAct) tea.Cmd { + switch act.kind { + case sideActOpen: + node := a.tasks[act.id] + if node == nil { + return nil + } + a.sideAck(node) + return a.openRailRoom(node) + case sideActJump: + a.railTake(false) + return a.trafficJump(act.key, act.entry) + case sideActThread: + a.sideToggleThread(act.key) + case sideActBand: + a.side.bandAll = !a.side.bandAll + a.dropHover() + a.touch() + case sideActView: + a.sideSetView(act.view) + case sideActHide: + a.sideToggle() + case sideActTeams: + a.railTake(false) + return a.showPage(pageTeams) + } + return nil +} + +// sideAck records that the person opened a failed task, which takes it out +// of the band. +func (a *app) sideAck(node *taskNode) { + if node == nil || node.state != session.TaskFailed { + return + } + if a.side.acked == nil { + a.side.acked = map[uint64]bool{} + } + a.side.acked[node.id] = true +} + +// sideGroupShut reports whether a task group is folded to its heading. The +// running work is always open; the rest open when the person opens them, and +// stay that way for the session. +func (a *app) sideGroupShut(g railGroup) bool { + return g != railRunning && !a.side.open[g] +} + +// sideToggleGroup opens a folded group or folds it again. +func (a *app) sideToggleGroup(g railGroup) { + if g == railRunning || g >= railGroupCount { + return + } + a.side.open[g] = !a.side.open[g] + a.touch() +} + +// sideToggleThread lays a work thread's replies open under it, or folds them. +func (a *app) sideToggleThread(key string) { + if a.side.threads == nil { + a.side.threads = map[string]bool{} + } + if a.side.threads[key] { + delete(a.side.threads, key) + } else { + a.side.threads[key] = true + } + a.side.moved++ + a.touch() +} + +// sideRowAct is what enter does on the column's row key: a work thread's +// replies are laid open or folded, which is the one thing a keyboard cannot +// otherwise reach on it, and every other row does what a press on it does. +func (a *app) sideRowAct(key string) tea.Cmd { + row := a.sideRowOf(key) + if row == nil { + return nil + } + for _, d := range row.doors { + if d.act.kind == sideActThread { + return a.sideDo(d.act) + } + } + return a.sideDo(row.act) +} + +// sideSpots is every one of the column's own rows the keyboard walks, in the +// order they are drawn: the band, then the Traffic's rows while it is in +// front. +func (a *app) sideSpots() []railSpot { + var out []railSpot + for _, l := range a.sideHead(a.railRoom()) { + if l.side != nil && l.side.pressable() { + out = append(out, railSpot{key: l.side.key}) + } + } + if a.sideView() == sideTraffic { + lines, _ := a.sideTrafficView(a.viewHeight()) + for _, l := range lines { + if l.side != nil && l.side.pressable() { + out = append(out, railSpot{key: l.side.key}) + } + } + } + return out +} + +// sideHoverWords is what the hint line says with the pointer on the column, +// "" anywhere else. +func (a *app) sideHoverWords() string { + switch a.hot.kind { + case hoverSide: + if a.hot.key == sideHeadKey { + width := a.railRoom() + _, row := a.sideHeadRow(width) + if i := a.hot.index; i >= 0 && i < len(row.doors) { + return row.doors[i].hint + } + return "" + } + row := a.sideRowOf(a.hot.key) + if row == nil { + return "" + } + if i := a.hot.index; i >= 0 && i < len(row.doors) { + return row.doors[i].hint + } + // A TASK'S ROW IN THE BAND SAYS WHAT ITS ROW IN THE LIST SAYS, read + // when the pointer is on it and not for every frame. + if row.hint == "" && row.act.kind == sideActOpen { + return a.sideTaskHint(a.tasks[row.act.id]) + } + return row.hint + case hoverRailGroup: + g := railGroup(a.hot.index) + if g >= railGroupCount { + return "" + } + if a.sideGroupShut(g) { + return "Show what is " + railGroupWords[g] + hintSegment + "click" + } + return "Fold what is " + railGroupWords[g] + hintSegment + "click" + case hoverRail: + return a.sideTaskHint(a.tasks[a.hot.id]) + case hoverRailGrip: + words := "Show this column" + hintSegment + a.chords.say(sideHideKey) + if t, kind, handle := a.sideTeam(); kind != sideKindPlain { + if _, fresh := a.sideTrafficCount(t, kind, handle); fresh > 0 { + words += hintSegment + itoa(fresh) + " new in the traffic" + } + } + return words + } + return "" +} + +// sideTaskHint is the hint line over a task's row, in the list or in the +// band: its whole title, then what the row had no room for (what it is doing, +// what it spent), then what a press does. +func (a *app) sideTaskHint(node *taskNode) string { + if node == nil { + return "" + } + words := strings.TrimSpace(node.label) + if words == "" { + words = node.title + } + for _, under := range a.railUnder(node, 400) { + if s := strings.TrimSpace(ansi.Strip(under)); s != "" { + words += hintSegment + s + } + } + return words + hintSegment + "click opens it" +} + +// sideBackHint is what the legend's hint slot says while the column is away: +// the key, and what it brings back. +func (a *app) sideBackHint() string { + if a.sideKind() == sideKindManager { + return a.chords.say(sideHideKey) + " traffic" + } + return a.chords.say(sideHideKey) + " tasks" +} diff --git a/internal/tui3/sidecol_test.go b/internal/tui3/sidecol_test.go new file mode 100644 index 0000000000..06880c384c --- /dev/null +++ b/internal/tui3/sidecol_test.go @@ -0,0 +1,310 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// sideDoorOf is the screen cell of the first door on the column's own rows +// that does act kind, failing the test when the column draws none. +func sideDoorOf(t *testing.T, a *app, kind int) (int, int) { + t.Helper() + view, _ := a.railDrawnView(a.viewHeight()) + for i, line := range view { + if line.side == nil { + continue + } + for _, d := range line.side.doors { + if d.act.kind == kind { + return a.railLeft() + ansi.StringWidth(railSeam) + d.span.from, a.topHeight() + i + } + } + } + t.Fatalf("the column draws no door that does act %d", kind) + return 0, 0 +} + +// sideRowOn is the screen cell of row key on the column, at a column of it no +// door covers, failing the test when the column does not draw it. +func sideRowOn(t *testing.T, a *app, key string) (int, int) { + t.Helper() + view, _ := a.railDrawnView(a.viewHeight()) + for i, line := range view { + if line.side == nil || line.side.key != key { + continue + } + for x := 0; x < a.railRoom(); x++ { + if line.side.doorAt(x) < 0 { + return a.railLeft() + ansi.StringWidth(railSeam) + x, a.topHeight() + i + } + } + } + t.Fatalf("the column does not draw row %q", key) + return 0, 0 +} + +// sideBandFixture is a plain chat with two tasks waiting on the person, three +// failures nobody has opened, one running task and one landed one. +func sideBandFixture(t *testing.T) *app { + t.Helper() + a, _, _ := roomApp(t) + for _, id := range []uint64{1, 2} { + a.taskUpdate(update(id, "Port the parser "+itoa(int(id)), session.TaskUnverified, + session.TaskNotice{Merge: mergeWordAborted, Branch: "task/p" + itoa(int(id))})) + } + // Each failure is seen running first, as live work is: a node whose first + // news is a failure is one a reopened conversation replayed. + for _, id := range []uint64{3, 4, 5} { + a.taskUpdate(update(id, "Cut the goldens "+itoa(int(id)), session.TaskRunning, session.TaskNotice{})) + a.taskUpdate(update(id, "Cut the goldens "+itoa(int(id)), session.TaskFailed, + session.TaskNotice{Ending: session.TaskEndingSteps})) + } + a.taskUpdate(update(6, "Fix the loader", session.TaskRunning, session.TaskNotice{})) + a.taskUpdate(update(7, "Read the law", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) + a.height = 30 + return a +} + +// sideDrawn is the column's own rows as the frame lays them: the key of each +// line that is one of them, "" for every other line, and the raw text. +func sideDrawn(a *app) ([]string, []string) { + view, _ := a.railDrawnView(a.viewHeight()) + raw := a.railRows(a.viewHeight()) + keys := make([]string, len(view)) + for i, line := range view { + if line.side != nil { + keys[i] = line.side.key + } + } + return keys, raw +} + +// THE BAND IS WHAT NEEDS THE PERSON, AMBER ONLY FOR WHAT IS BLOCKED ON THEM. +// Two tasks whose next step is the person's lead in amber, newest first; the +// failures follow with a ✗ in ordinary ink; three rows and then `+N more`; +// and nothing in the band is drawn again in the list under it. +func TestTheBandCarriesAsksInAmberAndFailuresInInk(t *testing.T) { + a := sideBandFixture(t) + keys, raw := sideDrawn(a) + var band []int + for i, k := range keys { + if k != "" && k != sideHeadKey { + band = append(band, i) + } + } + want := []string{"task/2", "task/1", "fail/5", "band/more"} + if len(band) != len(want) { + t.Fatalf("the band drew %v, want %v:\n%s", keys, want, strings.Join(railText(a, a.viewHeight()), "\n")) + } + for i, at := range band { + if keys[at] != want[i] { + t.Fatalf("band row %d is %q, want %q (all %v)", i, keys[at], want[i], keys) + } + } + if more := plain(raw[band[3]]); !strings.Contains(more, "+2 more") { + t.Fatalf("the band's last row is %q, want +2 more", more) + } + // THE PAINT. The palette's warn ink is on the asks and on nothing else. + warn := a.pal.ask("Q") + warn = warn[:strings.Index(warn, "Q")] + if warn == "" { + t.Fatal("the test palette paints no warn ink, so this test would prove nothing") + } + for i, at := range band[:3] { + amber := strings.Contains(raw[at], warn) + if ask := i < 2; amber != ask { + t.Fatalf("band row %q amber=%v, want %v:\n%q", keys[at], amber, ask, raw[at]) + } + } + if !strings.Contains(plain(raw[band[2]]), a.taskStateMark(a.tasks[5])+" Cut the goldens 5") { + t.Fatalf("the failure row is %q", plain(raw[band[2]])) + } + // A RULE CLOSES THE BAND, and the list starts under it. + if rule := plain(raw[band[3]+1]); !strings.Contains(rule, "────") { + t.Fatalf("no rule under the band: %q", rule) + } + // NOT REPEATED BELOW. + railOpenAll(a) + for _, e := range a.railEntries() { + if e.node != nil && e.node.id <= 5 { + t.Fatalf("band item %d is drawn again in the list", e.node.id) + } + } + // `+2 more` SHOWS THEM ALL, and `fewer` folds them back. + x, y := sideRowOn(t, a, "band/more") + railClick(t, a, x, y) + if n := len(a.sideBand()); n != 5 { + t.Fatalf("the band holds %d items", n) + } + sideRowOn(t, a, "fail/3") + if more := plain(strings.Join(railText(a, a.viewHeight()), "\n")); !strings.Contains(more, "fewer") { + t.Fatalf("the opened band offers no way back:\n%s", more) + } + x, y = sideRowOn(t, a, "band/more") + railClick(t, a, x, y) + if a.side.bandAll { + t.Fatal("`fewer` did not fold the band back") + } + // OPENING A FAILURE IS LOOKING AT IT: it leaves the band and joins the + // finished work. + x, y = sideRowOn(t, a, "fail/5") + railClick(t, a, x, y) + if !a.roomOpen() || a.room.id != 5 { + t.Fatalf("a press on the failure opened %d", roomID(a)) + } + for _, item := range a.sideBand() { + if item.key == "fail/5" { + t.Fatal("the failure the person opened is still in the band") + } + } + listed := false + for _, e := range a.railEntries() { + listed = listed || (e.node != nil && e.node.id == 5) + } + if !listed { + t.Fatal("the failure the person opened is not in the list") + } +} + +// FOUR ITEMS ARE FOUR ROWS. `+1 more` would spend the row it saves, so the +// band only counts what it cannot draw from the fifth item on. +func TestTheBandDrawsFourItemsRatherThanCountOne(t *testing.T) { + a := sideBandFixture(t) + a.side.acked = map[uint64]bool{3: true} + keys, _ := sideDrawn(a) + got := strings.Join(keys, " ") + for _, want := range []string{"task/2", "task/1", "fail/5", "fail/4"} { + if !strings.Contains(got, want) { + t.Fatalf("the band lost %q: %v", want, keys) + } + } + if strings.Contains(got, "band/more") { + t.Fatalf("four items were cut to three and a count: %v", keys) + } +} + +// NOTHING NEEDING THE PERSON DRAWS NOTHING: no band, no rule, no `none`. And +// a plain terminal gets the linear marks. +func TestAnEmptyBandIsGoneAndAPlainTerminalReadsItsMarks(t *testing.T) { + a, _, _ := taskApp(t) + a.taskUpdate(update(1, "Fix the loader", session.TaskRunning, session.TaskNotice{})) + rows := railText(a, 10) + if strings.TrimRight(rows[1], " ") != "│ Running 1" { + t.Fatalf("an empty band left something between the header and the list:\n%s", strings.Join(rows, "\n")) + } + for _, row := range rows { + for _, never := range []string{"none", "Needs you", "────"} { + if strings.Contains(row, never) { + t.Fatalf("an idle column drew %q:\n%s", never, strings.Join(rows, "\n")) + } + } + } + b := sideBandFixture(t) + b.linear = true + text := strings.Join(railText(b, b.viewHeight()), "\n") + for _, want := range []string{b.taskStateMark(b.tasks[2]) + " Port the parser 2", b.taskStateMark(b.tasks[5]) + " Cut the goldens 5", "----"} { + if !strings.Contains(text, want) { + t.Fatalf("the plain terminal's band is missing %q:\n%s", want, text) + } + } + if strings.Contains(text, "✗") || strings.Contains(text, "─") { + t.Fatalf("the plain terminal drew a glyph it cannot be trusted with:\n%s", text) + } +} + +// NOTHING IN THE COLUMN MOVES THE CONVERSATION OR THE HEADER. A band item +// arriving, a group folding, a row arriving, and in a team chat the other +// word coming to the front: the body keeps its width and the header its row. +func TestNothingInTheColumnMovesTheBodyOrTheHeader(t *testing.T) { + a, _, _ := taskApp(t) + railRun(a) + body := a.bodyWidth() + check := func(what string) { + t.Helper() + if a.bodyWidth() != body { + t.Fatalf("%s moved the conversation from %d to %d columns", what, body, a.bodyWidth()) + } + view, _ := a.railDrawnView(a.viewHeight()) + if len(view) == 0 || view[0].side == nil || view[0].side.key != sideHeadKey { + t.Fatalf("%s moved the header off the column's first row", what) + } + } + a.taskUpdate(update(8, "Cut the trailer", session.TaskRunning, session.TaskNotice{})) + a.taskUpdate(update(8, "Cut the trailer", session.TaskFailed, session.TaskNotice{Ending: session.TaskEndingSteps})) + check("a failure arriving in the band") + a.sideToggleGroup(railDone) + check("opening a group") + a.sideToggleGroup(railDone) + check("folding a group") + a.taskUpdate(update(9, "Port the loader", session.TaskRunning, session.TaskNotice{})) + check("a new row") + + m, _, _, _ := trafficApp(t) + m.width, m.height = 160, 40 + if m.sideKind() != sideKindManager { + t.Fatalf("the fixture's front chat is kind %d", m.sideKind()) + } + width := m.bodyWidth() + if m.railWidth() != sideColsFor(m.width) { + t.Fatalf("the manager's column is %d wide, want %d", m.railWidth(), sideColsFor(m.width)) + } + for _, view := range []int{sideTasks, sideTraffic, sideTasks} { + m.sideSetView(view) + if m.bodyWidth() != width || m.sideView() != view { + t.Fatalf("switching to view %d moved the conversation from %d to %d", view, width, m.bodyWidth()) + } + if v, _ := m.railDrawnView(m.viewHeight()); len(v) == 0 || v[0].side == nil || v[0].side.key != sideHeadKey { + t.Fatalf("switching to view %d moved the header", view) + } + } +} + +// THE HOVER GROUND IS THE CLICK TARGET. Every cell of a band row lights that +// row and a press on any of them opens its task; on the header, each word and +// the key light alone, and the air between them lights nothing and does +// nothing. +func TestTheHoverGroundIsTheClickTarget(t *testing.T) { + a := sideBandFixture(t) + _, y := sideRowOn(t, a, "task/2") + left := a.railLeft() + ansi.StringWidth(railSeam) + for col := 0; col < a.railRoom(); col++ { + a.setHover(left+col, y) + if a.hot.kind != hoverSide || a.hot.key != "task/2" || a.hot.index != -1 { + t.Fatalf("cell %d of the band row lit %+v", col, a.hot) + } + } + lit := a.railRows(a.viewHeight())[y-a.topHeight()] + if w := ansi.StringWidth(lit); w != ansi.StringWidth(railSeam)+a.railRoom() { + t.Fatalf("the hover ground is %d cells, want the whole row", w) + } + for _, col := range []int{0, a.railRoom() / 2, a.railRoom() - 1} { + a.closeRoom() + railClick(t, a, left+col, y) + if !a.roomOpen() || a.room.id != 2 { + t.Fatalf("a press on cell %d of the band row opened %d", col, roomID(a)) + } + } + a.closeRoom() + + // THE HEADER, cell by cell, against its own doors. + _, row := a.sideHeadRow(a.railRoom()) + hy := a.topHeight() + for col := 0; col < a.railRoom(); col++ { + a.setHover(left+col, hy) + door := row.doorAt(col) + switch { + case door >= 0 && (a.hot.kind != hoverSide || a.hot.key != sideHeadKey || a.hot.index != door): + t.Fatalf("header cell %d is door %d and lit %+v", col, door, a.hot) + case door < 0 && a.hot.kind == hoverSide: + t.Fatalf("header cell %d is no door and lit %+v", col, a.hot) + } + } + // A plain chat's one word is not a door: there is nothing to switch to. + if len(row.doors) != 1 || row.doors[0].act.kind != sideActHide { + t.Fatalf("a plain chat's header has doors %+v", row.doors) + } +} diff --git a/internal/tui3/sidetraffic.go b/internal/tui3/sidetraffic.go new file mode 100644 index 0000000000..242e66ca45 --- /dev/null +++ b/internal/tui3/sidetraffic.go @@ -0,0 +1,733 @@ +package tui3 + +import ( + "strings" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── THE TRAFFIC VIEW (sidecol.go says what the column is) ────────────────── +// +// One line a row, newest first, and a thin `new` line under what arrived +// since the person last looked. EVERY ROW READS `from → to words age`: who +// sent it, who it is for, then what it says, and how long ago at the right, +// dim (`2m`, `3h`, `1d`, `now`, the same ladder a task row uses). The +// manager is `◆`. Several recipients are the first handle and `+N`. In a +// member's chat that member is `you`. The arrow and the names keep their +// cells, then the age, and only the words are cut, at a word. +// +// ◆ → @security +2 parser numbers running ▸ 2m +// ↳ @review → ◆ ✓ 2 findings… 3m +// General 5 msgs ▸ 1d +// +// A press on ▸ lays the thread's replies open under it, one line each in the +// same `from → to`, and a second press folds them. A press on a handle opens +// that member at the message. A press anywhere else on a row opens the +// conversation the message belongs to, at that message (teamjump.go): one +// the sender wrote opens the sender's chat, and one put to the person opens +// the manager's. Already in front, it scrolls in place. Whatever answers +// nothing and is answered by nothing (a note, a start, a stop, an event) is +// chatter, and all of it is the one `General` thread. Laid open, its lines +// read `from → to` too. +// +// IN A MEMBER'S CHAT A ROW IS A MESSAGE, one of those involving that member, +// `◆ → you` for what it was told and `you → ◆` for what it said. A press on +// `you → ◆` scrolls this chat; a press on `◆ → you` opens the manager. +// +// WHAT THE BAND CARRIES IS NOT DRAWN AGAIN HERE: a member's question waiting +// on the person is the band's row, `? @model → ◆ …`, and its own row would +// say it twice. + +// sideTrafficCacheKey is everything the Traffic view's rows are drawn from. +type sideTrafficCacheKey struct { + team, handle, last, divider, hot, focus, front string + kind, rows, width, height, hotDoor, moved int + ascii, held bool + minute int64 +} + +// sideTrafficCache is the Traffic view's rows as last laid. +type sideTrafficCache struct { + key sideTrafficCacheKey + lines []railLine +} + +// sideThreadKey is a work thread's name in the column's record of what is +// laid open. +func sideThreadKey(teamID, root string) string { return teamID + "/" + root } + +// sideGeneral is the root the chatter thread is keyed by. +const sideGeneral = "general" + +// sideTrafficView is the Traffic view's rows, at most height, width the +// column's own. It snapshots where the `new` line stands the first time the +// Traffic comes into view, and records that the person has the newest entry +// in front of them. Frame-safe: memory only. +func (a *app) sideTrafficView(height int) ([]railLine, int) { + t, kind, handle := a.sideTeam() + if kind == sideKindPlain || height <= 0 { + return nil, -1 + } + if a.side.up != t.ID { + if a.side.divider == nil { + a.side.divider = map[string]string{} + } + a.side.divider[t.ID] = a.traffic.seen[t.ID] + a.side.up = t.ID + } + width := a.railRoom() + rows := a.traffic.rows[t.ID] + last := "" + if len(rows) > 0 { + last = rows[len(rows)-1].ID + } + hot, hotDoor := "", -1 + if a.hot.kind == hoverSide { + hot, hotDoor = a.hot.key, a.hot.index + } + focus := "" + if a.railHold { + focus = a.railWhere.key + } + key := sideTrafficCacheKey{ + team: t.ID, handle: handle, last: last, divider: a.side.divider[t.ID], hot: hot, focus: focus, front: a.frontTabKey(), + kind: kind, rows: len(rows), width: width, height: height, hotDoor: hotDoor, moved: a.side.moved, + ascii: a.pal.ascii, held: a.railHold, minute: a.now().Unix() / 60, + } + a.trafficMarkSeen(t) + if c := &a.side.traffic; c.lines != nil && c.key == key { + return c.lines, -1 + } + s := &sideSheet{a: a, t: t, width: width, hot: hot, hotDoor: hotDoor, divider: key.divider} + if kind == sideKindManager { + s.threads(kind, handle) + } else { + s.messages(handle) + } + lines := s.lines + if len(lines) > height { + lines = lines[:height] + } + a.side.traffic = sideTrafficCache{key: key, lines: lines} + return lines, -1 +} + +// sideSheet lays the Traffic view's rows one at a time. +type sideSheet struct { + a *app + t team + width int + hot string + hotDoor int + divider string + lines []railLine + // fresh says the rows laid so far are newer than the divider, and ruled + // that the `new` line is down. + fresh, ruled bool +} + +// seg is one piece of a row being laid: its words, how they are painted, and +// the door they are (-1 for none). flex is the row's words, the one piece a +// narrow column cuts, and it is cut at a word so the arrow and the names +// stay whole. +type sideSeg struct { + text string + paint func(string) string + door int + flex bool +} + +// newer draws the `new` line once, above the first row that is not newer +// than the divider, when rows above it were. +func (s *sideSheet) newer(id string) { + if s.ruled { + return + } + if id > s.divider && s.divider != "" { + s.fresh = true + return + } + if s.fresh { + word := " " + sideNewWord + " " + rule := s.a.linearMark("─", "-") + left := 2 + right := max(s.width-left-ansi.StringWidth(word), 0) + s.lines = append(s.lines, railLine{entry: -1, + text: s.a.pal.dim(strings.Repeat(rule, left)) + s.a.pal.muted(word) + s.a.pal.dim(strings.Repeat(rule, right))}) + } + s.ruled = true +} + +// sideHintWith is a row's hint with a fact the row gave up said in it, before +// the click the hint ends on. +func sideHintWith(hint, fact string) string { + if fact == "" { + return hint + } + if at := strings.LastIndex(hint, hintSegment+"click"); at >= 0 { + return hint[:at] + hintSegment + fact + hint[at:] + } + if hint == "" { + return fact + } + return hint + hintSegment + fact +} + +// fitAtWord cuts words to width at a word boundary, with tail where they do +// not fit. A first word longer than the room is cut where it lands, because +// there is no boundary to stop at. +func fitAtWord(words string, width int, tail string) string { + if width <= 0 { + return "" + } + if ansi.StringWidth(words) <= width { + return words + } + tw := ansi.StringWidth(tail) + if tw >= width { + return ansi.Truncate(tail, width, "") + } + head := ansi.Truncate(words, width-tw, "") + // A CUT THAT LANDS INSIDE A WORD steps back to the space before it. When + // the first word itself does not fit, the row says there is more and does + // not show half a word. + if len(head) < len(words) && (len(head) == 0 || !strings.HasPrefix(words[len(head):], " ")) { + if at := strings.LastIndex(head, " "); at > 0 { + head = strings.TrimRight(head[:at], " ") + } else { + return tail + } + } + head = strings.TrimRight(head, " ") + if head == "" { + return tail + } + return head + tail +} + +// add lays one row: the segments from the left, the words cut at a word where +// they run out of room, and the age at the right, dim. The arrow and the +// names keep their cells, then the age, and only the words are cut. A door +// keeps the columns its words ended up in. The age is not a door: a press on +// it is a press on the row. +func (s *sideSheet) add(row *sideRow, segs []sideSeg, right []sideSeg, age string) { + pal := s.a.pal + ageText := "" + ageW := 0 + if age != "" { + ageText = " " + age + ageW = ansi.StringWidth(ageText) + } + // NAMES OUTRANK THE AGE. When the address alone fills the column, the age + // is the cell that goes, and the hint still says it. + fixedLeft := 0 + for _, seg := range segs { + if !seg.flex { + fixedLeft += ansi.StringWidth(seg.text) + } + } + if fixedLeft+ageW > s.width { + ageText, ageW = "", 0 + } + room := s.width - ageW + rightW := 0 + for _, seg := range right { + rightW += ansi.StringWidth(seg.text) + } + // THE STATE AT THE RIGHT GIVES WAY BEFORE THE WORDS DO, when the column + // cannot hold both and a dozen cells of what the row is about (or all of + // it, when it is shorter). A door on the right, a thread's ▸, is kept: it + // is the one way to the replies. + need := 0 + for _, seg := range segs { + need += ansi.StringWidth(seg.text) + } + need = min(need, 20) + for rightW > 0 && room-rightW < need { + // The count goes first and the state after it: the last words drawn + // are the first given up. + drop := -1 + for i, seg := range right { + if seg.door < 0 && strings.TrimSpace(seg.text) != "" { + drop = i + } + } + if drop < 0 { + break + } + rightW -= ansi.StringWidth(right[drop].text) + right = append(right[:drop:drop], right[drop+1:]...) + } + left := room - rightW + // THE WORDS ARE THE ONLY SEGMENT THAT SHRINKS, and they shrink at a word. + // The arrow and the names were laid as fixed segments so a narrow column + // cuts `Please provide a st…` and never `Pleas…` through a name. + fixed := 0 + for _, seg := range segs { + if !seg.flex { + fixed += ansi.StringWidth(seg.text) + } + } + for i := range segs { + if !segs[i].flex { + continue + } + segs[i].text = fitAtWord(segs[i].text, max(left-fixed, 0), s.a.linearMark("…", "~")) + } + var b strings.Builder + used := 0 + spans := make([]hudSpan, len(row.doors)) + paint := func(seg sideSeg, text string, w int) { + painted := text + switch { + case seg.door >= 0 && row.key == s.hot && seg.door == s.hotDoor: + painted = teamLinkHotInk(pal, text) + case seg.door >= 0 && row.doors[seg.door].act.kind == sideActJump && row.doors[seg.door].act.key != "": + painted = teamLinkInk(pal, text) + case seg.paint != nil: + painted = seg.paint(text) + } + if seg.door >= 0 && seg.door < len(spans) { + spans[seg.door] = hudSpan{from: used, to: used + w} + } + b.WriteString(painted) + used += w + } + for _, seg := range segs { + if used >= left { + break + } + text := seg.text + w := ansi.StringWidth(text) + if used+w > left { + text = ansi.Truncate(text, left-used, s.a.linearMark("…", "~")) + w = ansi.StringWidth(text) + } + paint(seg, text, w) + } + if pad := left - used; pad > 0 { + b.WriteString(strings.Repeat(" ", pad)) + used += pad + } + for _, seg := range right { + paint(seg, seg.text, ansi.StringWidth(seg.text)) + } + if ageW > 0 { + b.WriteString(pal.dim(ageText)) + used += ageW + } + for i := range row.doors { + row.doors[i].span = spans[i] + } + s.lines = append(s.lines, railLine{text: b.String(), entry: -1, side: row}) +} + +// handle is a member's handle as a door that opens it at entry, or plain +// muted words when the handle is nobody's in the team or is the chat in +// front. +func (s *sideSheet) handle(row *sideRow, h, entry string) sideSeg { + word := "@" + strings.TrimPrefix(h, "@") + if ansi.StringWidth(word) > trafficHandleCap { + word = ansi.Truncate(word, trafficHandleCap, s.a.linearMark("…", "~")) + } + if m, ok := s.t.ByHandle(strings.TrimPrefix(h, "@")); ok && m.Key != s.a.frontTabKey() { + hint := strings.Replace(s.a.teamMemberHint(m), " @"+m.Handle, " @"+m.Handle+" at this message", 1) + row.doors = append(row.doors, sideDoor{hint: hint, act: sideAct{kind: sideActJump, key: m.Key, entry: entry}}) + return sideSeg{text: word, door: len(row.doors) - 1} + } + return sideSeg{text: word, paint: s.a.pal.muted, door: -1} +} + +// arrow is the dim ` → ` between who a row is from and who it is for. +func (s *sideSheet) arrow() sideSeg { + return sideSeg{text: " " + s.a.linearMark("→", "->") + " ", paint: s.a.pal.dim, door: -1} +} + +// party is one end of `from → to`: the manager's mark, this member as `you` +// when self is that handle, a word for everyone, or a handle that opens the +// member at entry. +func (s *sideSheet) party(row *sideRow, who, entry, self string) sideSeg { + if self != "" && (who == self || who == "@"+self) { + return sideSeg{text: "you", paint: s.a.pal.muted, door: -1} + } + switch who { + case teamstore.FromManager: + return sideSeg{text: s.a.teamManagerMark(), paint: s.a.pal.accent, door: -1} + case teamstore.FromSystem: + return sideSeg{text: "codeaf", paint: s.a.pal.dim, door: -1} + case teamstore.FromYou: + return sideSeg{text: "you", paint: s.a.pal.muted, door: -1} + case teamstore.ToEveryone: + return sideSeg{text: "all", paint: s.a.pal.muted, door: -1} + case teamstore.ToRoom: + return sideSeg{text: "room", paint: s.a.pal.muted, door: -1} + case "": + return sideSeg{text: "", door: -1} + } + return s.handle(row, who, entry) +} + +// route is `from → to` for one entry. named is the member handles it went to, +// and the first of them is drawn with `+N` for the rest. to is the address +// when named is empty (the manager, everyone, one handle). self is this +// member's handle in a member's chat, drawn as `you`. +func (s *sideSheet) route(row *sideRow, from, entry, self string, named []string, to string) []sideSeg { + segs := []sideSeg{s.party(row, from, entry, self), s.arrow()} + if len(named) > 0 { + segs = append(segs, s.party(row, named[0], entry, self)) + if len(named) > 1 { + segs = append(segs, sideSeg{text: " +" + itoa(len(named)-1), paint: s.a.pal.dim, door: -1}) + } + return segs + } + segs = append(segs, s.party(row, to, entry, self)) + return segs +} + +// words is an entry's words on one line, what a row says about it. +func sideWords(e teamstore.Entry) string { + text := strings.Join(strings.Fields(e.Text), " ") + if teamstore.IsRuling(e) { + text = trafficRulingText(text) + } + if text == "" { + text = e.State + } + return text +} + +// says is what a row says about an entry: its words, and for a start or a +// stop what was done to whom first, `started @lexer to run orbit · rewrite +// the lexer`, `stopped @web · stuck in a retry loop`, because a start's words +// are its brief and a stop's are its reason and neither says the act. +func (s *sideSheet) says(e teamstore.Entry) string { + words := sideWords(e) + var act string + switch e.Kind { + case teamstore.KindStart: + act = "started " + s.a.trafficAddr(e.To) + // A START THAT NAMES A TEAM made a sub-team for the started + // conversation to run (DESIGN.md 8.10). + if e.Team != "" { + name := e.Team + if sub, ok := s.a.teamByID(e.Team); ok { + name = sub.Name + } + act += " to run " + name + } + case teamstore.KindStop: + act = "stopped " + s.a.trafficAddr(e.To) + default: + return words + } + if words == "" || words == e.State { + return act + } + return act + " · " + words +} + +// jumpHint is the hint a press on the row says: whose message, how long ago, +// then any fact the row itself gave up (its state, the words that were cut). +func (s *sideSheet) jumpHint(from, self, age, extra string) string { + return trafficOpenHint(s.a.trafficSenderWord(from, self), age, extra) +} + +// ── A MANAGER'S WORK ──────────────────────────────────────────────────────── + +// sideWork is a thread as the manager's Traffic draws it, and chatter the +// entries that are a thread of their own and nobody's work. +type sideWork struct { + thread teamstore.Thread + last teamstore.Entry +} + +// sideChatter reports whether a thread is chatter: one entry, answering +// nothing and answered by nothing, that is not a message somebody was asked +// to act on. +func sideChatter(th teamstore.Thread) bool { + if len(th.Replies) > 0 { + return false + } + switch th.Root.Kind { + case teamstore.KindDirective, teamstore.KindQuestion: + return false + } + return !teamstore.IsRuling(th.Root) +} + +// sideLast is the newest entry of a thread. +func sideLast(th teamstore.Thread) teamstore.Entry { + last := th.Root + for _, r := range th.Replies { + if r.ID > last.ID { + last = r + } + } + return last +} + +// threads lays a manager's Traffic: its work threads, newest activity first, +// and one General thread for the chatter, where its newest entry falls among +// them. +func (s *sideSheet) threads(kind int, handle string) { + all := s.a.trafficThreads(s.t) + var chatter []teamstore.Entry + var newest teamstore.Entry + for _, th := range all { + if !sideChatter(th) || s.a.sideAsked(s.t, kind, handle, th.Root.ID) { + continue + } + chatter = append(chatter, th.Root) + if th.Root.ID > newest.ID { + newest = th.Root + } + } + laid := len(chatter) == 0 + for _, th := range all { + if sideChatter(th) { + continue + } + last := sideLast(th) + if !laid && newest.ID > last.ID { + s.general(chatter, newest) + laid = true + } + s.work(th, last) + } + if !laid { + s.general(chatter, newest) + } +} + +// work lays one work thread: its row, and its replies under it when laid +// open. +func (s *sideSheet) work(th teamstore.Thread, last teamstore.Entry) { + pal := s.a.pal + e := th.Root + s.newer(last.ID) + key := sideThreadKey(s.t.ID, e.ID) + open := s.a.side.threads[key] + lines := replyLines(th) + age := s.a.trafficAge(last) + row := &sideRow{key: "thread/" + e.ID, + act: sideAct{kind: sideActJump, key: s.a.trafficBelongsTo(s.t, e), entry: e.ID}} + // EVERY WORK ROW READS `from → to`: the manager's mark to the members it + // asked, or the member that wrote it back to the manager. + named := e.Recipients() + segs := s.route(row, e.From, e.ID, "", named, e.To) + title := s.says(e) + if teamstore.IsRuling(e) { + title = "ruling · " + title + } + segs = append(segs, sideSeg{text: " ", door: -1}, sideSeg{text: title, paint: pal.muted, door: -1, flex: true}) + // THE STATE ITS ANSWERS LEAVE IT IN, and how many messages it holds. + state := sideThreadState(lines) + // A MESSAGE IS WORDS SOMEBODY WROTE: a wake or a finishing is an event + // the state already says, not a message. + msgs := 1 + for _, r := range lines { + if r.said { + msgs++ + } + } + var right []sideSeg + words := state + if state != "" { + right = append(right, sideSeg{text: " " + state, paint: pal.dim, door: -1}) + } + if msgs > 1 { + count := itoa(msgs) + " msgs" + sep := " " + if words != "" { + words += " · " + sep = " · " + } + words += count + right = append(right, sideSeg{text: sep + count, paint: pal.dim, door: -1}) + } + if len(th.Replies) > 0 { + glyph := s.a.linearMark(glyphShut, glyphShutASCII) + hint := "Show the replies" + hintSegment + "click" + if open { + glyph = s.a.linearMark(glyphOpen, glyphOpenASCII) + hint = "Fold the replies" + hintSegment + "click" + } + row.doors = append(row.doors, sideDoor{hint: hint, act: sideAct{kind: sideActThread, key: key}}) + right = append(right, sideSeg{text: " ", door: -1}, sideSeg{text: glyph, paint: pal.muted, door: len(row.doors) - 1}) + } + // THE HINT SAYS THE STATE TOO, because the row gives it up first when + // the column is narrow. A RULING'S HINT NAMES THE CONFLICT IT DECIDED + // (DESIGN.md 8.10). + extra := title + if words != "" { + extra += hintSegment + words + } + if teamstore.IsRuling(e) && e.Packet != "" { + extra += hintSegment + "the ruling on conflict " + e.Packet + } + row.hint = s.jumpHint(e.From, "", age, extra) + s.add(row, segs, right, age) + if !open { + return + } + for _, r := range lines { + s.member(r) + } +} + +// member lays one member's line under an open thread, with its events folded +// into it the way replyLines folds them: `↳ @review → ◆ ✓ 2 findings`, or +// `working…` for a member woken on the thread with nothing said yet. A wake or +// a finishing is never a line of its own. The age sits at the right, the same +// ladder as the thread above it. +func (s *sideSheet) member(r trafficReply) { + pal := s.a.pal + e := r.last + if r.said { + e = r.entry + } + age := s.a.trafficAge(e) + row := &sideRow{key: "reply/" + e.ID, act: sideAct{kind: sideActJump, key: s.a.trafficBelongsTo(s.t, e), entry: e.ID}} + segs := []sideSeg{{text: " " + s.a.linearMark("↳", "->") + " ", paint: pal.dim, door: -1}} + // A MEMBER'S LINE RUNS BACK TO THE MANAGER. A line the manager, the + // person or codeaf wrote runs the other way, to whoever it names. + to := teamstore.FromManager + if r.who == teamstore.FromManager || r.who == teamstore.FromSystem || r.who == teamstore.FromYou { + to = e.To + } + segs = append(segs, s.route(row, r.who, e.ID, "", nil, to)...) + words := r.note + if r.said { + words = s.says(r.entry) + } + switch r.state { + case teamstore.StateFinished: + words = s.a.linearMark(s.a.icon(tokens.GSettled), "ok") + " " + words + case teamstore.StateFailed: + words = s.a.linearMark(s.a.icon(tokens.GFailed), "x") + " " + words + case teamstore.StateAsking: + words = "asking: " + strings.TrimSpace(strings.TrimPrefix(words, "asks:")) + case "working": + words = "working" + s.a.linearMark("…", "...") + } + segs = append(segs, sideSeg{text: " ", door: -1}, sideSeg{text: words, paint: pal.muted, door: -1, flex: true}) + row.hint = s.jumpHint(r.who, "", age, words) + s.add(row, segs, nil, age) +} + +// sideThreadState is the one word a thread's answers leave it in: someone +// asking, someone still working, a failure, all finished, or answered. +func sideThreadState(lines []trafficReply) string { + if len(lines) == 0 { + return "sent" + } + // EACH MEMBER'S LAST LINE IS WHERE IT STANDS. replyLines starts a new line + // for a member when an event follows a finished one, so a member that asked + // and then failed has both lines, and only the later one is still true. + last := make(map[string]int, len(lines)) + for i, r := range lines { + last[r.who] = i + } + working, failed, finished, members := false, false, 0, 0 + for i, r := range lines { + if last[r.who] != i { + continue + } + members++ + switch r.state { + case teamstore.StateAsking: + return "asking" + case "working": + working = true + case teamstore.StateFailed: + failed = true + case teamstore.StateFinished: + finished++ + } + } + switch { + case working: + return "running" + case failed: + return "failed" + case finished == members: + return "done" + } + return "answered" +} + +// reply lays one chatter line under General: `↳ ◆ → @price an older aside 2m`. +func (s *sideSheet) reply(e teamstore.Entry) { + pal := s.a.pal + age := s.a.trafficAge(e) + row := &sideRow{key: "reply/" + e.ID, act: sideAct{kind: sideActJump, key: s.a.trafficBelongsTo(s.t, e), entry: e.ID}} + segs := []sideSeg{{text: " " + s.a.linearMark("↳", "->") + " ", paint: pal.dim, door: -1}} + segs = append(segs, s.route(row, e.From, e.ID, "", e.Recipients(), e.To)...) + words := s.says(e) + segs = append(segs, sideSeg{text: " ", door: -1}, sideSeg{text: words, paint: pal.muted, door: -1, flex: true}) + row.hint = s.jumpHint(e.From, "", age, words) + s.add(row, segs, nil, age) +} + +// general lays the chatter as one thread, `General`, and its entries under +// it when laid open, newest first. +func (s *sideSheet) general(chatter []teamstore.Entry, newest teamstore.Entry) { + pal := s.a.pal + s.newer(newest.ID) + key := sideThreadKey(s.t.ID, sideGeneral) + open := s.a.side.threads[key] + row := &sideRow{key: key, act: sideAct{kind: sideActThread, key: key}, + hint: "Everything that is nobody's work" + hintSegment + "click shows it"} + if open { + row.hint = "Everything that is nobody's work" + hintSegment + "click folds it" + } + glyph := s.a.linearMark(glyphShut, glyphShutASCII) + if open { + glyph = s.a.linearMark(glyphOpen, glyphOpenASCII) + } + row.doors = append(row.doors, sideDoor{hint: row.hint, act: row.act}) + right := []sideSeg{{text: " " + itoa(len(chatter)) + " " + plural("msg", len(chatter)) + " ", paint: pal.dim, door: -1}, {text: glyph, paint: pal.muted, door: 0}} + s.add(row, []sideSeg{{text: "General", paint: pal.muted, door: -1}}, right, s.a.trafficAge(newest)) + if !open { + return + } + for _, e := range chatter { + s.reply(e) + } +} + +// ── A MEMBER'S MESSAGES ───────────────────────────────────────────────────── + +// messages lays a member's Traffic: every drawn message involving it, newest +// first, one line each. +func (s *sideSheet) messages(handle string) { + rows := s.a.traffic.rows[s.t.ID] + for i := len(rows) - 1; i >= 0; i-- { + e := rows[i] + if !trafficShown(e) || e.Wake() || !sideInvolves(e, handle) { + continue + } + if s.a.sideAsked(s.t, sideKindMember, handle, e.ID) { + continue + } + s.newer(e.ID) + age := s.a.trafficAge(e) + row := &sideRow{key: "msg/" + e.ID, act: sideAct{kind: sideActJump, key: s.a.trafficBelongsTo(s.t, e), entry: e.ID}} + // THIS MEMBER IS `you`. What it was told reads `◆ → you`, what it + // said reads `you → ◆` or `you → @other`. + segs := s.route(row, e.From, e.ID, handle, e.Recipients(), e.To) + words := s.says(e) + switch { + case e.State == teamstore.StateFinished: + words = s.a.linearMark(s.a.icon(tokens.GSettled), "ok") + " " + words + case e.State == teamstore.StateFailed: + words = s.a.linearMark(s.a.icon(tokens.GFailed), "x") + " " + words + } + segs = append(segs, sideSeg{text: " ", door: -1}, sideSeg{text: words, paint: s.a.pal.muted, door: -1, flex: true}) + row.hint = s.jumpHint(e.From, handle, age, words) + s.add(row, segs, nil, age) + } +} diff --git a/internal/tui3/sidetraffic_test.go b/internal/tui3/sidetraffic_test.go new file mode 100644 index 0000000000..bb6c675087 --- /dev/null +++ b/internal/tui3/sidetraffic_test.go @@ -0,0 +1,268 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// WHAT CAME IN WHILE THE TASKS WERE IN FRONT IS COUNTED ON THE OTHER WORD, +// `Traffic 2 new`, and when the Traffic comes to the front a thin `new` line +// stands under it and over what was already seen. The line holds still while +// the Traffic is read, a row arriving moves neither the header nor the body, +// and once looked at the word counts everything again. +func TestTheTrafficSaysWhatIsNewAndHoldsStill(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.welcome.open = false + price, _ := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "old work"}) + trafficReadNow(t, a) + _ = railLines(t, a) // the Traffic in front: the old work is seen + a.sideSetView(sideTasks) + body, cols := a.bodyWidth(), a.railWidth() + head := railRowOf(railLines(t, a), sideTasksWord) + + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: rail, Text: "first new work"}, + teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "second new work"}, + ) + trafficReadNow(t, a) + rows := railLines(t, a) + if railRowOf(rows, sideTrafficWord+" 2 "+sideNewWord) != head || a.bodyWidth() != body || a.railWidth() != cols { + t.Fatalf("the other word does not count what is new in place (body %d, cols %d):\n%s", a.bodyWidth(), a.railWidth(), strings.Join(rows, "\n")) + } + + a.sideSetView(sideTraffic) + rows = railLines(t, a) + joined := strings.Join(rows, "\n") + second, first := railRowOf(rows, "second new work"), railRowOf(rows, "first new work") + line, old := railRowOf(rows, "── "+sideNewWord+" ──"), railRowOf(rows, "old work") + if railRowOf(rows, sideTrafficWord) != head || second != head+1 || first != second+1 || line != first+1 || old != line+1 { + t.Fatalf("the new line does not stand between the new and the seen (%d %d %d %d):\n%s", second, first, line, old, joined) + } + if strings.Contains(rows[head], sideNewWord) { + t.Fatalf("the word still says new with the Traffic in front: %q", rows[head]) + } + + // A ROW ARRIVING WHILE IT IS READ goes on top; the line and the header + // hold, and the body does not move. + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: rail, Text: "third new work"}) + trafficReadNow(t, a) + rows = railLines(t, a) + if railRowOf(rows, "third new work") != head+1 || railRowOf(rows, "── "+sideNewWord+" ──") != line+1 || railRowOf(rows, sideTrafficWord) != head || a.bodyWidth() != body { + t.Fatalf("a row arriving moved the line or the header:\n%s", strings.Join(rows, "\n")) + } + + // AND LOOKED AT, IT IS SEEN: away and back, no line. + a.sideSetView(sideTasks) + a.sideSetView(sideTraffic) + if rows := railLines(t, a); railRowOf(rows, "── "+sideNewWord+" ──") >= 0 { + t.Fatalf("the line stayed over what was read:\n%s", strings.Join(rows, "\n")) + } +} + +// IN A MEMBER'S CHAT THE TRAFFIC IS THAT MEMBER'S MESSAGES, newest first, one +// line each: what it said is `→ whom`, what it was told is who told it, and +// what went between two other members is not there. The count on the word is +// the same set. +func TestAMembersTrafficIsItsOwnMessages(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "scrape the prices"}, + teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: rail, Text: "not for price"}, + teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "prices are in"}, + teamstore.Entry{Kind: teamstore.KindNote, From: teamstore.FromManager, To: teamstore.ToEveryone, Text: "all hands"}, + ) + trafficReadNow(t, a) + spend(t, a, a.trafficGo(priceKey)) + a.sideSetView(sideTraffic) + rows := railLines(t, a) + joined := strings.Join(rows, "\n") + all := railRowOf(rows, "all hands") + said := railRowOf(rows, "prices are in") + told := railRowOf(rows, "scrape the prices") + if all < 0 || said != all+1 || told != said+1 { + t.Fatalf("the member's messages are not newest first, one line each (%d %d %d):\n%s", all, said, told, joined) + } + if !strings.Contains(rows[said], "you → "+teamManagerGlyph) || !strings.Contains(rows[told], teamManagerGlyph+" → you") { + t.Fatalf("a row does not say who it is from and who it is for:\n%s", joined) + } + if strings.Contains(joined, "not for price") { + t.Fatalf("a message between others is in the member's Traffic:\n%s", joined) + } + if n, _ := a.sideTrafficCount(mustTeam(t, a, harbor), sideKindMember, price); n != 3 { + t.Fatalf("the word counts %d, want the member's 3", n) + } + // A PRESS ON A ROW GOES TO ITS MESSAGE HERE, and nowhere else. + x, y := sideRowOn(t, a, railKeyOfReply(t, a, "prices are in")) + sideClick(t, a, x, y) + if a.frontTabKey() != priceKey { + t.Fatalf("a press on the member's own row left its chat for %q", a.frontTabKey()) + } +} + +// THE GROUND THE POINTER LIGHTS IS THE TARGET THE PRESS HITS. On every row the +// Traffic draws, laid open and not, the hover at a cell names the row, or the +// door, that a press at the same cell acts on; the whole row lights for a +// row, and lighting moves no word of it. +func TestTheTrafficsHoverGroundIsItsClickTarget(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + price, _ := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q := threadScenario(t, a, harbor, price, rail) + a.sideToggleThread(sideThreadKey(harbor, q)) + a.sideToggleThread(sideThreadKey(harbor, sideGeneral)) + _ = railLines(t, a) + view, _ := a.railDrawnView(a.viewHeight()) + left := a.railLeft() + ansi.StringWidth(railSeam) + checked := 0 + for i, line := range view { + if line.side == nil || line.side.key == sideHeadKey { + continue + } + y := a.topHeight() + i + for col := 0; col < a.railRoom(); col++ { + a.setHover(left+col, y) + door := line.side.doorAt(col) + switch { + case door >= 0: + if a.hot.kind != hoverSide || a.hot.key != line.side.key || a.hot.index != door { + t.Fatalf("row %q col %d: the pointer lit %+v, the press hits door %d", line.side.key, col, a.hot, door) + } + case line.side.pressable(): + if a.hot.kind != hoverSide || a.hot.key != line.side.key || a.hot.index != -1 { + t.Fatalf("row %q col %d: the pointer lit %+v, the press hits the row", line.side.key, col, a.hot) + } + default: + if a.hot.kind == hoverSide { + t.Fatalf("row %q col %d lights with nothing to press", line.side.key, col) + } + } + checked++ + } + // THE WHOLE ROW LIGHTS, and the words under the light are the words. + if line.side.pressable() { + x, _ := sideRowOn(t, a, line.side.key) + a.dropHover() + before := a.railRows(a.viewHeight()) + a.setHover(x, y) + after := a.railRows(a.viewHeight()) + y0 := y - a.topHeight() + if before[y0] == after[y0] || ansi.Strip(before[y0]) != ansi.Strip(after[y0]) { + t.Fatalf("row %q: the hover did not light it, or moved its words:\n%q\n%q", line.side.key, before[y0], after[y0]) + } + } + } + if checked == 0 { + t.Fatal("the Traffic drew no row to point at") + } + a.dropHover() +} + +// rowEndsWithAge reports that a Traffic row keeps its age at the right: +// `now`, `2m`, `3h`, `1d`. +func rowEndsWithAge(row string) bool { + row = strings.TrimRight(row, " ") + if strings.HasSuffix(row, "now") { + return true + } + if len(row) < 2 { + return false + } + unit := row[len(row)-1] + if (unit == 'm' || unit == 'h' || unit == 'd' || unit == 's') && row[len(row)-2] >= '0' && row[len(row)-2] <= '9' { + return true + } + return false +} + +// rowKeepsTheArrow reports that a Traffic row still says who it is from and +// who it is for, cuts its words at a word, and keeps its age. full is the +// words the row was cut from. +func rowKeepsTheArrow(row, full string) bool { + row = strings.TrimRight(row, " ") + if !strings.Contains(row, "→") || !rowEndsWithAge(row) { + return false + } + // A cut through a word of full leaves a prefix of that word and the + // ellipsis, with the rest of the word missing. + for _, w := range strings.Fields(full) { + if len(w) < 4 { + continue + } + for n := 2; n < len(w); n++ { + frag := w[:n] + "…" + if strings.Contains(row, frag) && !strings.Contains(row, w) { + return false + } + } + } + return true +} + +// EVERY WIDTH DRAWS `from → to` AND CUTS ONLY THE WORDS. At a column of 28, +// 32 and 40 the arrow and the names stay, the age stays at the right, and the +// words stop at a word. The same is true of a member's own rows. +func TestTrafficRowsKeepTheArrowAtEveryWidth(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q := threadScenario(t, a, harbor, price, rail) + full := "Please provide a brief status update on your part" + for _, width := range []int{112, 128, 160} { + a.width, a.height = width, 40 + a.touch() + if got := a.railWidth(); got != sideColsFor(width) || (got != 28 && got != 32 && got != 40) { + t.Fatalf("width %d lends column %d, want 28, 32 or 40", width, got) + } + rows := railLines(t, a) + at := railRowOf(rows, "@"+price+" +2") + if at < 0 || !strings.Contains(rows[at], teamManagerGlyph+" → ") || !rowKeepsTheArrow(rows[at], full) { + t.Fatalf("at column %d the work row lost its arrow or cut a word:\n%s", a.railWidth(), strings.Join(rows, "\n")) + } + hint := a.sideRowOf("thread/" + q).hint + if !strings.Contains(hint, "Open ") || !strings.Contains(hint, hintSegment+"now"+hintSegment) || !strings.Contains(hint, hintSegment+"click") { + t.Fatalf("at column %d the hint does not open the message at its age: %q", a.railWidth(), hint) + } + } + spend(t, a, a.trafficGo(priceKey)) + a.sideSetView(sideTraffic) + for _, width := range []int{112, 128, 160} { + a.width, a.height = width, 40 + a.touch() + rows := railLines(t, a) + told := railRowOf(rows, teamManagerGlyph+" → you") + if told < 0 || !rowKeepsTheArrow(rows[told], full) { + t.Fatalf("at column %d a member row is not `from → you`:\n%s", a.railWidth(), strings.Join(rows, "\n")) + } + if hint := a.sideRowOf(railKeyOfReply(t, a, teamManagerGlyph+" → you")).hint; !strings.Contains(hint, "Open ") || !strings.Contains(hint, "now") { + t.Fatalf("at column %d the member row's hint does not open the message: %q", a.railWidth(), hint) + } + } +} + +// A CUT NEVER LEAVES A CLAUSE ITS SEPARATOR AND NOTHING ELSE. +func TestABandRowIsCutAtAClause(t *testing.T) { + for _, c := range []struct { + words string + width int + want string + }{ + {"Ship the price table · your call", 24, "Ship the price table…"}, + {"Ship the price table · your call", 29, "Ship the price table · your…"}, + {"Ship the price table", 30, "Ship the price table"}, + } { + if got, w := fitClauses(c.words, c.width, "…"); got != c.want || w > c.width { + t.Fatalf("%q at %d is %q, want %q", c.words, c.width, got, c.want) + } + } +} diff --git a/internal/tui3/standing.go b/internal/tui3/standing.go index 58ff0aa87b..0e91191dad 100644 --- a/internal/tui3/standing.go +++ b/internal/tui3/standing.go @@ -131,17 +131,20 @@ const ( // their first card said, in as many words, that they did not understand the // options. So the words say what will HAPPEN: it gets set up, you change // something about it, it happens once, or nothing does. - standYesWord = "yes, set it up" - standChangeWord = "change when or where" - standOnceWord = "just once" + // These are the repeating check's words with no cadence in hand. A real card + // reads [session.StandingOptions], which puts the cadence on the yes and + // says a different sentence for a reminder, a watch or a rule. + standYesWord = "Set it up" + standChangeWord = "Change…" + standOnceWord = "Only now, don't repeat" // standNoWordChip is the way out, ON the card. It used to be `esc` and a `0` - // named in the hint slot under the message box and nowhere else — a decline - // a person had to already know about, which is the one trade + // named in the hint slot under the message box and nowhere else. A decline + // a person had to already know about is the one trade // docs/DESIGN-LANGUAGE.md refuses by name: every chord keeps a visible, // clickable door beside it. So the decline is a chip like the others, under // [session.StandingNoKey], and it is the chip that is never dropped for want // of room ([app.pickRow]). - standNoWordChip = "no" + standNoWordChip = "Don't set it up" // The two band labels. They are lower-case nouns and not headings: this is // a card in a conversation, and a card with a heading on every row is a form. @@ -179,10 +182,10 @@ const ( // bands two rows above are for. Under a card that draws both, that sentence // was the two-renderings defect one size smaller. What no band can say is how // LONG each answer lasts, so that is what is left. - standYesCost = "it keeps happening until you stop it" - standOnceCost = "it happens now, and nothing is kept" - standNoCost = "nothing happens, now or later" - standChangeCost = "say the time or the place you want instead" + standYesCost = "It repeats on that cadence until you stop it." + standOnceCost = "Runs the check one time now. Nothing repeats." + standNoCost = "Nothing is set up, and nothing runs." + standChangeCost = "Say a different time or place. Nothing is set up yet." ) // The glyphs a standing row wears, and their stand-ins on a terminal that @@ -550,10 +553,11 @@ func (a *app) standingQuestion(card *standingCard, notice session.StandingNotice // this" rather than "there are no answers". options = session.StandingOptions(card.item) } - dressed := make([]session.AnswerOption, 0, len(options)) - for _, option := range options { - option.Label, option.Consequence = standAnswerWord(option.Key), standAnswerCost(option.Key) - dressed = append(dressed, option) + // THE WORDS ARE THE ENGINE'S. This surface draws them and does not respell + // them: another window, and the record of what was pressed, read the same + // list. A notice that arrived without them is filled from the item. + if options[0].Label == "" || options[0].Consequence == "" { + options = session.StandingOptions(card.item) } return session.Question{ ID: card.id, @@ -561,53 +565,30 @@ func (a *app) standingQuestion(card *standingCard, notice session.StandingNotice Ask: session.AskChoice, Form: session.FormCard, Asker: session.Asker{Kind: session.AskerModel}, - Head: session.StandingAskLead + strings.TrimSpace(card.item.Words), + Head: session.StandingHead(card.item), Reason: session.StandingAskReason, Subject: session.SubjectRef{Kind: session.SubjectOrder, ID: card.id, Name: strings.TrimSpace(card.item.Words)}, - Options: dressed, + Options: options, Stakes: session.StakesReversible, Scope: []session.AnswerScope{session.ScopeOnce, session.ScopeAlways}, // THE CARD'S BOX IS ITS CORRECTION LANE and always was: "make it 2pm" is // a real answer to this question, and the engine reads a standing answer // that carries words alone as a correction to re-propose on // (session's applyToLane). - Input: session.InputShape{Kind: session.InputText, Prompt: standChangeCost}, + Input: session.InputShape{Kind: session.InputText, Prompt: session.StandingChangeHint(card.item)}, Deadline: notice.Deadline, Asked: a.now(), } } // standAnswerWord is what one answer is CALLED on this card, by the key that -// takes it. -// -// EVERY ONE OF THEM NAMES ITS OUTCOME IN WORDS A STRANGER READS COLD, which is -// why the card says more than the kind's own list does ([session.AnswerOptions] -// spells them `yes`, `just once`, `not set up` for home's chip row, where the -// column is scarce). A person meeting their first card said, in as many words, -// that they did not understand the options; these say what will HAPPEN. -func standAnswerWord(key string) string { - switch key { - case standYesKey: - return standYesWord - case session.StandingOnceKey: - return standOnceWord - case session.StandingNoKey: - return standNoWordChip - } - return "" -} - -// standAnswerCost is what one answer costs, by the key that takes it. A key the -// list does not carry has no clause, which is the emptiness law rather than a -// default. -func standAnswerCost(key string) string { - switch key { - case standYesKey: - return standYesCost - case session.StandingOnceKey: - return standOnceCost - case session.StandingNoKey: - return standNoCost +// takes it. The words are the kind's own ([session.StandingOptions]), so the +// transcript, home and the recorded labels say the same thing. +func standAnswerWord(item standing.Item, key string) string { + for _, option := range session.StandingOptions(item) { + if option.Key == key { + return option.Label + } } return "" } @@ -647,9 +628,9 @@ func standVerdictOf(card *standingCard, answer session.Answer) (string, string) // A CORRECTION IS NOT A YES. The person said what is wrong with the // arrangement and the model re-proposes on those words; nothing stands // yet, and the row has to say so. - return standChangedWord, standChangeWord + return standChangedWord, session.StandingChangeWord(card.item) } - word := standAnswerWord(key) + word := standAnswerWord(card.item, key) switch key { case session.StandingOnceKey: return standOnceDone, word @@ -826,35 +807,20 @@ func StandingCardRows(a *app, card *standingCard, width int, sel bool) []string // are agreeing to. func (a *app) standBands(card *standingCard, width int) []string { var out []string + // THE THIRD LINE IS THE WHEN AND THE COST, one sentence. The tags used to + // take a row each. What a person checks is the cadence and what one time + // costs, and they read them together. + var fact string if card.when != "" && card.item.When.Kind != standing.WhenHold { - word := standWhenTag + card.when + fact = card.when if card.guessed { // THE GUESS IS SAID OUT LOUD, in the card's own sentence from // docs/AMBIENT.md. A cadence the model invented and the card stated // flatly is the one thing on this block a person cannot audit // afterwards, because it looks exactly like something they said. - word += standGuessTag - } - for _, line := range wrap(word, width) { - out = append(out, a.pal.dim(line)) + fact += standGuessTag } } - // AND HOW FAR IT REACHES, ALWAYS SAID, which is the one band here that is - // never dropped. The other two can be empty because a notice may carry no - // words for them; a reach cannot — [standing.Item.Level] resolves the zero - // value to a real answer — and an order whose reach was not on the card is - // an order somebody agreed to without knowing where it applies - // (docs/STANDING-ORDERS.md: the card always names it before anything - // stands). It is drawn in the person's own words and never the field's - // ([standLevelWord]). - for _, line := range wrap(standWhereTag+standLevelWord(card.item.Level()), width) { - out = append(out, a.pal.dim(line)) - } - // AND A RULE HAS NO COST BAND AT ALL. A hold never wakes, so it never runs a - // probe, never buys a judgment and never launches work ([standing.Item.Spends] - // is where that is decided) — and the emptiness law reaches a whole band: an - // allowance quoted on a card for something that can never draw on it is a - // figure the person has to weigh and nothing will ever spend. cost := "" if card.item.Spends() { cost = card.cost @@ -867,10 +833,28 @@ func (a *app) standBands(card *standingCard, width int) []string { } } if cost != "" { - for _, line := range wrap(standCostTag+cost, width) { + if fact != "" { + fact += " · " + cost + } else { + fact = cost + } + } + if fact != "" { + for _, line := range wrap(fact, width) { out = append(out, a.pal.dim(line)) } } + // AND HOW FAR IT REACHES, ALWAYS SAID, which is the one band here that is + // never dropped. The other two can be empty because a notice may carry no + // words for them. A reach cannot: [standing.Item.Level] resolves the zero + // value to a real answer, and an order whose reach was not on the card is + // an order somebody agreed to without knowing where it applies + // (docs/STANDING-ORDERS.md: the card always names it before anything + // stands). It is drawn in the person's own words and never the field's + // ([standLevelWord]). + for _, line := range wrap(standWhereTag+standLevelWord(card.item.Level()), width) { + out = append(out, a.pal.dim(line)) + } return out } @@ -984,13 +968,14 @@ func (a *app) standingAnimating() bool { // conversation draws and the card home's errand pane draws (homeexchange.go) are // the same object read the same way. func (a *app) standingCardFor(notice session.StandingNotice) *standingCard { - words := strings.TrimSpace(notice.Item.Words) - name := standName(words) + // THE HEAD NAMES THE KIND. The second line is what it does, the brief's + // title or the person's own sentence when nobody wrote a title. + does := strings.TrimSpace(notice.Item.Title()) return &standingCard{ id: notice.ID, item: notice.Item, - name: name, - words: standSub(name, words), + name: session.StandingHead(notice.Item), + words: does, when: strings.TrimSpace(notice.WhenWords), cost: strings.TrimSpace(notice.CostWords), guessed: notice.Guessed, diff --git a/internal/tui3/standing_test.go b/internal/tui3/standing_test.go index ed0897fbb7..cfd388daf9 100644 --- a/internal/tui3/standing_test.go +++ b/internal/tui3/standing_test.go @@ -132,8 +132,9 @@ func TestAStandingProposalDrawsWhenAndCost(t *testing.T) { text := standText(a) for _, want := range []string{ taskHeadCorner + " " + glyphAsk + " " + standWaitGlyph, - standWhenTag + "Mondays at 9am", - standCostTag + "about $0.02 a run, at most once a day", + "Mondays at 9am", + "about $0.02 a run, at most once a day", + session.StandingHeadCheck, standEndsWord + "30s", taskFootCorner, } { @@ -236,7 +237,11 @@ func TestTheThreeKeysSendTheThreeAnswers(t *testing.T) { if kept.stand == nil || !kept.stand.settled() { t.Fatal("the answered card left the transcript") } - if page := standText(kept); !strings.Contains(page, standYesWord+" · "+standSetWord) { + // The chosen word is the kind's own yes, cadence included. The verdict sits + // after it, so a later reading says both which button was pressed and what + // that button did. + wantFoot := standAnswerWord(standItem(), "1") + " · " + standSetWord + if page := standText(kept); !strings.Contains(page, wantFoot) { t.Fatalf("the settled card does not carry the answer and what it came to:\n%s", page) } @@ -514,7 +519,7 @@ func TestAOneOffReminderCardDrawsTwoChips(t *testing.T) { }) block := standBlock(a) - for _, want := range []string{"1 " + standYesWord, "0 " + standNoWordChip} { + for _, want := range []string{"1 Remind me", "0 Don't remind me"} { if !strings.Contains(block, want) { t.Fatalf("a reminder's card is missing %q:\n%s", want, block) } @@ -535,7 +540,7 @@ func TestAOneOffReminderCardDrawsTwoChips(t *testing.T) { // The derivation names the keys the card drew and not one more. (The slot // itself is quiet while the block draws them — hints pick A — and this is // the reading behind it, which is where the defect would be.) - const twoHint = "1 yes, set it up · 0 no · esc later" + const twoHint = "1 Remind me in 1 minute — 07:35 · 0 Don't remind me · esc later" if got := a.questionHintFor(); got != twoHint { t.Fatalf("the hint is %q, want %q", got, twoHint) } @@ -580,10 +585,10 @@ func TestAWatchCardStillDrawsThreeChips(t *testing.T) { }) block := standBlock(a) - if !strings.Contains(block, "3 "+standOnceWord) { - t.Fatalf("a watch lost its `%s` answer:\n%s", standOnceWord, block) + if !strings.Contains(block, "3 Check once now") { + t.Fatalf("a watch lost its once answer:\n%s", block) } - const threeHint = "1 yes, set it up · 3 just once · 0 no · esc later" + const threeHint = "1 Watch for it · 3 Check once now · 0 Don't watch · esc later" if got := a.questionHintFor(); got != threeHint { t.Fatalf("the hint is %q, want %q", got, threeHint) } @@ -672,7 +677,13 @@ func TestZeroSaysNoToAStandingCardWhereverItIsDrawn(t *testing.T) { Item: item, WhenWords: "every few minutes", CostWords: "about $0.02 a check", Options: session.StandingOptions(item), }) - if block := standBlock(a); !strings.Contains(block, session.StandingNoKey+" "+standNoWordChip) { + label := "" + for _, option := range session.StandingOptions(item) { + if option.Key == session.StandingNoKey { + label = option.Label + } + } + if block := standBlock(a); !strings.Contains(block, session.StandingNoKey+" "+label) { t.Fatalf("the card does not draw the decline:\n%s", block) } } @@ -985,9 +996,9 @@ func TestEveryStandingAnswerSaysWhatItWillDo(t *testing.T) { }) block := standBlock(a) for key, want := range map[string]string{ - "1": standYesCost, - session.StandingOnceKey: standOnceCost, - session.StandingNoKey: standNoCost, + "1": "It watches until you stop it.", + session.StandingOnceKey: "Checks once now. Nothing keeps watching.", + session.StandingNoKey: "Nothing watches.", } { if !strings.Contains(block, want) { t.Fatalf("the answer under %q does not say %q:\n%s", key, want, block) @@ -1127,3 +1138,16 @@ func TestAStandingQuestionArrivingByBothRoadsDrawsOnce(t *testing.T) { t.Fatalf("the lane's copy respelled the answers:\n%s", block) } } + +// A NARROW BAND DROPS THE CADENCE BEFORE IT CUTS A CHARACTER. "Set it up · +// every 3 hours" becomes "Set it up", and only a still-too-narrow stem is cut. +func TestANarrowStandingLabelDropsTheCadenceFirst(t *testing.T) { + a := newTestApp(&fakeAgent{}) + full := "Set it up · every 3 hours" + if got := a.questionBandWord(full, "1", 24); got != "Set it up" { + t.Fatalf("the cadence was not dropped: %q", got) + } + if got := a.questionBandWord("Don't set it up", "0", 80); got != "Don't set it up" { + t.Fatalf("the no was rewritten: %q", got) + } +} diff --git a/internal/tui3/stop.go b/internal/tui3/stop.go index b5077be5e9..6ad4fc8938 100644 --- a/internal/tui3/stop.go +++ b/internal/tui3/stop.go @@ -394,9 +394,14 @@ func (a *app) stopSay(line string) { // the roster does not hold the keyboard there is no cursor and nothing is being // aimed at (taskstrip.go's [app.stripFocused] reads the same two fields). func (a *app) railFocusNode() *taskNode { - if !a.railHold || a.railWhere.id == 0 { + if !a.railHold { return nil } + if a.railWhere.id == 0 { + // A TASK'S ROW IN THE BAND IS THAT TASK, for every key the held column + // answers (sidecol.go). + return a.tasks[sideTaskOf(a.railWhere.key)] + } return a.tasks[a.railWhere.id] } @@ -410,9 +415,8 @@ func (a *app) railFocusNode() *taskNode { // at an unseen row is the guess this whole path exists to avoid: [app.railView] // is the one door onto the roster's geometry, the same door the pointer and the // frame are answered through, so this and they cannot disagree about what is -// on screen. A FOLDED ROOT STANDS FOR WHAT IT HIDES, exactly as it does for the -// pointer: one row covering a family is one target, and its `worst` node is the -// work it is standing for ([app.railView] reads the same field for the pin). +// on screen. A group folded to its heading hides its rows from this count as +// it hides them from the eye. // // Counted here and not beside the caller so the one-row rule has one statement // rather than two copies a second caller could get wrong. @@ -426,13 +430,7 @@ func (a *app) stopVisible() (int, *taskNode) { continue } if a.stopTaskTarget(node).empty() { - // A folded root carries nothing stoppable of its own but may be standing - // for a subtree that does. The work it stands for is the worst node it - // hid, which is the same reading the pin and the row's own glyph take. - if !e.folded || a.stopTaskTarget(e.worst).empty() { - continue - } - node = e.worst + continue } if count++; count > 1 { return count, nil diff --git a/internal/tui3/stopping_test.go b/internal/tui3/stopping_test.go index 6de06c6328..cbcc0f43d6 100644 --- a/internal/tui3/stopping_test.go +++ b/internal/tui3/stopping_test.go @@ -217,6 +217,10 @@ func TestTheStoppedSurfaceReadsAClockThatDoesNotMoveOnItsOwn(t *testing.T) { // insists the compared frame SEES it. func TestTheStoppedFramesComparisonStillCoversTheHead(t *testing.T) { a, _, elapse := stoppingAppOnAHeldClock(t) + // THE HEAD'S CLOCK NEEDS THE ROOM THE NAV LEAVES IT. The top line carries + // the places before the clock (topnav.go), and on the fixture's narrow + // frame the clock is the first thing the line drops. + a.width = 160 drive(t, a, key("esc")) was := stoppedFrame(a) diff --git a/internal/tui3/striporder_test.go b/internal/tui3/striporder_test.go new file mode 100644 index 0000000000..e1e6ba9cd4 --- /dev/null +++ b/internal/tui3/striporder_test.go @@ -0,0 +1,62 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" +) + +// THE STRIP READS THE TEAM CHIP, THE MANAGER, THEN THE TABS. The chip filters +// the tabs, so it stands first, right before them, with the manager's place +// after it. There is no `home` piece in front of it any more: home is the +// nav's first word, on the row over the strip on every page (topnav.go). The +// hits follow the words, and as the row narrows the chip goes before the tab +// in front ever does. +func TestTheStripReadsTheTeamThenItsTabs(t *testing.T) { + a, _, _, _ := trafficApp(t) + a.open = func(workspace, transcript string) (Conversation, error) { return Conversation{}, nil } + a.width, a.height = 160, 40 + row := ansi.Strip(a.tabsRow(a.width)) + chip, manager := strings.Index(row, "harbor ▾"), strings.Index(row, teamManagerGlyph+" Manager") + if chip < 0 || manager < 0 || chip > manager { + t.Fatalf("the strip reads %q", row) + } + if strings.Contains(row, " home ") || strings.Contains(row, "Home") { + t.Fatalf("the strip still carries a way home, which is the nav's first word now: %q", row) + } + for _, hit := range a.chatTabHits { + if hit.kind == tabManager || hit.kind == tabHere || hit.kind == tabOther { + if hit.span.from < a.wall.chip.to { + t.Fatalf("a tab's hit %+v is before the chip's end %d", hit, a.wall.chip.to) + } + } + } + if a.wall.chip.from != headLabelAt { + t.Fatalf("the chip's hit %+v is not the strip's first piece at %d", a.wall.chip, headLabelAt) + } + if got := plainCells(row, a.wall.chip.from, a.wall.chip.to); !strings.Contains(got, "harbor") { + t.Fatalf("the chip's hit covers %q", got) + } + // Narrowing: the chip goes, and the tab in front stays. + sawChipless := false + for w := 159; w >= roomHeadFloor; w-- { + a.chatTabBar = tabBar{} + row := ansi.Strip(a.tabsRow(w)) + if !strings.Contains(row, "harbor") { + sawChipless = true + } + front := false + for _, hit := range a.chatTabHits { + if hit.kind == tabHere || (hit.tab.here && hit.kind == tabManager) || hit.tab.key == a.frontTabKey() { + front = true + } + } + if !front { + t.Fatalf("at %d the tab in front is gone: %q", w, row) + } + } + if !sawChipless { + t.Fatal("no width gave the chip up to keep the tab in front") + } +} diff --git a/internal/tui3/tabinset_test.go b/internal/tui3/tabinset_test.go index 1fa6982eac..097f94ccc4 100644 --- a/internal/tui3/tabinset_test.go +++ b/internal/tui3/tabinset_test.go @@ -17,7 +17,7 @@ func TestTabInsetSurroundsPaintedStatusAndClose(t *testing.T) { a := newTestApp(&fakeAgent{}) a.pal = newPalette(profile, false) tab := chatTab{key: "inset", word: "Readable title", here: active, signal: signal} - pieces, hits := a.tabsFit([]chatTab{tab}, 70) + pieces, hits := a.tabsFit([]chatTab{tab}, 70, 0) a.chatTabHits = hits var label, close tabHit for _, hit := range hits { @@ -42,7 +42,13 @@ func TestTabInsetSurroundsPaintedStatusAndClose(t *testing.T) { line := a.tabsPaint(pieces) first := ansi.Cut(line, label.span.from, label.span.from+1) last := ansi.Cut(line, close.span.to-1, close.span.to) - if plain(first) != " " || plain(last) != " " { + // WITH NO COLOUR, THE POINTER'S TAB WEARS `·` IN ITS LEADING INSET, + // as a nav word does; every other edge is a blank. + lead := " " + if profile == tokens.NoColor && hover >= 0 { + lead = "·" + } + if plain(first) != lead || plain(last) != " " { t.Fatalf("profile=%v signal=%v active=%v hover=%d: tab edges are not inset: %q / %q", profile, signal, active, hover, first, last) } if profile >= tokens.ANSI256 && (active || hover >= 0) { @@ -77,11 +83,11 @@ func TestTabInsetCellsKeepTheirNavigationAndCloseOwnership(t *testing.T) { if closeIt { x, want = close.to-1, tabClose } - hit, ok := a.tabAt(x, placeTabRow) + hit, ok := a.tabAt(x, tabStripRow) if !ok || hit.kind != want || hit.tab.word != word { t.Fatalf("inset maps to wrong target: %+v", hit) } - cmd, took := a.tabPress(x, placeTabRow) + cmd, took := a.tabPress(x, tabStripRow) if !took { t.Fatal("inset click fell through") } diff --git a/internal/tui3/tabscroll.go b/internal/tui3/tabscroll.go index 6b92074332..b69c721c56 100644 --- a/internal/tui3/tabscroll.go +++ b/internal/tui3/tabscroll.go @@ -30,10 +30,10 @@ func (a *app) tabWindow(tabs []chatTab, widths []int, budget, active int) (int, for _, width := range widths { used += width + 1 } - scroll := used > budget && budget >= tabReadableCells+tabInsetCells+tabCloseCells+2+2*tabArrowCells + scroll := used > budget && budget >= tabReadableCells+tabInsetCells+tabCloseCells+2+tabArrowsCells(1) available := budget if scroll { - available -= 2 * tabArrowCells + available -= tabArrowsCells(1) } else { v.browsing = false } @@ -57,14 +57,21 @@ func (a *app) tabWindow(tabs []chatTab, widths []int, budget, active int) (int, return from, to, scroll } +// tabArrowsCells is what a scrolling strip spends on its two arrows: their +// cells and the gap in front of the left one ([app.tabsFit]). +func tabArrowsCells(sepW int) int { return 2*tabArrowCells + sepW } + func (a *app) tabArrowPiece(right, enabled bool, at int) (tabPiece, *tabHit) { - if !enabled { - return tabPiece{word: " ", quiet: true}, nil - } word, kind := a.linearMark("‹", "<"), tabScrollLeft if right { word, kind = a.linearMark("›", ">"), tabScrollRight } + // A SCROLLING STRIP DRAWS BOTH ARROWS, the one with nowhere to go dim and + // inert. Its cells are held either way so the window never shifts under a + // press, and three blank cells there read as a gap nobody meant. + if !enabled { + return tabPiece{word: " " + word + " ", quiet: true}, nil + } return tabPiece{word: " " + word + " ", kind: kind}, &tabHit{span: hudSpan{from: at, to: at + tabArrowCells}, kind: kind} } diff --git a/internal/tui3/tabscroll_test.go b/internal/tui3/tabscroll_test.go index 15c84f277e..30b4818d2f 100644 --- a/internal/tui3/tabscroll_test.go +++ b/internal/tui3/tabscroll_test.go @@ -73,7 +73,7 @@ func TestManyTabsRemainReadableWhileArrowsBrowseWithoutSwitching(t *testing.T) { break } right := tabScrollTarget(t, a, tabScrollRight) - cmd, took := a.tabPress(right.span.to-1, placeTabRow) + cmd, took := a.tabPress(right.span.to-1, tabStripRow) if !took || cmd != nil { t.Fatal("scroll arrow opened or started something") } @@ -104,7 +104,7 @@ func TestTabStripWheelBrowsesBothAxesWithoutTouchingTheTranscript(t *testing.T) for _, button := range []tea.MouseButton{tea.MouseWheelRight, tea.MouseWheelDown, tea.MouseWheelLeft, tea.MouseWheelUp} { _ = a.tabsRow(a.width) from := a.tabView.from - drive(t, a, tea.MouseWheelMsg{X: 20, Y: placeTabRow, Button: button}) + drive(t, a, tea.MouseWheelMsg{X: 20, Y: tabStripRow, Button: button}) if a.tabView.from == from { t.Fatalf("wheel %v did not browse tabs", button) } @@ -122,7 +122,10 @@ func TestTabViewportFitsUnicodePlainAndCompactFramesAfterBrowsing(t *testing.T) for _, ascii := range []bool{false, true} { a := manyTabApp(t) a.pal = newPalette(profile, ascii) - for _, width := range []int{160, 80, 40, 24, 12} { + // 36 is a compact strip: the strip had eight fewer cells while a + // `home` piece led it, and forty columns was compact then; the + // scroll floor itself ([tabReadableCells]) did not move. + for _, width := range []int{160, 80, 36, 24, 12} { for _, height := range []int{40, 16} { a.width, a.height = width, height a.touch() @@ -136,7 +139,7 @@ func TestTabViewportFitsUnicodePlainAndCompactFramesAfterBrowsing(t *testing.T) t.Fatalf("overlapping or offscreen target at %d: %+v", width, hit) } for x := hit.span.from; x < hit.span.to; x++ { - got, ok := a.tabAt(x, placeTabRow) + got, ok := a.tabAt(x, tabStripRow) if !ok || got.kind != hit.kind || got.tab.key != hit.tab.key { t.Fatalf("drawn target disagrees with hit at %d", x) } @@ -227,7 +230,7 @@ func TestNewChatFollowsTheLastVisibleTab(t *testing.T) { } } for x := plus.span.from; x < plus.span.to; x++ { - got, ok := a.tabAt(x, placeTabRow) + got, ok := a.tabAt(x, tabStripRow) if !ok || got.kind != plus.kind { t.Fatalf("adjacent control has wrong hit ownership: %+v", got) } diff --git a/internal/tui3/tabtitle.go b/internal/tui3/tabtitle.go index bca8d2a361..3831c51a23 100644 --- a/internal/tui3/tabtitle.go +++ b/internal/tui3/tabtitle.go @@ -24,12 +24,12 @@ func (a *app) tabTitlePreview(frame string) string { rows := strings.Split(frame, "\n") // A modal or another place can hide the strip while its last hit map remains. // Only a frame actually drawing this strip may reveal its title. - if at := placeTabRow; at >= len(rows) || rows[at] != a.chatTabBar.line { + if at := tabStripRow; at >= len(rows) || rows[at] != a.chatTabBar.line { return frame } preview := strings.Split(ansi.Wrap(title, width-2*headLabelAt, ""), "\n") for i, line := range preview { - at := placeTabRow + 1 + i + at := tabStripRow + 1 + i if at >= len(rows) { break } diff --git a/internal/tui3/tabtitle_test.go b/internal/tui3/tabtitle_test.go index 8910ae903d..2f6afd5caf 100644 --- a/internal/tui3/tabtitle_test.go +++ b/internal/tui3/tabtitle_test.go @@ -10,11 +10,11 @@ func TestTabHoverRevealsFullTitleWithoutMovingTargets(t *testing.T) { a.title = "Shipping the parser with complete unicode support" a.tabsRow(a.width) span := tabSpanFor(t, a, a.title) - a.hot, _ = a.tabHoverAt(span.from, placeTabRow) + a.hot, _ = a.tabHoverAt(span.from, tabStripRow) before := a.tabsRow(a.width) frame := strings.Repeat(strings.Repeat(" ", a.width)+"\n", a.height-1) rows := strings.Split(frame, "\n") - rows[placeTabRow] = before + rows[tabStripRow] = before frame = strings.Join(rows, "\n") shown := a.tabTitlePreview(frame) if !strings.Contains(plain(shown), a.title) { diff --git a/internal/tui3/tallyrows_test.go b/internal/tui3/tallyrows_test.go index 537650e70f..9f0284f936 100644 --- a/internal/tui3/tallyrows_test.go +++ b/internal/tui3/tallyrows_test.go @@ -246,21 +246,20 @@ func TestTheManualQuotesBothTasksOpeningHeadingsExactly(t *testing.T) { } } -// A ROSTER FOOTER THE MANUAL QUOTES IS BUILT FROM THE ROSTER'S OWN WORD TABLE. -// `railGroupWords` moved and four passages went on teaching the words it had -// dropped, so the next move of that table fails here rather than in front of -// somebody reading the page. +// THE GROUP HEADINGS THE MANUAL QUOTES ARE BUILT FROM THE ROSTER'S OWN WORD +// TABLE. The column's footer of counts is gone and its headings carry the +// counts now (`Running 4`, `Done 6 ▸`); the words moved once before and four +// passages went on teaching the words it had dropped, so the next move of the +// table fails here rather than in front of somebody reading the page. func TestTheManualQuotesTheRosterGroupsOwnWords(t *testing.T) { wants := []string{ - itoa(148) + " " + railGroupWords[railParked] + railSep + itoa(12) + " " + railGroupWords[railDone], - // IN THE FOOTER'S OWN ORDER ([railFootOrder]), which leads with what is - // HAPPENING and not with what is asking — the manual had it the other way - // round as well as in the retired words. - itoa(3) + " " + railGroupWords[railRunning] + railSep + itoa(1) + " " + railGroupWords[railAttention], + railHeadWords[railRunning] + " " + itoa(4), + railHeadWords[railIdle] + " " + itoa(3) + " " + glyphShut, + railHeadWords[railDone] + " " + itoa(6) + " " + glyphShut, } for _, want := range wants { if !manual.Chat().Mentions(want) { - t.Fatalf("the chat manual does not quote the roster footer %q in the table's own words", want) + t.Fatalf("the chat manual does not quote the roster heading %q in the table's own words", want) } } } diff --git a/internal/tui3/task.go b/internal/tui3/task.go index 06da4be8d0..a79c42a153 100644 --- a/internal/tui3/task.go +++ b/internal/tui3/task.go @@ -2148,74 +2148,54 @@ func countdownWord(d time.Duration) string { // ── the roster ────────────────────────────────────────────────────────────── // -// THE RAIL WAS A PRESENCE LIST AND IT IS NOW A ROSTER, because the two stop -// being the same thing somewhere around the fortieth node. A presence list holds -// what is alive and forgets everything else, which is exactly right for a -// session with three nodes in it and useless for a day's work: "where did that -// task go" is the commonest question a person asks a column of work, and a -// column that dropped every landed node had already thrown the answer away. -// -// So the column keeps EVERY node the session has admitted, and it survives -// hundreds of them by four mechanisms and no new scroll machinery: -// -// - IT IS A FOREST AND NOT FIVE BUCKETS. The column used to open with five -// state headings — needs you, running, idle, parked, done — and file every -// node under one of them, which scattered ONE run across four sections: the -// root under `running`, its finished cuts under `done`, the one that -// conflicted at the top of the column, and nothing on screen saying they -// were the same piece of work. A shape is the news an adaptive run makes -// (internal/orchestrate spawns as it learns), and the state of a single node -// inside it is a detail. So a family is drawn WHOLE, under its own root, in -// the order the session admitted it — and a node that belongs to no family -// is the flat row it has always been. -// -// What the headings sorted, the ORDER of the families still says: a family -// stands where its most urgent member puts it ([app.railUrgency]), so work -// that is waiting on a person is at the top of the column and a settled run -// is at the bottom, whole, one row deep. -// - FOLDING IS THE PERSON'S, PER FAMILY, AND IT HAS A DEFAULT WORTH HAVING. A -// family with anything live in it opens; a family that is entirely settled — -// or entirely waiting — opens as one row wearing the worst thing that -// happened under it and a count of what it is standing for. The map is the -// person's correction of that default and it sticks ([app.railShut]). +// THE ROSTER IS THE SIDE COLUMN'S TASKS VIEW (sidecol.go), and it is grouped +// by what the work is doing, one line a task: +// +// Running 4 +// ⠙ rebase onto dev 2m +// ⠙ price scrape 40s +// Queued 3 ▸ +// Done 7 ▾ +// ✓ read the law 3m +// +// It keeps EVERY node the session has admitted, and it survives dozens of them +// by three mechanisms and no new scroll machinery: +// +// - WHAT IS RUNNING IS ALWAYS OPEN, and everything else folds to one row with +// a count until the person opens it. Running work is bounded by the slots +// the machine has; queued, waiting and done work is bounded by nothing, +// and a plan can admit a hundred nodes in a breath. The fold is the +// person's, per group, and it is remembered for the session +// ([app.sideGroupShut]). +// - WHAT NEEDS THE PERSON IS NOT IN THE LIST AT ALL. A task whose next step +// is theirs, and a failure they have not opened, are the band's rows at +// the top of the column (sidecol.go's [app.sideBand]), and a row is never +// drawn twice. // - THE COLUMN IS A WINDOW. What shows is a slice of the line list around the -// focus, taken by [listTop] — the same function the model picker and the two -// typed lists scroll with, because a second scroller on this surface would be -// a second set of off-by-ones. -// - THE FOOTER SAYS THE WHOLE. What the window cannot show — the spend, the -// weight, the count of every state the forest has folded into a shape — is -// one dim block at the bottom of the column, in the group vocabulary the -// headings used to carry. +// focus, taken by [listTop], the same function the model picker and the two +// typed lists scroll with, because a second scroller on this surface would +// be a second set of off-by-ones. +// +// ONE LINE A TASK: its state, its name cut with an ellipsis, and how long it +// has been at it in the muted ink at the right. What a two-line row used to say +// under the name (the call it is in, what it waits on, the branch it kept) is +// on the hint line under the pointer, with the whole name ([app.sideHoverWords] +// reads [app.railUnder]). // // THE KEYBOARD IS ASKED FOR, NEVER TAKEN (alt+t, esc to give it back). The // draft is this surface's rest state and a map that stole keys from it would -// make typing a thing you check before you do — see the marker law at +// make typing a thing you check before you do: see the marker law at // [app.railRows]. // -// AND THE COLUMN WIDENS ON DEMAND (w). A tree spends three cells a level, and -// three levels of indent inside thirty columns is a list of first words. The -// wide tier is a third width the person asks for and never a width the surface -// takes: it is charged against the conversation like the other two, and the one -// piece of chrome that says it exists is a hint that appears only while a title -// is actually being cut by its own indent ([app.railFootRows]). +// AND THE COLUMN WIDENS ON DEMAND (alt+w), by [railWideGain], charged against +// the conversation like the rest of it. const ( - // railCols is the whole charge a full rail makes on the frame: the seam, - // its gutter, and the column the nodes are drawn in. - railCols = 30 - // railSlimCols is the charge under a narrower frame: the same column, - // tighter. - railSlimCols = 24 - // railWideCols is the charge of a column a person has ASKED to widen (w, - // [app.railKey]). Forty-six is thirty plus five levels of indent, which is - // deeper than any run this surface has drawn — the point of the tier is that - // a tree stops eating its own names, not that it can nest forever. It is - // charged against the conversation exactly like the other two, which is why - // it is a key and not a default. - railWideCols = 46 - // railWideGain is what taking that tier lends a row, and it is the whole of - // what the widen hint promises ([app.railEntryRows]). - railWideGain = railWideCols - railCols + // railWideGain is what a column the person has ASKED to widen (alt+w, + // [app.railKey]) takes on top of the one the frame lends it + // ([sideColsFor]). It is charged against the conversation exactly like + // the rest of the column, which is why it is a key and not a default. + railWideGain = 16 // railFloor is the frame a FULL rail takes. Under it the conversation // would be reading at ninety columns to keep a column of titles on screen. railFloor = 120 @@ -2234,15 +2214,9 @@ const ( railMarkASCII = "> " ) -// The disclosure marks a family root wears, and their ASCII stand-ins: closed -// points at what it is hiding, open points down at what it showed. -// -// THEY ARE DRAWN UNDER THE POINTER AND NOWHERE ELSE (see [app.railEntryRows]). -// A triangle on every root at rest is a column of widgets; a triangle that -// appears in the glyph cell the moment the pointer is over the row is the -// affordance arriving exactly when there is a hand to use it. What a FOLDED -// family shows at rest is its count instead — there is something hidden, and a -// count is the one thing a person cannot discover by hovering. +// The disclosure marks a folded group and a work thread wear, and their ASCII +// stand-ins: closed points at what it is hiding, open points down at what it +// showed. const ( glyphShut = "▸" glyphShutASCII = ">" @@ -2273,8 +2247,8 @@ const ( // What the keyboard offers while the roster holds it. const ( - // railHoldHint is what the legend's hint slot says while the roster has the - // keyboard (render.go's [app.hintWord]) — the keys [app.railKey] takes, + // railHoldKeys is what the legend's hint slot says while the roster has the + // keyboard (render.go's [app.hintWord]), the keys [app.railKey] takes, // quoted from the handler rather than authored twice. // // It is split at the dismiss key because ONE OF THOSE KEYS IS CONDITIONAL: @@ -2291,8 +2265,10 @@ const ( // person who pressed `x` over an empty box and watched a letter appear — the // key works the moment the roster is being driven, and this line is where that // is said out loud (#892). - railHoldKeys = "↑↓ move · →← tree · enter open · " + stopRaiseKey + " stop · " + railWidenChord + " wide" - railHoldHint = railHoldKeys + " · esc" + railHoldKeys = "↑↓ move · enter open · " + stopRaiseKey + " stop · " + railWidenChord + " wide" + // sideSwitchKeys leads that line in a chat in a team, where the column has + // two words and ← and → move between them (sidecol.go). + sideSwitchKeys = "←→ tasks/traffic" // The footer names both answers the handle can give. A bare "w" in a column // of counts is a keystroke nobody would risk pressing, and a handle whose // return trip is not named is only half an affordance. @@ -2323,43 +2299,28 @@ const ( // where Option is not meta, which is exactly what [chordDeadKeys] is a table of. const railHoldChord = chordAltWord + "t" -// The column's own door, and the two lines that name it. +// railStowKey is the column's older key, and it still puts the column away +// and brings it back. The header names [sideHideKey] (alt+l), which does the +// same and also lays the column over the body on a frame too narrow for it; +// the legend's hint slot names it while the column is away +// ([app.sideBackHint]). // -// THE KEY IS FREE AND IT IS THE LAST FREE ONE WORTH SPENDING. alt+t is the -// roster's ([app.railKey]) and every other letter this surface could reach for -// is a chord the message box already answers — ctrl+a, ctrl+e, ctrl+b, ctrl+f, -// and ctrl+u are the readline edits a person types without looking, and -// taking one of those for a sidebar would be a keystroke that deleted a word the -// first time somebody meant it. ctrl+g is readline's abort, which this surface -// has always spelled esc, so nothing is lost by binding it. -const ( - railStowKey = "ctrl+g" - // railStowHint is the last line of the column, and unlike the widen offer - // above it, it is drawn WHENEVER THE COLUMN IS. The widen tier is contextual — - // a cut title earns the offer — but the way out of a column is the one thing a - // person cannot discover by hovering, cannot reach from the keyboard they have - // not been handed, and will look for at exactly the moment they have decided - // they are done with it. One dim row at the bottom is the whole cost. - railStowHint = railStowKey + " hide" - // railBackHint is the other half, and it lives in the legend's hint slot while - // the column is away and this session has run anything (render.go's - // [app.hintWord]). It is the shape of that slot's other lines: the key, then - // what it reaches. - railBackHint = railStowKey + " tasks" -) +// ctrl+g is readline's abort, which this surface has always spelled esc, so +// nothing was lost by binding it. +const railStowKey = "ctrl+g" // ── THE EDGE A CLOSED COLUMN LEAVES BEHIND ────────────────────────────────── // // ctrl+g USED TO MAKE THE COLUMN VANISH WITHOUT A TRACE, and a thing with no // trace is a thing a person cannot get back. The two ways home were the chord // itself — which is knowledge, not an affordance, and the person who pressed it -// by accident never had that knowledge — and the legend's [railBackHint], which -// is one line of five words in a slot that carries something else most of the +// by accident never had that knowledge, and the legend's hint slot, which is +// one line of five words in a slot that carries something else most of the // time and says nothing at all in a session that has run no work. // // So a closed column leaves an EDGE: [railGripCols] columns down the right of // the frame, near-silent, with a handle at the middle of it, and the whole strip -// is a door. Pressing anywhere on it is exactly ctrl+g ([app.railStow] takes +// is a door. Pressing anywhere on it is exactly alt+l ([app.railStow] takes // both). // // THREE THINGS KEEP IT HONEST: @@ -2370,7 +2331,9 @@ const ( // - IT WHISPERS ONLY WHAT IS TRUE. One cell above the handle carries the state // of the work while there is work in a state worth carrying — something // running, or something waiting on a person — and NOTHING otherwise, which -// is the emptiness law in the smallest space this surface has. +// is the emptiness law in the smallest space this surface has. In a chat in +// a team, the cells under it count what came in on the Traffic since the +// person last read it, while anything did. // - IT IS NOT THERE WHEN A COLUMN COULD NOT BE. Under [railSlimFloor] the // frame lends no columns to anything, and an edge onto a column that cannot // stand would be a door onto a room that does not exist. @@ -2393,16 +2356,6 @@ const ( // louder still and belong to the work rather than to the door. railGripGlyph = "❮" railGripGlyphASCII = "<" - // railGripOpenGlyph is the SAME control in its other state: the chevron the - // column wears while it stands, pointing right because that is the way it - // goes. It rides the footer's own door line ([railStowHint]) rather than the - // seam, which is already the width handle and may not mean two things. - // - // SO THE RIGHT EDGE ALWAYS CARRIES ONE CHEVRON — `❯` to close while the column - // is up, `❮` to open while it is away — and the pointer can go round the whole - // cycle without ever being told a chord. - railGripOpenGlyph = "❯" - railGripOpenGlyphASCII = ">" ) // railGroup is what a node is DOING, which is the only thing the roster sorts @@ -2508,133 +2461,56 @@ func (a *app) taskAwaitsPerson(node *taskNode) bool { return status.Presence == session.TaskPresenceNeedsLook && status.State == session.TaskRunning } -// taskParentDeciding reports whether the node above this one is STILL WORKING, -// and is therefore the one being asked about work under it that nobody could -// check. -// -// IT IS A FOLD AND NOT A MUTE, and the difference is the whole of #268. The -// engine routes a sub-task's landing note to its parent node's own agent, which -// has the `tasks` tool and the diff and every reason to answer it (session's -// deliverTaskNote) — so while the parent lives, the top of the family is what a -// person should be reading first. That is an argument about LOUDNESS and it was -// once read as an argument about presence: the child was filed under `done` and -// drew no card, so a nested question could expire with nobody able to see it. -// What this answers now is only [app.railGlyphRank]'s question — how loud — -// while [app.railGroupOf] keeps the demand where it belongs. -// -// It is asked about exactly one thing — is the parent unsettled — and everything -// else answers "no": a node with no parent is a root and is the person's, a node -// whose parent this session has never heard of has nobody above it that could -// decide, and a node whose parent has landed has been orphaned and is the -// person's again. -// -// It is deliberately not a walk up the whole family. The immediate parent is the -// only node that is ever handed this child's news, so a grandparent's state says -// nothing about whether anybody is reading it. -func (a *app) taskParentDeciding(node *taskNode) bool { - if node == nil || node.parent == "" { - return false - } - for _, up := range a.tasks { - if stripKey(up) != node.parent { - continue - } - return up.state == session.TaskRunning || up.state == session.TaskQueued - } - return false -} - -// railShut reports whether a family is drawn as its root alone. -// -// THE DEFAULT IS THE DESIGN AND THE MAP IS THE PERSON'S CORRECTION OF IT, which -// is why this is not a plain bool per node: a family nobody has touched must -// follow the default even as the work under it moves. A family with anything -// live in it — running, waiting on a person, or waiting for a slot — is open, -// because that is the shape somebody is watching; a family that has entirely -// settled, or that is entirely waiting behind other work, is one row with a count -// on it. -func (a *app) railShut(node *taskNode) bool { - if open, said := a.railOpen[node.id]; said { - return !open - } - return !a.railKinLive(node) -} - -// railTwigShut is the same question asked where the family is already grown, and -// it is the one the layout uses: [app.railShut] has to build the subtree back up -// to answer, which down a walk is the family regrown once a row. -func (a *app) railTwigShut(t *railTwig) bool { - if open, said := a.railOpen[t.node.id]; said { - return !open - } - return !a.railTwigLive(t) -} - -// railSetOpen folds one family open or closed. -func (a *app) railSetOpen(node *taskNode, open bool) { - if node == nil { - return - } - if a.railOpen == nil { - a.railOpen = map[uint64]bool{} - } - if a.railShut(node) == !open { - return - } - a.railOpen[node.id] = open - a.touch() -} +// railHeadWords is the word each group's heading wears in the column, the +// same vocabulary as [railGroupWords] said as a heading. +var railHeadWords = [railGroupCount]string{"Needs you", "Running", "Queued", "Waiting", "Done"} -// railToggle is what a press on a root's glyph cell does. -func (a *app) railToggle(node *taskNode) { a.railSetOpen(node, a.railShut(node)) } +// railListOrder is the order the column's groups stand in. The work waiting +// on a person is not among them: it is the band's (sidecol.go). +var railListOrder = [...]railGroup{railRunning, railIdle, railParked, railDone} -// railEntry is one navigable row of the roster: a node, and where in its family -// it hangs. +// railEntry is one navigable row of the roster: a group's heading, or a node +// under it. type railEntry struct { node *taskNode - // stems is the ancestry as the connectors need it: one entry per level, true - // where that level's node still has siblings to come. Its length is the - // node's depth, so a root's is empty and a root has no connector. - stems []bool - // root says this node HEADS a family — it has children, so it is the one row - // in the family that folds. A node that belongs to no family is not a root: - // it is the flat row this column has always drawn. - root bool - // folded says this root is standing for its whole subtree, hidden is how many - // nodes it is standing for, and worst is the node whose state that one row - // wears. All three are zero on every other row, and all three are settled at - // WALK TIME because the walk has the subtree in its hand — asking the same - // questions again at paint time would be re-growing the family once a row. - folded bool - hidden int - worst *taskNode + // group is the group the row heads or sits in. + group railGroup + // head says this row is the group's heading, count how many nodes the + // group holds, and shut that the group is folded to it. + head bool + count int + shut bool } // railSpot names a row by IDENTITY rather than by index, and it is what the // focus is stored as. // -// An index would be a cursor that jumps: work landing reorders the families, a -// fold takes a subtree out from under it, and both happen while nobody is -// touching the keyboard. An id survives all of it, and when the node it names is -// genuinely gone the walk clamps rather than teleporting. -// -// AN ID IS ENOUGH BECAUSE EVERY ROW OF THIS COLUMN IS THIS CONVERSATION'S. It -// used to carry a second field for the project's record rows, which cannot be -// named by id at all — ids restart with every conversation (task_index.go says so -// on [session.TaskIndexEntry.ID]) — and those rows are the task page's now. +// An index would be a cursor that jumps: work landing moves a node from one +// group to another, a fold takes a group's rows out from under it, and both +// happen while nobody is touching the keyboard. An id survives all of it, and +// when the node it names is genuinely gone the walk clamps rather than +// teleporting. type railSpot struct { id uint64 + // group is a group's heading, as its railGroup plus one. + group int // jobs is the jobs section's label, and job is a row of that section. They // live here rather than in a second cursor because this column has one // walk and one enter, and a second map would be a second idea of where // the keyboard is. jobs bool job int + // key is one of the side column's own rows: a band item or a row of the + // Traffic (sidecol.go's [sideRow.key]). + key string } func (s railSpot) onJobs() bool { return s.jobs || s.job != 0 } func railSpotOf(e railEntry) railSpot { + if e.head { + return railSpot{group: int(e.group) + 1} + } if e.node == nil { return railSpot{} } @@ -2698,31 +2574,13 @@ func railFinalOrder(nodes []*taskNode) []*taskNode { return out } -// ── THE FOREST ────────────────────────────────────────────────────────────── - -// railTwig is one node of a family as the roster holds it: the node and the -// children the session admitted under it. -// -// It is a shape of its own rather than a flat list of (node, depth) pairs -// because every question the column asks is about a SUBTREE — is anything under -// this live, what is the worst thing that happened in it, how many rows is it -// standing for — and a depth-tagged list answers those by scanning forward for -// the next row at the same depth, which is a tree with its structure taken out -// and then guessed back. -type railTwig struct { - node *taskNode - kids []*railTwig -} - // railKin buckets every node this session has admitted by its parent's key, and // indexes them all by their own. // // It walks [app.taskOrder], so a parent's children come out in the order the -// session met them — the one order a family is allowed to use, because any other -// one moves a row a person is watching for a reason they cannot see. The -// alphabet is the parent seam's ([taskNode.ParentID] and [stripKey], -// taskstrip.go): an orchestrate node id is a string, and "" is an honest -// "nobody spawned this". +// session met them. The alphabet is the parent seam's ([taskNode.ParentID] and +// [stripKey], taskstrip.go): an orchestrate node id is a string, and "" is an +// honest "nobody spawned this". func (a *app) railKin() (kids map[string][]*taskNode, byKey map[string]*taskNode) { byKey = make(map[string]*taskNode, len(a.taskOrder)) for _, id := range a.taskOrder { @@ -2747,167 +2605,56 @@ func (a *app) railKin() (kids map[string][]*taskNode, byKey map[string]*taskNode return kids, byKey } -// railRootOf walks up to the head of a node's family. -// -// The visited set is not defensive tidiness: the parent is written by an adapter -// this package does not own ([taskNode.ParentID]), and a cycle in it would be a -// frame that never returns rather than a frame that looks wrong. -func railRootOf(node *taskNode, byKey map[string]*taskNode) *taskNode { - seen := map[string]bool{} - for { - key := stripKey(node) - if seen[key] { - return node - } - seen[key] = true - up := byKey[node.ParentID()] - if up == nil { - return node - } - node = up - } -} - -// railGrow builds one family, depth first, in the order the session met it. The -// visited set carries the same law [railRootOf] states. -func railGrow(node *taskNode, kids map[string][]*taskNode, seen map[string]bool) *railTwig { - key := stripKey(node) - twig := &railTwig{node: node} - if seen[key] { - return twig - } - seen[key] = true - for _, kid := range kids[key] { - twig.kids = append(twig.kids, railGrow(kid, kids, seen)) - } - return twig -} - -// count is every node under this twig, its own row not included — what a folded -// root has to say it is standing for. -func (t *railTwig) count() int { - n := 0 - for _, kid := range t.kids { - n += 1 + kid.count() - } - return n +// railListed reports whether a node is a row of the list rather than of the +// band: work waiting on the person, and a failure they have not opened, are +// the band's (sidecol.go). +func (a *app) railListed(node *taskNode, g railGroup) bool { + return g != railAttention && !(g == railDone && a.sideBandFails(node)) } -// railForest preserves creation order. State changes update each row without -// moving a task away from the place where the person first saw it. -func (a *app) railForest() []*railTwig { - kids, byKey := a.railKin() - seen, grown := map[string]bool{}, map[string]bool{} - var trees []*railTwig - for _, id := range a.taskOrder { - node := a.tasks[id] - if node == nil { +// railEntries is the roster's row model: each group that has anything in it, +// its heading, and its nodes under it unless it is folded. +func (a *app) railEntries() []railEntry { + members := a.railMembers() + out := make([]railEntry, 0, len(a.taskOrder)+len(railListOrder)) + for _, g := range railListOrder { + n := 0 + for _, node := range members[g] { + if a.railListed(node, g) { + n++ + } + } + if n == 0 { continue } - root := railRootOf(node, byKey) - key := stripKey(root) - if seen[key] { + shut := a.sideGroupShut(g) + out = append(out, railEntry{group: g, head: true, count: n, shut: shut}) + if shut { continue } - seen[key] = true - trees = append(trees, railGrow(root, kids, grown)) - } - return trees -} - -// railKinLive reports whether anything in this node's family is still moving or -// still waiting on somebody: it is the fold's default, and it is asked of the -// root ([app.railShut]). -func (a *app) railKinLive(node *taskNode) bool { - kids, _ := a.railKin() - return a.railTwigLive(railGrow(node, kids, map[string]bool{})) -} - -func (a *app) railTwigLive(t *railTwig) bool { - switch a.railGroupOf(t.node) { - case railAttention, railRunning, railIdle: - return true - } - if t.node.Paused() { - return true - } - for _, kid := range t.kids { - if a.railTwigLive(kid) { - return true + for _, node := range members[g] { + if a.railListed(node, g) { + out = append(out, railEntry{node: node, group: g}) + } } } - return false -} - -// railEntries is the roster's row model: every family, whole, under its own -// root, with the folded ones standing at one row each. -// -// THE FOREST IS THIS COLUMN'S WHOLE ACCOUNT OF WHO IS WORKING, and nothing is -// hung under it from the engine's live tree. It used to be: a second, smaller -// list of the same hands was attached beneath each row from -// [session.Agent.WorkingNow], keyed by the row's bare id — and it never once -// drew, because that door spells a worker `task:7`, `run:2` or `run:2/plan` -// (session's work_tree.go) and this column was asking it for "7". Fixing the -// spelling would not have fixed the surface, it would have started the double -// draw the broken key had been hiding: every worker in that tree ALREADY has a -// row of its own here. A graph node announces itself with the id of whatever -// spawned it (session's task_run.go) and an adaptive run registers a row for -// itself and one per planned node (its family seam), so both halves of the -// engine's tree arrive here as ordinary notices and [app.railForest] hangs them -// on their parents. The preview could only ever have restated them, in one mark -// and a name, under the fuller row that was already there. -// -// So the ownership rule, stated once: A WORKER IS DRAWN BY THE FAMILY THAT -// OWNS IT, on the row its own notice minted. -func (a *app) railEntries() []railEntry { - out := make([]railEntry, 0, len(a.taskOrder)) - for _, tree := range a.railForest() { - out = a.railWalk(out, tree, nil) - } return out } -// railWalk lays one family out, depth first. -func (a *app) railWalk(out []railEntry, t *railTwig, stems []bool) []railEntry { - e := railEntry{node: t.node, stems: stems, root: len(t.kids) > 0} - if e.root && a.railTwigShut(t) { - e.folded, e.hidden, e.worst = true, t.count(), a.railWorst(t) - return append(out, e) - } - out = append(out, e) - for i, kid := range t.kids { - // The stack is COPIED down rather than appended to in place: one backing - // array shared between two siblings is the second sibling drawing the - // first one's stems. - next := make([]bool, len(stems), len(stems)+1) - copy(next, stems) - out = a.railWalk(out, kid, append(next, i < len(t.kids)-1)) - } - return out -} - -// railColsFor is how wide the rail is at a frame width: full from railFloor, -// slim down to railSlimFloor, gone under that. -func railColsFor(width int) int { - switch { - case width >= railFloor: - return railCols - case width >= railSlimFloor: - return railSlimCols - } - return 0 -} - -// railColumns is [railColsFor] with the person's own answer folded in: a column -// somebody widened (w) takes [railWideCols], and only where the frame was -// already lending a full one. The floors are the frame's and the tier is the -// person's — a terminal that cannot afford thirty columns cannot afford -// forty-six either. +// railColumns is [sideColsFor] with the person's own answer folded in: a +// column somebody widened (alt+w) takes [railWideGain] more, and only where +// the frame was already lending a full one and the conversation keeps its +// floor. The floors are the frame's and the tier is the person's. +// +// IT DOES NOT ASK WHAT THE COLUMN SHOWS. Which word is in front, what is +// folded and what the band holds are all drawn inside these columns, so none +// of them moves the conversation (sidecol.go). func (a *app) railColumns(width int) int { - if a.railWide && width >= railFloor { - return railWideCols + cols := sideColsFor(width) + if cols > 0 && a.railWide && width >= railFloor { + cols = min(cols+railWideGain, width-sideBodyFloor) } - return railColsFor(width) + return cols } // railCanWiden reports whether the third tier is ON OFFER at this frame — the @@ -2945,8 +2692,12 @@ func (a *app) railCanWiden() bool { // longer does (taskview.go says why); what a directory with a history behind it // gets instead is one dim line at the foot of the column naming the page that // holds it ([taskSheetPastHint]). +// +// AND IT IS THE SAME COLUMN IN EVERY CHAT. A chat in a team has the team's +// Traffic in it as its second word (sidecol.go), and that changes what is +// drawn inside the column and never whether it stands or how wide it is. func (a *app) railShowing() bool { - if a.railAway || a.railQuiet() { + if a.sideAway() || a.railQuiet() { return false } width, _ := a.size() @@ -3001,7 +2752,12 @@ func (a *app) railQuiet() bool { // A JOB COUNTS. It is this conversation's work as much as a task is, and a // session that has only started a server still has a row the keyboard can // stand on (jobsection.go). -func (a *app) railAvail() bool { return len(a.taskOrder) > 0 || len(a.jobs) > 0 } +// +// AND SO DOES A TEAM. A chat in a team has the team's Traffic on this column +// (sidecol.go), which is rows to stand on whether or not it has run anything. +func (a *app) railAvail() bool { + return len(a.taskOrder) > 0 || len(a.jobs) > 0 || a.sideKind() != sideKindPlain +} // railFull reports whether the roster is drawn OVER the body rather than beside // it — the narrow frame's answer to the same key. @@ -3019,7 +2775,7 @@ func (a *app) railAvail() bool { return len(a.taskOrder) > 0 || len(a.jobs) > 0 // frame does with the request is a question about its width. One state cannot // disagree with itself about whether the roster is up. func (a *app) railFull() bool { - if !a.railHold || !a.railAvail() || a.railAway || a.railQuiet() { + if !a.railHold || !a.railAvail() || a.sideAway() || a.railQuiet() { return false } width, _ := a.size() @@ -3044,15 +2800,15 @@ func (a *app) railRoom() int { // column to put away. // // It is deliberately the exact complement of [app.railShowing] at every width -// that lends columns at all — one of the two is true whenever [railColsFor] is +// that lends columns at all: one of the two is true whenever [sideColsFor] is // positive — so the right-hand strip of the frame always belongs to the roster // in one of its two shapes, and never to nobody. func (a *app) railStowed() bool { - if !a.railAway || a.railQuiet() { + if !a.sideAway() || a.railQuiet() { return false } width, _ := a.size() - return railColsFor(width) > 0 + return sideColsFor(width) > 0 } // railWidth is what the rail costs the conversation, in columns: its own where @@ -3117,6 +2873,17 @@ func (a *app) railGripRows(height int) []string { if mark, hue := a.railGripState(); mark != "" && height > 1 { out[height/2-1] = " " + hue(mark) } + // AND TWO CELLS BELOW IT, HOW MUCH CAME IN ON THE TRAFFIC since the person + // last had it in front of them, in a chat in a team, while anything did. + if t, kind, handle := a.sideTeam(); kind != sideKindPlain && height > 2 { + if _, fresh := a.sideTrafficCount(t, kind, handle); fresh > 0 { + count := itoa(min(fresh, 99)) + if len(count) == 1 { + count = " " + count + } + out[height/2+1] = a.pal.dim(count) + } + } return out } @@ -3132,10 +2899,17 @@ func (a *app) railGripRows(height int) []string { // program's existing vocabulary for "wants you" and "moving" said in a single // column. The rail's own glyphs are a spinner and a tree, and neither is a thing // that fits in one static cell. +// +// THE TRAFFIC'S QUESTIONS COUNT AS A PERSON'S, because they are: whatever the +// band would carry in amber is what this cell says in amber (sidecol.go). func (a *app) railGripState() (string, func(string) string) { members := a.railMembers() + asked := false + if t, kind, handle := a.sideTeam(); kind != sideKindPlain { + asked = len(a.sideAsks(t, kind, handle)) > 0 + } switch { - case len(members[railAttention]) > 0: + case len(members[railAttention]) > 0 || asked: return a.linearMark(homeAskGlyph, homeAskASCII), a.pal.ask case len(members[railRunning]) > 0: return a.linearMark(homeLiveGlyph, homeLiveASCII), a.pal.accent @@ -3148,7 +2922,7 @@ func (a *app) railGripState() (string, func(string) string) { // [app.railAt]'s own bargain: a strip that answered a click it would not light // under the pointer is a strip that disagrees with itself about what it is. func (a *app) railGripAt(x, y int) bool { - if !a.railStowed() || x < a.bodyWidth() { + if !a.railStowed() || x < a.bodyWidth() || x >= a.bodyWidth()+a.railWidth() { return false } top := a.bodyTop() @@ -3183,36 +2957,22 @@ type railLine struct { plan string // entry indexes [app.railEntries], or -1 for the padding and the footer. entry int - // head says this is the entry's FIRST line, which is the one a marker goes - // on: a two-line node with two markers would read as two nodes. + // head says this is the entry's line a marker goes on. Every entry is one + // line now, so it is every entry's line; it is kept for the run's own rows + // spliced among them ([app.railDrawnView]), which are not. head bool - // glyph is the row's FOLD CELL in the column's own coordinates, and badge the - // ▸ +N a folded root wears. They are written at LAYOUT and read by the click, - // which is the bargain the strip's chips make (taskstrip.go): the geometry is - // recorded where it is decided, because a hit-test that recomputed it would - // be measuring a row the frame has not drawn. - // - // glyph IS EMPTY ON EVERY FRAME WHERE THAT CELL IS NOT A CONTROL, which is - // most of them: the cell holds the row's state until the pointer is on a row - // that can fold, and only then does it become ▾ or ▸ ([app.railLead] says - // why the press may not work this out for itself). An empty span is a span - // that holds no column, so the cells fall to the row and the row is the - // node's door. - glyph hudSpan - badge hudSpan + // side is one of the side column's own rows: its header, a band item, or a + // row of the Traffic (sidecol.go), with the doors on it and what a press + // does. nil on every roster line. + side *sideRow // hint says this line is the footer's widen offer, which is pressable and // belongs to no entry. hint bool - // stow marks the pinned first line, the column's own door - // ([railStowHint]). It is a second flag rather than a kind on the line above - // because both can be drawn at once and a press has to tell them apart: one - // changes the column's width and the other takes it off the frame. - stow bool // more says this line is the footer's door onto the TASK PAGE - // ([taskSheetMoreHint] or [taskSheetPastHint], taskview.go) — a third flag for - // the second one's reason: all three can be drawn at once, and a press has to - // know whether it was asked to widen the column, to hide it, or to leave it - // for a page that holds work this session never ran. + // ([taskSheetPastHint], taskview.go), a flag of its + // own because all of the footer's lines can be drawn at once, and a press has + // to know whether it was asked to widen the column or to leave it for a page + // that holds work this session never ran. more bool // keeping says this line is the footer's standing count, whose door is // /standing (standdoor.go). It is a fourth flag for the third one's reason: @@ -3255,16 +3015,9 @@ type railLine struct { // railLines renders every entry, in order. It is the unwindowed list, and the // window is taken out of it by [app.railView]. func (a *app) railLines(entries []railEntry, width int) []railLine { - out := make([]railLine, 0, len(entries)+len(entries)/2) + out := make([]railLine, 0, len(entries)) for i := range entries { - rows, glyph, badge := a.railEntryRows(entries[i], width) - for j, text := range rows { - line := railLine{text: text, entry: i, head: j == 0} - if j == 0 { - line.glyph, line.badge = glyph, badge - } - out = append(out, line) - } + out = append(out, railLine{text: a.railEntryRow(entries[i], width), entry: i, head: true}) } return out } @@ -3297,18 +3050,34 @@ func (a *app) railView(height int) ([]railLine, int) { if height <= 0 || !a.railStanding() { return nil, -1 } - // The hide control belongs to the sidebar, outside every scrolling list - // and task panel. Neither a new task nor a deeper page may displace it. - var head []railLine - if !a.railFull() && ansi.StringWidth(a.railDoorHint())+2 <= a.railRoom() { - head = append(head, railLine{text: a.railDoorLine(), entry: -1, stow: true}) + // THE HEADER AND THE BAND BELONG TO THE COLUMN, outside every scrolling + // list and task panel, so neither a new task, a deeper page nor the other + // word may displace them (sidecol.go). + room := a.railRoom() + head := a.sideHead(room) + if len(head) > height { + head = head[:height] } if a.roomOpen() && len(head) < height { word := a.icon(tokens.GScopeUp) + " " + railMainWord - head = append(head, railLine{text: a.pal.accent(fit(word, a.railRoom())), entry: -1, roomAction: railMainAction}) + head = append(head, railLine{text: a.pal.accent(fit(word, room)), entry: -1, roomAction: railMainAction}) + } + a.side.pinned = len(head) + if a.sideView() == sideTraffic { + rows, _ := a.sideTrafficView(height - len(head)) + out := make([]railLine, 0, height) + out = append(append(out, head...), rows...) + for len(out) < height { + out = append(out, railLine{entry: -1}) + } + a.sideRemember(out) + return out, -1 } + a.side.up = "" rows, focus := a.railContentView(height - len(head)) - return append(head, rows...), focus + out := append(head, rows...) + a.sideRemember(out) + return out, focus } func (a *app) railContentView(height int) ([]railLine, int) { @@ -3322,15 +3091,9 @@ func (a *app) railContentView(height int) ([]railLine, int) { entries := a.railEntries() focus := a.railFocusIndex(entries) - // THE LINES ARE LAID OUT BEFORE THE FOOTER IS ASKED FOR, which is the one - // ordering this function is not free to choose: whether the footer offers the - // wide tier is a fact about what the rows did to their titles, and a footer - // built first would be answering it about the frame before this one - // ([app.railFootRows]). - a.railCramped = false - // A SECTION EARNS ITS LABEL FROM A REAL ROW. The typeable doors remain when - // nothing exists, while the emptiness law spends no pixels naming absence. - head := a.marginHead(room, len(entries) > 0) + // THE GROUPS STAND STRAIGHT UNDER THE HEADER, which already names the + // column and counts its work (sidecol.go). + var head []railLine lines := a.railLines(entries, room) foot, marks := a.railFootRows(room, height) body := height - len(foot) @@ -3418,62 +3181,6 @@ func (a *app) railContentView(height int) ([]railLine, int) { return out, focus } -// railMovingHead is how many lines at the top of the list belong to work that is -// MOVING — running right now, or standing still waiting on a person. -// -// IT IS THOSE TWO GROUPS AND NOT EVERY LIVE ONE, which is the difference between -// a head that stays small and a head that eats the column. What is running at -// once is bounded by the slots the executor has, and what is waiting on a person -// is bounded by the person; what is QUEUED is bounded by nothing at all — one -// plan can admit a hundred nodes in a breath — so a head that pinned the idle -// group would pin the whole window the first time somebody started an adaptive -// run. Queued work is a promise and promises can wait their turn in a scroll. -// -// It is the count through the LAST such line rather than the length of an -// unbroken run, because a family is drawn whole: a settled child sitting between -// two running siblings is part of the live shape, and a head that stopped at it -// would pin half a tree. Families with nothing live in them sort below every -// family that has ([app.railForest]), so what this measures is the moving region -// and not the whole column. -// -// A FOLDED ROOT COUNTS FOR WHAT IT IS HIDING. One row standing for a subtree -// with something running in it is that running work as far as this column is -// concerned, which is the same fact its glyph already carries ([app.railWorst]). -func (a *app) railMovingHead(lines []railLine, entries []railEntry) int { - head := 0 - for i, line := range lines { - if line.entry < 0 || line.entry >= len(entries) { - continue - } - if a.railEntryMoving(entries[line.entry]) { - head = i + 1 - } - } - return head -} - -// railEntryMoving reports whether one drawn row is work that is running or -// waiting on a person, its hidden descendants included. -func (a *app) railEntryMoving(e railEntry) bool { - if e.node == nil { - return false - } - nodes := []*taskNode{e.node} - if e.folded && e.worst != nil { - nodes = append(nodes, e.worst) - } - for _, node := range nodes { - switch a.railGroupOf(node) { - case railAttention, railRunning: - return true - } - if node.Paused() { - return true - } - } - return false -} - // railDrawnView is the column AS IT IS DRAWN: [app.railView] with a run's own // rows put in their place. IT IS THE ONE ANSWER TO "WHAT IS ON THIS SCREEN ROW", // for the frame and for the pointer alike. The rows used to be spliced in by the @@ -3482,8 +3189,8 @@ func (a *app) railEntryMoving(e railEntry) bool { // press on a task opened nothing or opened its neighbour. func (a *app) railDrawnView(height int) ([]railLine, int) { view, focus := a.railView(height) - if len(view) == 0 { - return nil, focus + if len(view) == 0 || a.sideView() == sideTraffic { + return view, focus } // THE TREES COME OUT OF THE READING THE PLACE ALREADY HOLDS, never out of the // store: this is a frame, and a frame never reads the disk. The reading is @@ -3551,8 +3258,8 @@ func (a *app) railDrawnView(height int) ([]railLine, int) { // A NODE ROW THAT CARRIES A RUN IS THAT RUN'S ROW. The door that takes the // run road publishes a node row for the run's own task, naming it // ([taskNode.planTask]) — and an older row is matched by the title it - // wears. That row is kept, drawn as the head of a family, and the run's - // parts hang under it: one piece of work, one row. + // wears. That row is kept, and the run's parts hang under it, a level in: + // one piece of work, one row. carrier := make(map[string]int) for _, line := range view { node := nodeOf(line) @@ -3579,7 +3286,7 @@ func (a *app) railDrawnView(height int) ([]railLine, int) { kids = append(kids, block.self.kids...) } if at, ok := carrier[run]; ok { - under[at] = append(under[at], a.planRailLines(kids, entries[at].stems, entries[at].root, width)...) + under[at] = append(under[at], a.planRailLines(kids, 1, width)...) continue } if block.self != nil { @@ -3610,37 +3317,19 @@ func (a *app) railDrawnView(height int) ([]railLine, int) { continue } if node != nil && carried[line.entry] { - if !line.head { - continue - } - // THE CARRIER IS DRAWN AGAIN AS THE HEAD OF ITS FAMILY, by the - // same renderer, so its under-block keeps the stem the parts - // below it hang from. - e := entries[line.entry] - kids := len(under[line.entry]) > 0 - if kids && !e.folded { - e.root = true - } - rows, glyph, badge := a.railEntryRows(e, width) - for j, text := range rows { - redrawn := line - redrawn.text, redrawn.head = text, j == 0 - if j == 0 { - redrawn.glyph, redrawn.badge = glyph, badge - } else { - redrawn.glyph, redrawn.badge = hudSpan{}, hudSpan{} - } - next = append(next, redrawn) - } - if !e.folded { - next = append(next, under[line.entry]...) - } + // THE CARRIER KEEPS ITS ONE LINE, and the run's parts hang under + // it, a level in: a task on this column is one line (sidecol.go). + next = append(next, line) + next = append(next, under[line.entry]...) continue } next = append(next, line) } if !placed { - next = append(append([]railLine{}, ahead...), next...) + // UNDER THE HEADER AND THE BAND, which stand at the top of every + // view (sidecol.go), and ahead of the rest. + at := min(a.side.pinned, len(next)) + next = append(append(append([]railLine{}, next[:at]...), ahead...), next[at:]...) } if len(next) > height { next = next[:height] @@ -3696,7 +3385,10 @@ func (a *app) railRows(height int) []string { // the label (jobHere below), so the keyboard's place is not silent. jobHere := (a.railWhere.jobs && line.jobs) || (a.railWhere.job != 0 && line.job == a.railWhere.job) jobRowHere := a.railWhere.job != 0 && line.job == a.railWhere.job - if (focus >= 0 && line.head && line.entry == focus) || jobRowHere { + // A ROW OF THE SIDE COLUMN'S OWN IS HELD BY ITS KEY, the band's and the + // Traffic's alike (sidecol.go). + sideHere := a.railHold && line.side != nil && a.railWhere.key != "" && line.side.key == a.railWhere.key + if (focus >= 0 && line.head && line.entry == focus) || jobRowHere || sideHere { lead = a.pal.accent(a.linearMark(railMark, railMarkASCII)) } text := line.text @@ -3709,9 +3401,7 @@ func (a *app) railRows(height int) []string { // It is [palette.selected] and not a new mark — the same background the strip // puts on the chip of the room a person is standing in (taskstrip.go's // [app.stripChip]), and the same one every selected row on this surface - // wears (palette.go). It covers EVERY line of the entry, not just its head: - // a node's row is two lines tall when it has something to say under its - // title, and a band on half of it would read as a row cut in two. + // wears (palette.go), and it covers the whole row. // // AND EVERY NODE ROW TAKES THE HOVER STEP, because every node row answers // to a click — the whole row is that node's door (hover.go's own law). It @@ -3727,7 +3417,20 @@ func (a *app) railRows(height int) []string { if line.entry >= 0 && line.entry < len(entries) { node = entries[line.entry].node } + var head railEntry + if line.entry >= 0 && line.entry < len(entries) && entries[line.entry].head { + head = entries[line.entry] + } switch { + case line.side != nil && a.sideHovering(line.side.key): + // THE HOVER GROUND COVERS THE WHOLE ROW, padding and time included, + // because the whole row is what a press on it answers. + text = a.hoverRow(text, room) + case sideHere: + text = a.pal.cursor(text, room) + case line.side != nil: + case head.head && a.hot.kind == hoverRailGroup && a.hot.index == int(head.group): + text = a.hoverRow(text, room) case line.roomAction != "" && a.hot.kind == hoverRoomControl && a.hot.key == line.roomAction: text = a.hoverRow(text, room) case a.roomStandingOn(node): @@ -3756,11 +3459,6 @@ func (a *app) railRows(height int) []string { // pressable line here takes it on: it answers to a click, so the pointer // says so ([taskSheetPastHint], taskview.go). text = a.hoverRow(text, room) - case line.stow && a.hoveringRailDoor(): - // AND THE COLUMN'S OWN DOOR TAKES IT TOO, on the terms every other - // pressable line here takes it on: it answers to a click, so the pointer - // says so ([app.railDoorLine]). - text = a.hoverRow(text, room) case line.keeping && a.hoveringRailStanding(): // AND THE STANDING COUNT, which is a door onto /standing and says so // twice for the margin door's reason: its own ink comes up @@ -3839,7 +3537,10 @@ func (a *app) railNodeAt(y int) *taskNode { // railFocusAt finds the entry a spot names, or -1. func railFocusAt(entries []railEntry, spot railSpot) int { for i, e := range entries { - if e.node != nil && e.node.id == spot.id { + switch { + case spot.group > 0 && e.head && int(e.group)+1 == spot.group: + return i + case spot.group == 0 && spot.id != 0 && e.node != nil && e.node.id == spot.id: return i } } @@ -3847,26 +3548,24 @@ func railFocusAt(entries []railEntry, spot railSpot) int { } // railFocusIndex is where the cursor is in the current entry list, or -1 when -// the roster does not have the keyboard. +// the roster does not have the keyboard, or has it on a row of the side +// column's own (sidecol.go). // -// THE CURSOR FOLLOWS THE WORK AND THEN THE FAMILY. A node that lands does not -// move any more — a family is drawn where it always was — but a fold closing -// over it does, and that is now the one way a focused row leaves the list. Where -// its rows went is its nearest drawn ancestor, which is exactly the row standing -// for it, so that is where the cursor stands. +// THE CURSOR FOLLOWS THE WORK AND THEN ITS GROUP. A node that moves from +// running to done moves its row, and the cursor goes with it; a fold closing +// over it takes its row away, and then the cursor stands on the heading that +// is standing for it. func (a *app) railFocusIndex(entries []railEntry) int { - if !a.railHold || a.railWhere.onJobs() || len(entries) == 0 { + if !a.railHold || a.railWhere.onJobs() || a.railWhere.key != "" || len(entries) == 0 { return -1 } if at := railFocusAt(entries, a.railWhere); at >= 0 { return at } - if node := a.tasks[a.railWhere.id]; node != nil { - _, byKey := a.railKin() - for up := byKey[node.ParentID()]; up != nil; up = byKey[up.ParentID()] { - if at := railFocusAt(entries, railSpot{id: up.id}); at >= 0 { - return at - } + if node := a.tasks[a.railWhere.id]; node != nil && a.railWhere.group == 0 { + g := a.railGroupOf(node) + if at := railFocusAt(entries, railSpot{group: int(g) + 1}); at >= 0 { + return at } } // The node itself is gone — /new, or a session that dropped it. The top of the @@ -3894,15 +3593,27 @@ func (a *app) railTake(hold bool) { // it back: remembered. a.railStow(false) } + if !hold && a.railFull() { + // The overlay goes with the hold, and the Traffic's `new` line with it. + a.side.up = "" + } a.railHold = hold if hold { // WHERE THE CURSOR LANDS IS THE FIRST ROW THERE IS. The key is refused // outright on a column with no rows of this session's ([app.railAvail]), so // there is always one to land on — a task, or the jobs section when // that is the work this conversation has. + // A ROW OF WORK BEFORE A HEADING: the heading is what the rows under it + // are filed by, and the person asked for the work. spots := a.railSpots() if railSpotAt(spots, a.railWhere) < 0 && len(spots) > 0 { a.railWhere = spots[0] + for _, spot := range spots { + if spot.group == 0 { + a.railWhere = spot + break + } + } } } a.touch() @@ -3963,8 +3674,8 @@ func (a *app) railKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { // THE ONE KEY THAT ANSWERS WITH THE COLUMN ITSELF. It is read before the // hold below because it is true in both postures — a column that is up goes // away, a column that is away comes back — and it is the only key on this - // map a person may press without having asked for the roster first. - // + // map a person may press without having asked for the roster first. It is + // the older name of [sideHideKey], which the column's header names. // IT ONLY ACTS ON A ROSTER THAT IS ON THE FRAME, or on one it has already // taken off. The column stands empty now ([app.railShowing]), so "on the // frame" no longer needs any tasks behind it — a column carrying nothing but @@ -3974,10 +3685,10 @@ func (a *app) railKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { // alt+t does. A keystroke that silently moved a state nothing is drawing is a // keystroke a person cannot tell they pressed, and this one would move it into // the NEXT session as well. - if !(a.railStanding() || a.railAway) { + if !(a.railStanding() || a.railAway || a.railStowed()) { return nil, false } - a.railStow(!a.railAway) + a.railStow(!a.railStowed()) return nil, true } if key == railHoldChord { @@ -4015,11 +3726,12 @@ func (a *app) railKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { case "down": a.railMove(1) return nil, true - case "right": - a.railOut() - return nil, true - case "left": - a.railIn() + case "right", "left": + // ← AND → MOVE BETWEEN THE HEADER'S TWO WORDS, in a chat in a team, + // which is what they are for on every strip of words on this surface. + // In a chat with one word they are eaten and do nothing, so an arrow + // meant for the column never moves the draft's caret instead. + a.sideStep() return nil, true case railWidenChord: // WIDEN, IN THE ONE SPELLING NOTHING CAN EAT. It used to be the bare @@ -4065,7 +3777,7 @@ func (a *app) railKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { // holding a rail focus they cannot see. The rail's rule is that explicit // focus outranks ambient place, and this is that rule applied to one more // key; the way out is esc, which the hint already advertises - // ([railHoldHint]). + // ([railHoldKeys]). return nil, true } // THE ANSWERS TO THE ONE QUESTION A ROW CAN BE ASKING ARE NOT TAKEN HERE. @@ -4095,13 +3807,18 @@ func (a *app) railMove(delta int) { a.touch() } -// railSpots is every row the keyboard walks: this conversation's work, then -// the jobs section under it. One walk, so enter on the jobs label is the -// same key that opens a task, and a person who held ↓ off the last family -// lands on the section that is actually next. +// railSpots is every row the keyboard walks, in the order the column draws +// them: the band, then the view in front. In the tasks that is this +// conversation's work and then the jobs section under it; one walk, so enter +// on the jobs label is the same key that opens a task, and a person who held +// ↓ off the last group lands on the section that is actually next. In the +// Traffic it is its rows (sidecol.go). func (a *app) railSpots() []railSpot { + out := a.sideSpots() + if a.sideView() == sideTraffic { + return out + } entries := a.railEntries() - out := make([]railSpot, 0, len(entries)+len(a.jobs)+1) for _, e := range entries { out = append(out, railSpotOf(e)) } @@ -4111,11 +3828,17 @@ func (a *app) railSpots() []railSpot { func railSpotAt(spots []railSpot, want railSpot) int { for i, s := range spots { switch { + case s.key != "" || want.key != "": + if s.key == want.key { + return i + } case s.jobs && want.jobs: return i case s.job != 0 && s.job == want.job: return i - case !s.onJobs() && !want.onJobs() && s.id != 0 && s.id == want.id: + case s.group != 0 && s.group == want.group: + return i + case !s.onJobs() && !want.onJobs() && s.group == 0 && want.group == 0 && s.id != 0 && s.id == want.id: return i } } @@ -4166,80 +3889,6 @@ func (a *app) railScroll(delta int) { } } -// railCursorTo parks the cursor at one row of that list. -func (a *app) railCursorTo(entries []railEntry, at int) { - if at < 0 || at >= len(entries) { - return - } - a.railWhere = railSpotOf(entries[at]) -} - -// railOut is →, and it is the tree grammar every file manager a person has used -// spells the same way: on a folded root it OPENS the family, and on a family -// already open it steps INTO it, onto the first child. -// -// ON A LANDED ROW IT OPENS THE ROW'S OWN BLOCK, which is the same grammar one -// scale down: → is "show me what is inside this", and what is inside a row that -// has come home is the branch it kept or the log it wrote ([app.railTucks]). On -// anything else it does nothing — there is nothing further out to go. -func (a *app) railOut() { - entries := a.railEntries() - at := a.railFocusIndex(entries) - if at < 0 { - return - } - e := entries[at] - if !e.root { - if a.railTuckShut(e.node) && a.railTucks(e) { - a.railSetOpen(e.node, true) - } - return - } - if e.folded { - a.railSetOpen(e.node, true) - return - } - if at+1 < len(entries) { - a.railWhere = railSpotOf(entries[at+1]) - a.touch() - } -} - -// railIn is ←, and it is the mirror: on an open root it FOLDS the family, on a -// landed row whose block is showing it tucks the block back away, and anywhere -// else it walks up to the parent row. -// -// THE CURSOR NEVER STAYS ON A ROW THE FOLD TOOK AWAY. Folding from the root -// leaves it on the root, which is the row the family is now standing in; jumping -// from a leaf leaves it on the parent, which is the row a second ← will fold. -func (a *app) railIn() { - entries := a.railEntries() - at := a.railFocusIndex(entries) - if at < 0 { - return - } - e := entries[at] - if e.root && !e.folded { - a.railSetOpen(e.node, false) - return - } - if !e.root && !a.railTuckShut(e.node) && a.railTucks(e) { - a.railSetOpen(e.node, false) - return - } - depth := len(e.stems) - if depth == 0 { - return - } - for i := at - 1; i >= 0; i-- { - if len(entries[i].stems) < depth { - a.railWhere = railSpotOf(entries[i]) - a.touch() - return - } - } -} - // railWiden takes the third width tier, or gives it back. It is sticky — a // person who widened the column meant to keep it — and it goes with the nodes // when the session does ([app.dropTasks]). @@ -4279,11 +3928,28 @@ func (a *app) railWiden(wide bool) { // session opens where the last one was told to, which is the behaviour of a // session that has never been told anything. func (a *app) railStow(away bool) { + // ON THE TEAMS PAGE THE ANSWER IS THE PAGE'S, and it is not written: the + // page opens with the column folded because it has a rail of its own on + // the left (teamspagehost.go). + if a.teamsHosting() { + if a.tp.traffic == !away { + return + } + a.tp.traffic = !away + if away { + a.railHold = false + a.side.up = "" + } + a.dropHover() + a.touch() + return + } if a.railAway == away { return } a.railAway = away if away { + a.side.up = "" // THE KEYBOARD GOES BACK TO THE DRAFT WITH THE COLUMN. A hold left standing // on a roster that is not drawn is six keys taken from the box by a list // nobody can see, and [app.railFull] would raise the overlay the moment the @@ -4298,36 +3964,37 @@ func (a *app) railStow(away bool) { // row under it — the same law the task page states ([app.taskSheetEnter], // taskview.go), because these are two lists of the same work. // -// A NODE THIS SESSION HOLDS OPENS ITS ROOM. Folding has its own two keys, which -// is what took the overload off this one. +// A NODE THIS SESSION HOLDS OPENS ITS ROOM, and a group's heading opens the +// group or folds it, which is what a press on either does. Work an earlier +// conversation ran has no room and never will: a room is a live lane onto a +// node in this session's graph, and it is reached through the task page +// instead, where enter goes inside its card (taskrecord.go). // -// EVERY ROW OF THIS COLUMN IS SUCH A NODE, so that is the whole of what this key -// does. Work an earlier conversation ran has no room and never will — a room is a -// live lane onto a node in this session's graph — and it is reached through the -// task page instead, where enter goes inside its card (taskrecord.go). +// A ROW OF THE COLUMN'S OWN DOES WHAT A PRESS ON IT DOES: a band item opens +// its task or goes to its message, and a work thread lays its replies open or +// folds them (sidecol.go). func (a *app) railEnter() tea.Cmd { + if a.railWhere.key != "" { + return a.sideRowAct(a.railWhere.key) + } entries := a.railEntries() at := a.railFocusIndex(entries) - if at < 0 || entries[at].node == nil { + if at < 0 { + return nil + } + if entries[at].head { + a.sideToggleGroup(entries[at].group) return nil } + if entries[at].node == nil { + return nil + } + a.sideAck(entries[at].node) return a.openRailRoom(entries[at].node) } // ── the footer ────────────────────────────────────────────────────────────── -// railFootOrder is the order the footer counts the groups in, and it is not the -// column's order: the column leads with what is asking for a decision because -// that is where the eye starts, and the footer leads with what is HAPPENING -// because a total is read as a state of the session. -var railFootOrder = [railGroupCount]railGroup{railRunning, railAttention, railIdle, railParked, railDone} - -// railFootMax is how many lines the footer may spend on the COUNTS. Three is -// the whole aggregate at the full width; a fourth would be the column reporting -// on itself. The standing line, the doors and the offer are each measured -// against the height on their own. -const railFootMax = 3 - // railFootMarks is where the footer's pressable lines landed, as indices into // the rows it returns, or -1 for a line this frame did not draw. // @@ -4341,61 +4008,25 @@ type railFootMarks struct { // missing. var noRailFoot = railFootMarks{hint: -1, more: -1, keeping: -1} -// railFootRows is the aggregate: what the window cannot show, said once at the -// bottom of the column. +// railFootRows is the foot of the column: the standing count, the door onto +// the task page, and the offer of the wide tier, each only when it is true. // -// 3 running · 1 needs you -// 148 waiting · 12 done // ◦ 2 standing orders +// earlier ▸ // -// THE Σ IS GONE WITH THE MONEY IT LED. It meant "this is a SUM, including what -// the column folded away", and it earned that while the first line was -// `Σ $1.42 · 312k tok`. The bill left this foot for the status row on -// 2026-09-09 — one number drawn twice on one frame — and a sigma in front of a -// row of counts is a mathematician's mark on a tally: the counts are counts, -// they say so in words, and nothing about them needs a symbol to be believed. -// -// AND THE GROUP WORDS OUTLIVED THE GROUPS. The column stopped filing nodes under -// five headings ([app.railEntries] draws families now), and the five words are -// still the vocabulary a person has for what a session is doing — so the count -// of each is what the bottom of the column says, across every node in the -// forest, folded or not. -// -// IT ALSO CARRIES THE ONE CONTEXTUAL OFFER ON THIS SURFACE. When a title is -// being cut by its own indent and the frame could lend the wide tier, the last -// line of the footer says so ([railWideHint]) — and it says it only then. A -// permanent "w widens" is chrome charged to every session that never grew a -// tree. It reports which of its lines that offer landed on, or -1, because the -// line is pressable and the press has to know where it was drawn. +// THE COUNTS OF EACH GROUP ARE NOT HERE ANY MORE. They were the foot's first +// lines for as long as the column drew families, which scattered the groups; +// the groups are the column's own headings now, each with its count on it, and +// the header's `Tasks N` says the whole (sidecol.go). // // AND THE STANDING COUNT IS A LINE OF IT SINCE 2026-09-09 ([app.railStandingLine], -// standdoor.go). It was a segment of the status row; it belongs here, under the -// counts of what this column is holding, because it is the same question those -// counts answer — what is alive on this project — and because this column is -// where a person already looks for it. It keeps everything it had: it is drawn -// only when something stands here, its mark breathes while a pass has one of -// those orders in its hands, and pressing it opens /standing. +// standdoor.go). It keeps everything it had: it is drawn only when something +// stands here, its mark breathes while a pass has one of those orders in its +// hands, and pressing it opens /standing. func (a *app) railFootRows(width, height int) ([]string, railFootMarks) { if width < 8 || height < 4 { return nil, noRailFoot } - var segs []string - // THE BOOKS DECIDE WHETHER A FIGURE IS DRAWN AND THE CLOCK DECIDES WHAT IT - // SAYS. The guards ask the exact totals, because the emptiness law is about - // whether there is anything to report; the figures themselves come off the - // eased readings, so this foot counts up with the status line rather than - // jumping beside it (reveal.go). - // THE MONEY IS NOT HERE ANY MORE. It was the session's whole bill, and so - // is the figure at the left of the status row two lines down — one number - // drawn twice on one frame, and the second copy cost the column two of its - // three lines. The foot counts what the column holds; the bill is the - // status row's (foot.go). - members := a.railMembers() - for _, g := range railFootOrder { - if n := len(members[g]); n > 0 { - segs = append(segs, itoa(n)+" "+railGroupWords[g]) - } - } // IN THIS TERMINAL'S OWN SPELLING of the modifier (chords.go), because the // offer names a chord now rather than a bare letter and a Mac calls that // modifier Option. @@ -4407,20 +4038,11 @@ func (a *app) railFootRows(width, height int) ([]string, railFootMarks) { // THE DOOR ONTO THE TASK PAGE IS OFFERED ONLY WHEN THERE IS MORE BEHIND IT, // which is the emptiness law applied to an affordance rather than to a figure. // A door on a column that is already showing everything is a row that promises - // a page and delivers the list you were looking at. - // - // AND IT WEARS THE NAME OF WHAT IS BEHIND IT. A project with a record says - // `earlier`, because that is the section the page opens on and the word a - // person is looking for; a column whose only held-back thing is a family it - // folded says `view more`, because there is no earlier work to promise - // ([taskSheetPastHint] and [taskSheetMoreHint], taskview.go). It is ONE door - // either way — one line, one press, one page. - record := a.railHasRecord() - viewText := taskSheetMoreHint - if record { - viewText = taskSheetPastHint - } - view := ansi.StringWidth(viewText) <= width && (record || a.railFoldedAny()) + // a page and delivers the list you were looking at. What is behind it is + // the project's record, so it says `earlier` ([taskSheetPastHint], + // taskview.go): a group the column folded is one press away on the column. + viewText := taskSheetPastHint + view := ansi.StringWidth(viewText) <= width && a.railHasRecord() // THE STANDING LINE IS DRAWN ONLY WHERE SOMETHING STANDS, which is the // emptiness law the segment already kept on the status row: a permanent // `0 standing orders` is a permanent reminder of the absence of a thing @@ -4429,38 +4051,28 @@ func (a *app) railFootRows(width, height int) ([]string, railFootMarks) { if ansi.StringWidth(standWord) > width { standWord = "" } - if len(segs) == 0 && standWord == "" && !offer && !view { + if standWord == "" && !offer && !view { return nil, noRailFoot } - // The footer never takes more than a third of the column: a roster that is - // mostly its own summary has stopped being a roster. - rooms := min(railFootMax, height/3) - lines := railPack(segs, width, rooms) - out := make([]string, 0, len(lines)+2) + out := make([]string, 0, 4) // ONE BLANK ABOVE IT, when the column can lend one — whitespace is how this // surface separates blocks, and a rule across a two-cell column would be a // border on a seam. - if len(lines)+1 < height { + if height > 4 { out = append(out, "") } - for _, line := range lines { - out = append(out, a.pal.dim(line)) - } marks := noRailFoot - // THE STANDING COUNT GOES DIRECTLY UNDER THE TALLY, because it is the last of - // the counts: three lines saying what this project is holding, and then the - // doors and the offers about the column itself. + // THE STANDING COUNT GOES FIRST, because it says what this project is + // holding, and then the doors and the offers about the column itself. if standWord != "" && len(out)+1 < height { marks.keeping = len(out) out = append(out, a.railStandingLine()) } - // THE PAGE'S DOOR GOES DIRECTLY UNDER THE TALLY, above the width offer. - // The counts say what this session has, the door says where the rest of it - // is, and widening answers "how much of my screen is this taking". A person - // reading the tally and wanting more finds the next line saying so. + // THE PAGE'S DOOR GOES ABOVE THE WIDTH OFFER. The door says where the rest + // of the work is, and widening answers "how much of my screen is this + // taking". // - // IT IS DIM, which is the same weight the tally above it wears and the - // footnoted record rows used to. A door onto a month of other people's + // IT IS DIM, the weight the footnoted record rows used to wear. A door onto a month of other people's // afternoons is not a thing this column should raise its voice about; it is a // thing it should never fail to mention. if view && len(out)+1 < height { @@ -4495,69 +4107,6 @@ func (a *app) railStandingLine() string { return a.pal.dim(a.keepingWord()) } -// railDoorLine is the standing column's own door as it is drawn: the chevron -// that closes it, and then the chord only while the chord does the same thing. -// -// THE CHEVRON IS THE CONTROL AND THE WORDS ARE THE LABEL, which is why they are -// painted at two weights. `ctrl+g hide` tells the hand that types chords what to -// press only while no foreground command owns that key; with one running, the -// label is simply `hide`. The `❯` is what the hand that does NOT type chords -// presses either way, so it takes the ink — the same split the closed edge makes -// at the other end of the cycle ([app.railGripRows]). -// -// IT POINTS RIGHT AND ITS TWIN POINTS LEFT, and between them the pointer can go -// round the whole cycle: `❯` sends the column off the right edge, `❮` brings it -// back over the conversation. One control, two states, and neither of them a -// chord somebody had to be told about. -func (a *app) railDoorLine() string { - mark := a.linearMark(railGripOpenGlyph, railGripOpenGlyphASCII) - ink := a.pal.ink - if a.hoveringRailDoor() { - ink = a.pal.accent - } - return ink(mark) + " " + paintHint(a.railDoorHint(), a.pal, a.pal.dim) -} - -// railDoorHint names only the keyboard action available on this frame. The -// pointer's chevron still hides the column while a command owns ctrl+g, so the -// verb stays and only the unavailable chord comes off the line. -func (a *app) railDoorHint() string { - if a.promotableRow() >= 0 { - return "hide" - } - return railStowHint -} - -// railDoorAt reports whether a pointer is on that line. It is the hover's guard, -// and the press resolves the same fact through [railLine.stow] — one geometry -// asked twice, because the line is found by the layout either way. -func (a *app) railDoorAt(x, y int) bool { - if !a.railAt(x, y) || a.railSeamAt(x, y) { - return false - } - line, ok := a.railLineAt(y) - return ok && line.stow -} - -// railFoldedAny reports whether the column is standing one row for a family it -// has folded — which is the SECOND of the two things that earn the footer's door -// onto the task page, the first being the project's own record -// ([app.railHasRecord], taskview.go). -// -// A folded family is work the column is deliberately not drawing and the page -// draws every family whole, so the door is honest. A landed node of this -// session's, drawn on the column and listed again on the page, earns nothing: -// that is the same row said twice, and a line offering to show you what you are -// already looking at is chrome. -func (a *app) railFoldedAny() bool { - for _, e := range a.railEntries() { - if e.folded { - return true - } - } - return false -} - // railMoreAt reports whether a pointer is on the footer's door onto the task // page. It is the hover's guard, and the press resolves the same fact through // [railLine.more] — one geometry asked twice, because the line is found by the @@ -4570,455 +4119,109 @@ func (a *app) railMoreAt(x, y int) bool { return ok && line.more } -// railOffersResize reports whether the footer should name the handle. A cut -// title earns the offer on its own; focus and the pointer make it visible while -// a person is already acting on the roster. The frame still has the final say. +// railOffersResize reports whether the footer should name the handle: while a +// person is already acting on the roster, with the keyboard or the pointer. +// The frame still has the final say. func (a *app) railOffersResize() bool { if !a.railCanWiden() { return false } // The task panel reserves its footer before laying out the tree. Hover may // recolor that footer, but must never add a row and move the controls. - return a.roomOrganized() || a.railCramped || a.railHold || a.hoveringRailArea() -} - -// railPack folds the footer's segments into at most rooms lines of at most width -// cells, joined by this surface's own separator. -// -// A segment that will not fit is DROPPED and the fold is said out loud with the -// ellipsis this surface truncates everything with: a footer that silently stops -// counting is a footer that claims the session is smaller than it is. -// -// IT TAKES NO LEAD ANY MORE. It had one — `Σ `, on the first line only — for as -// long as the first line was the session's bill; the counts that are left say -// what they are in words ([app.railFootRows] says why the sigma went). -func railPack(segs []string, width, rooms int) []string { - if rooms < 1 || width < 1 { - return nil - } - out := make([]string, 0, rooms) - line := "" - for _, seg := range segs { - add := seg - if line != "" { - add = railSep + seg - } - if ansi.StringWidth(line)+ansi.StringWidth(add) <= width { - line += add - continue - } - // A FIRST SEGMENT TOO WIDE FOR THE COLUMN IS CUT RATHER THAN DROPPED: a - // count is still worth reading with its tail folded, and dropping it would - // leave the line under it claiming to be the first thing this session has. - if line == "" { - line = fit(seg, width) - continue + return a.roomOrganized() || a.railHold || a.hoveringRailArea() +} + +// railEntryRow is one row of the roster, one line whatever it is: +// +// Running 4 a group's heading, always open +// ⠙ rebase onto dev 2m a task: its state, its name, its time +// Queued 3 ▸ a folded group and its count +// Done 7 ▾ the same group, opened +// +// EVERY TASK ROW OPENS WITH ONE GLYPH AND IT IS THE STATE, two cells in under +// its heading, then the name the person approved, cut with an ellipsis, and +// how long the work has been at it (or took) in the muted ink at the right. +// The whole name, and what a row used to say under it, are the hint line's +// ([app.sideHoverWords]). +// +// A HEADING IS THE GROUP'S WORD AND ITS COUNT, and a group that folds wears ▸ +// while it is folded and ▾ while it is open. Running work does not fold, so +// its heading wears no mark: a mark is a promise that a press does something. +func (a *app) railEntryRow(e railEntry, width int) string { + if e.head { + word := railHeadWords[e.group] + " " + itoa(e.count) + line := a.pal.muted(railHeadWords[e.group]) + " " + a.pal.dim(itoa(e.count)) + if e.group != railRunning { + mark := a.linearMark(glyphOpen, glyphOpenASCII) + if e.shut { + mark = a.linearMark(glyphShut, glyphShutASCII) + } + word += " " + mark + line += " " + a.pal.muted(mark) } - out = append(out, line) - if len(out) == rooms { - out[rooms-1] = fit(out[rooms-1]+" "+glyphMore, width) - return out + if ansi.StringWidth(word) > width { + return a.pal.muted(fit(word, width)) } - line = fit(seg, width) - } - // The loop returns the moment the last line is spoken for, so what reaches - // here is a line with room left in the block. - if line != "" { - out = append(out, line) + return line } - return out -} - -// railEntryRows is one row of the forest: WHAT IT IS on the first line, and what -// is true of it on the second. -// -// ⠙ Fix nil-map #7 a node that belongs to no family -// bash go test ./… · 42s -// ⠙ Ship the port #1 and a family, drawn whole -// ├─ ✓ Read the law #2 -// ├─ ⠙ Write the tree #3 -// │ 42s · 9.9k · $0.31 -// │ └─ ◌ Cut the goldens #4 -// └─ ◌ Wire the seam #5 -// ⠙ Port the parser ▸ +7 the same family, folded -// -// EVERY ROW OPENS WITH ONE GLYPH AND IT IS THE STATE. A flat row used to lead -// with two — the state and the node's own ◆ — and the second bought nothing -// here: it is the same mark on every task, the tree rows never carried it, and -// this column holds nothing but tasks, so it marked a distinction the column -// does not contain while spending two of the twenty-two cells the name has -// ([app.railLead] states the whole of it). Down a tree the neighbours are -// already named by the connectors they hang from, and the question left over is -// which limb is still moving: so the column is a column of STATES and it can be -// read downward, flat rows and family rows alike. -// -// THE NAME LEADS AND THE HANDLE TRAILS. The glyph and the title are what a -// person reads down this column — the state, and the words they themselves -// approved — and the id is what identifies the node to the -// MACHINE: the number the engine says in its own sentences ("task 7 done", -// session's task_run.go), the thing to type when you go looking for the branch, -// and the least interesting fact on the row. So it is dim, it is at the far end, -// and the title is measured against what is left. -// -// A FOLDED ROOT SPENDS THAT SAME SLOT ON ITS COUNT. The handle is how you find -// one node and the count is how many nodes this row is standing for — on the one -// row that is hiding work, the second question is the one being asked. -// -// THE SUBTITLE IS NOT HERE. Every other place a task is drawn carries the one -// line that says what it is; this column is twenty-two cells wide and is a -// PRESENCE list — the question it answers is "what is alive", and a sentence -// clipped to twenty-two cells answers no question at all. -// -// It reports the FOLD cell's columns and the badge's alongside the rows, because -// both are pressable and both are narrower than the row they are on — and -// because everything else on the row is the node's own door, so a target -// recorded where nothing is drawn is a click the task swallows. -func (a *app) railEntryRows(e railEntry, width int) ([]string, hudSpan, hudSpan) { node := e.node if node == nil { - return nil, hudSpan{}, hudSpan{} - } - // Deep ancestry keeps its full navigation identity, but its indentation must - // leave room for a name and the under-row's child stem. The ellipsis marks - // omitted outer connectors; only this drawing copy is shortened. - depthRoom := max((width-railTitleFloor-2-treeIndentCols)/treeIndentCols, 1) - compressed := len(e.stems) > depthRoom - if compressed { - e.stems = e.stems[len(e.stems)-depthRoom:] - } - prefix, at := a.railPrefix(e.stems) - if compressed { - tail, _ := a.railPrefix(e.stems[1:]) - prefix = a.pal.dim(a.linearMark("…", "~")+strings.Repeat(" ", treeIndentCols-1)) + tail - } - glyph, lead, folds := a.railLead(e) - room := width - at - ansi.StringWidth(lead) - // The trailing slot: a folded root says how much it is standing for, every - // other row says its handle, and both stand down when the title cannot afford - // them. - meta := railMetaWord(node) - if e.folded { - meta = a.linearMark(glyphShut, glyphShutASCII) + " +" + itoa(e.hidden) - } - if room-ansi.StringWidth(meta)-1 < railTitleFloor { - meta = "" - } - if meta != "" { - room -= ansi.StringWidth(meta) + 1 - } - title, whole := fit(node.title, room), ansi.StringWidth(node.title) - // THE HINT IS EARNED TWICE OVER: by the INDENT, because a name cut on a row - // with nothing above it is a name this column is simply too narrow for, and by - // the WIDE TIER ACTUALLY SAVING IT, because an offer that does not fix what a - // person can see is worse than no offer. - if at > 0 && whole > room && whole <= room+railWideGain { - a.railCramped = true - } - line := prefix + lead + a.railTitle(node, title) - badge := hudSpan{} - if meta != "" { - if pad := room - ansi.StringWidth(title) + 1; pad > 0 { - line += strings.Repeat(" ", pad) - } - if e.folded { - from := width - ansi.StringWidth(meta) - badge = hudSpan{from: from, to: width} - } - line += a.pal.dim(meta) - } - rows := []string{line} - if a.railSaysMore(e) { - for _, under := range a.railUnder(node, width-a.railUnderCols(e)) { - rows = append(rows, a.railUnderStem(e)+under) - } - } - // THE CELL IS A TARGET ONLY WHERE IT IS DRAWN AS ONE. At rest it holds the - // STATE — a spinner, a tick, a demand — and a state is not a control; the - // disclosure appears in its place under the pointer and only there - // ([app.railLead]). An empty span holds no column ([hudSpan.holds] asks - // [hudSpan.pressable] first), so on every other frame these cells belong to - // the row, which is the node's door. - cell := hudSpan{} - if folds { - cell = hudSpan{from: at, to: at + ansi.StringWidth(glyph)} - } - return rows, cell, badge -} - -// railSaysMore reports whether this row is allowed the block under its title. -// -// A SETTLED NODE IS ONE LINE, WHEREVER IT STANDS. A family is drawn whole, which -// means the rows that landed are on screen to make the rows that have not landed -// legible — and a merge word and a price under each of them is a second column of -// history inside a shape somebody is reading for its shape. So only the rows that -// are still going somewhere say anything more: what is running, and what is -// waiting on a person. A folded root says nothing extra either — it is standing -// for a whole subtree, and one row is the point of it. -// -// AND THE FLAT ROW FOLLOWS THE SAME LAW, which is the thing that changed. A row -// with no family around it used to keep its block forever, so thirteen jobs that -// had all landed hours ago spent thirty-nine lines of a thirty-cell column -// restating history, and the standing section under them was squeezed to a single -// cut-off row. The column exists to say what is alive; space it spends on what is -// over is space taken from what is not. -// -// WHAT IS QUEUED IS NOT SETTLED, and a flat one keeps its line: `waits: Collect -// sources` is the only place this surface says what is in the way, and inside a -// family the sibling above it is that answer already. -// -// AND NOTHING IS THROWN AWAY — it is TUCKED. A landed flat row that had something -// to say folds it behind the same disclosure a family root wears, opened with → -// or a press on the glyph cell and remembered in the same map ([app.railOpen]). -// So the branch a stopped run kept is one gesture away rather than gone; see -// [app.railTucks]. -func (a *app) railSaysMore(e railEntry) bool { - if e.folded { - return false - } - group := a.railGroupOf(e.node) - switch group { - case railRunning, railAttention: - return true - } - if e.node.Paused() { - return true - } - // A HELD ROW SAYS WHAT IS HOLDING IT WHEREVER IT SITS IN A FAMILY. The - // engine starts as much of a fan as this machine can carry and holds the - // rest (internal/session's task_pressure.go), so a family is routinely half - // running and half waiting — and a child row that drew nothing was the one - // shape a person could not tell apart from work that has simply not been - // reached yet. - if e.node.waiting != "" { - return true - } - if e.root || len(e.stems) > 0 { - return false + return "" } - if group == railDone { - return !a.railTuckShut(e.node) + const indent = " " + glyph := a.railTreeGlyph(node) + room := width - len(indent) - 2 + // THE TIME GIVES WAY TO THE NAME: it is drawn only where the name keeps + // railTitleFloor cells beside it, and never where it would cut a name that + // fits whole without it. + age := a.railAge(node) + ageW := ansi.StringWidth(age) + 1 + nameW := ansi.StringWidth(node.title) + if age != "" && room-ageW >= railTitleFloor && !(nameW <= room && nameW > room-ageW) { + room -= ageW + } else { + age = "" } - return true -} - -// railTucks reports whether this row folds ITS OWN BLOCK — the landed flat row, -// open or shut, and nothing else on the column. -// -// IT ASKS WHETHER THERE IS ANYTHING BEHIND THE DISCLOSURE, at the width the block -// would be drawn at, because a triangle on a row with nothing under it is an -// affordance that answers a press with silence. A node that came home clean with -// no price to report has nothing tucked, and its glyph cell stays its state. -// -// It is asked of ONE row at a time — the row under the pointer, and the row a key -// arrived on — and never down the whole column, which is why the layout reads -// [app.railSaysMore] instead: that question is answered from the fold map alone, -// and this one renders a block to answer. -func (a *app) railTucks(e railEntry) bool { - if e.node == nil || e.root || e.folded || len(e.stems) > 0 { - return false + title, w := fitWidth(node.title, room) + line := indent + glyph + " " + a.railTitle(node, title) + if age != "" { + line += strings.Repeat(" ", max(room-w, 0)+1) + a.pal.dim(age) } - if a.railGroupOf(e.node) != railDone { - return false - } - return len(a.railUnder(e.node, a.railRoom()-a.railUnderCols(e))) > 0 -} - -// railTuckShut reports whether a landed flat row is holding its block back. -// -// THE DEFAULT IS SHUT AND THE MAP IS THE PERSON'S CORRECTION OF IT, which is -// [app.railShut]'s own bargain said about one row instead of a family — and it is -// the same map, so a row and a family are folded by the same gesture and undone -// by it too. It is spelled separately because [app.railShut] answers by regrowing -// the node's family, which the layout may not pay for once a row. -func (a *app) railTuckShut(node *taskNode) bool { - return node == nil || !a.railOpen[node.id] -} - -// railNodeRows is one node with no family around it — the flat row, and the -// shape every caller outside the column's own layout wants. -func (a *app) railNodeRows(node *taskNode, width int) []string { - rows, _, _ := a.railEntryRows(railEntry{node: node}, width) - return rows -} - -// railLead is the row's glyph cell, the whole lead it sits in, air included, and -// whether that cell IS A FOLD CONTROL on this frame. -// -// THE DISCLOSURE IS THE POINTER'S AND IT REPLACES THE STATE. A family root under -// the pointer trades its state cell for ▾ or ▸ — one cell, in place, so nothing -// on the row moves — because the affordance is worth exactly as much as the -// state for the one moment there is a hand on it. At rest the column is states -// all the way down. -// -// AND A LANDED ROW WITH ITS BLOCK TUCKED AWAY OFFERS THE SAME CELL, because it is -// the same gesture on the same map ([app.railTucks]). One fold vocabulary down -// the column: what is hiding something says so under the hand, and ▸ opens it -// whether what it is hiding is a subtree or two lines of its own history. -// -// THE THIRD ANSWER IS WHAT THE PRESS READS, and returning it is the whole of the -// fix: [app.railPress] used to fold whenever a row COULD disclose — a family -// root, a landed row with a block tucked under it — while the cell only DRAWS -// the triangle under the pointer. So a press on a root this surface was not -// holding a hover for folded the family with a STATE glyph on screen, and the -// task the person was aiming at never opened. Opening a room drops the hover -// ([app.dropHover]) and a pointer that has not moved since sends no motion to -// put it back, so the very next click after opening anything landed in exactly -// that gap. The set that LIGHTS is the set that acts, which is hover.go's own -// law; this is the one answer both halves now read. -// -// AND THE ROW NO LONGER CARRIES THE ◆. It is one marker drawn as furniture, -// saying "this row is a task" and nothing else (taskident.go) — a distinction -// this column does not contain, because every node row on it is a task and the -// tree rows never wore it at all. It cost two cells of NAME on the narrowest -// surface here, on flat rows only, so two rows of the same kind led differently -// and the under-block — indented two cells by [app.railUnderCols] — sat two -// cells to the left of the title it belongs to. Dropping it buys the name those -// cells and squares the block up under it. Every other place a task is drawn -// keeps the marker, because those places hold more than tasks. -func (a *app) railLead(e railEntry) (string, string, bool) { - glyph := a.railTreeGlyph(e.node) - if e.folded && e.worst != nil { - // A FOLDED ROOT WEARS THE WORST THING UNDER IT. The row is standing for a - // whole subtree, so the one cell it has says what that subtree's news is - // rather than what its root happens to be doing. - glyph = a.railTreeGlyph(e.worst) - } - fold := a.hoveringRail(e.node) && (e.root || a.railTucks(e)) - if fold { - mark := a.linearMark(glyphOpen, glyphOpenASCII) - if e.folded || (!e.root && a.railTuckShut(e.node)) { - mark = a.linearMark(glyphShut, glyphShutASCII) - } - glyph = a.pal.accent(mark) - } - return glyph, glyph + " ", fold + return line } -// railPrefix is the connectors for one row, painted, and the CELLS they cost. A -// root has none — it is the thing everything else hangs from. -func (a *app) railPrefix(stems []bool) (string, int) { - if len(stems) == 0 { - return "", 0 - } - var out strings.Builder - for _, more := range stems[:len(stems)-1] { - if more { - out.WriteString(a.linearMark(treeStem, treeStemASCII)) - continue +// railAge is how long a task has been at it, while it runs, or how long it +// took, once it has landed, in the fewest cells: `40s`, `2m`, `1h`. "" for +// work that has not started, and for a landed node nobody timed. +func (a *app) railAge(node *taskNode) string { + var d time.Duration + switch node.state { + case session.TaskRunning: + start := node.spawnedAt() + if start.IsZero() { + return "" } - out.WriteString(treeVoid) - } - if stems[len(stems)-1] { - out.WriteString(a.linearMark(treeBranch, treeBranchASCII)) - } else { - out.WriteString(a.linearMark(treeLast, treeLastASCII)) - } - return a.pal.dim(out.String()), len(stems) * treeIndentCols -} - -// railUnderStem is what an under-row is drawn behind, and railUnderCols is what -// that costs. -// -// THE STEM CONTINUES THROUGH THE UNDER-BLOCK. A node's telemetry sits between -// that node's row and its next sibling's, so a block indented with plain spaces -// would put a gap in the vertical line the eye is following down the family. The -// row's own elbow becomes a stem — or blank air, where the node was the last of -// its siblings — and the node's own stem is added when it has children drawn -// below it. The two cells on the end are the flat row's WHOLE lead — the state -// glyph and its air ([app.railLead]) — so an under-row now starts in the same -// column as the title it belongs to. It did not while the flat row also carried -// a ◆: the block sat two cells to its left, and squaring that up is half of why -// the marker went. -func (a *app) railUnderStem(e railEntry) string { - var out strings.Builder - for _, more := range e.stems { - if more { - out.WriteString(a.linearMark(treeStem, treeStemASCII)) - continue + d = a.taskNow(node).Sub(start) + case session.TaskQueued: + return "" + default: + d = node.elapsed + if d <= 0 && !node.started.IsZero() && !node.ended.IsZero() { + d = node.ended.Sub(node.started) } - out.WriteString(treeVoid) - } - if e.root && !e.folded { - out.WriteString(a.linearMark(treeStem, treeStemASCII)) - } - if out.Len() == 0 { - return " " - } - return a.pal.dim(out.String()) + " " -} - -func (a *app) railUnderCols(e railEntry) int { - cols := len(e.stems) * treeIndentCols - if e.root && !e.folded { - cols += treeIndentCols - } - return cols + 2 -} - -// railWorst is the node whose state a folded family wears: the most urgent thing -// under it, its root included. -// -// A family's position is stable, but its folded glyph still reports the most -// urgent state among its members. -func (a *app) railWorst(t *railTwig) *taskNode { - worst := t.node - for _, kid := range t.kids { - if under := a.railWorst(kid); a.railGlyphRank(under) < a.railGlyphRank(worst) { - worst = under + if d <= 0 { + return "" } } - return worst -} - -// railGlyphRank orders the readings by how loud they are on one cell, and IT IS -// THE TIER'S ORDER: the person's call first, then work in flight, then work that -// is over (docs/design/task-states/DESIGN.md). -// -// THE ONE RANK THE TIERS DO NOT DECIDE IS `over` AND UNFINISHED. The glyph on a -// folded row is the news of the subtree, and "something in here did not come -// off" is the loudest news there is short of a demand — so an incomplete child -// outranks a sibling that has not started. The glyph reports what happened -// without changing the family's creation order. -// -// A CHILD WHOSE DECISION IS ITS PARENT'S AGENT'S DOES NOT MAKE THE FOLDED ROW A -// DEMAND, which is [app.railGroupOf]'s law said on one cell: the parent holds -// the question, so a family drawn as its root alone must wear the root's own -// news and not a question its own head is already answering. That fold is read -// off [session.TaskAsk.Owner] and off nothing else — a design waiting to be -// approved is asking the PERSON, and no agent above it can answer for them — -// and it changes only where the row sorts. The row still reads its reason. -func (a *app) railGlyphRank(node *taskNode) int { - status := a.taskStatus(node) switch { - case status.Tier == session.TaskTierYourCall: - // AND THE TIER IS ASKED FIRST. A node whose landing is somebody's call has - // a branch that never came home by construction, so an unlanded-changes - // test above this one would answer for every one of them and the fold - // below could never fire. - // - // THE PARENT'S OWN RUN IS THE SAME FACT THE ENGINE HAS NOT PUBLISHED YET. - // The engine routes a sub-task's landing note to its parent node's agent - // while that parent lives (session's deliverTaskNote), which IS the model - // holding the question — but it does not stamp [session.TaskNotice.Decider] - // on that shape, so reading the owner alone would take the #268 fold away - // and put a demand back on a family whose head is already answering it. - // Both roads are the same claim; when the engine publishes the second the - // clause goes. - if status.Ask.Owner == session.TaskAskOwnerModel || a.taskParentDeciding(node) { - return 4 - } - return 0 - case node.Paused(), status.ChangesUnlanded(): - return 0 - case status.Tier == session.TaskTierMoving: - if status.Presence == session.TaskPresenceWorking || status.Presence == session.TaskPresenceFinishing { - return 1 - } - return 3 - case status.Presence == session.TaskPresenceIncomplete: - return 2 + case d < time.Minute: + return itoa(max(int(d/time.Second), 0)) + "s" + case d < time.Hour: + return itoa(int(d/time.Minute)) + "m" + case d < 24*time.Hour: + return itoa(int(d/time.Hour)) + "h" } - return 4 + return itoa(int(d/(24*time.Hour))) + "d" } // railTreeGlyph is the row's state in one cell: the roster's own glyph, with the @@ -5037,18 +4240,6 @@ func (a *app) railTreeGlyph(node *taskNode) string { // naming the work. const railTitleFloor = 12 -// railMetaWord is the node's handle: the id the engine calls it by. -// -// A STORE TASK'S HANDLE IS THE STORE'S. A run's parts have no node number, so -// the row lent to one carries the store's own id ([taskNode.handle]) and wears -// it in the same slot, in the same dim, as a node wears its number. -func railMetaWord(node *taskNode) string { - if node.handle != "" { - return "#" + node.handle - } - return "#" + itoa(int(node.id)) -} - // railModelWord is the model this node runs on, as a column this narrow can say // it: the part of the id AFTER THE VENDOR, which is the part that names the // model rather than who sells it. Empty when nobody published one, and then @@ -6191,13 +5382,14 @@ func (a *app) dropTasks() { // started it, down to the folder its log is written in. a.dropJobs() // THE ROSTER GOES WITH ITS NODES, the keyboard included. A column that kept - // its folds and its cursor into the next conversation would be a map of work - // that no longer exists, holding keys the draft is waiting for. - a.railOpen = nil + // its cursor into the next conversation would be a map of work that no + // longer exists, holding keys the draft is waiting for. Which groups are + // open is the person's reading of the column, not of these nodes, and stays + // for the session (sidecol.go). a.railTop = 0 a.railWhere = railSpot{} a.railHold = false - a.railWide, a.railCramped = false, false + a.railWide = false // [app.railAway] STAYS. It is the one fact in this block that is not about // these nodes: a person who put the column away said something about their // screen, not about the conversation they have just replaced, and standing it diff --git a/internal/tui3/taskcardhost_test.go b/internal/tui3/taskcardhost_test.go index 2b3b81bed1..a5be1d7dc5 100644 --- a/internal/tui3/taskcardhost_test.go +++ b/internal/tui3/taskcardhost_test.go @@ -167,7 +167,8 @@ func TestAHostedRosterListsTheFarConversationsTasks(t *testing.T) { if node := a.tasks[9]; node == nil || node.title != "widening the pipe" { t.Fatalf("the far row did not become a roster node: %#v", node) } - if entries := a.railEntries(); len(entries) != 1 || entries[0].node == nil || entries[0].node.id != 9 { + railOpenAll(a) + if entries := a.railEntries(); len(entries) != 2 || !entries[0].head || entries[1].node == nil || entries[1].node.id != 9 { t.Fatalf("the hosted roster stayed empty: %#v", entries) } } diff --git a/internal/tui3/taskeffort.go b/internal/tui3/taskeffort.go index 8d196de1c0..9fd64e2149 100644 --- a/internal/tui3/taskeffort.go +++ b/internal/tui3/taskeffort.go @@ -187,8 +187,9 @@ func (a *app) taskEffortClause(node *taskNode) string { // It is the engine's own gate read from outside: a running or queued node in // this session's graph, or an ordinary settled node saving its next rung. // A node belonging to an adaptive run is outside the graph this door reaches. -// railHoldHintWord is [railHoldHint] with the rung's chord named in it while the -// row under the cursor can take one, and [railHoldHint] itself otherwise. +// railHoldHintWord is [railHoldKeys] and esc, with the rung's chord named in +// it while the row under the cursor can take one, and led by ←→ in a chat in a +// team, where they switch the column's two words. // // AND A ROW THAT IS ASKING TAKES THE WHOLE LINE. A node that landed `needs your // look` is the surface standing still waiting for a person, and the three words @@ -210,10 +211,14 @@ func (a *app) railHoldHintWord() string { // ranked prefix of it that fits, and `esc` is the last thing it gives up. return a.landingHintAt(node.id, a.width, railSep+"esc") } + keys := railHoldKeys + if a.sideKind() != sideKindPlain { + keys = sideSwitchKeys + " · " + keys + } if !a.taskRungMovable(a.railFocusNode()) { - return a.chords.say(railHoldHint) + return a.chords.say(keys + " · esc") } - return a.chords.say(railHoldKeys + " · " + effortKeyClause + " · esc") + return a.chords.say(keys + " · " + effortKeyClause + " · esc") } func (a *app) taskRungMovable(node *taskNode) bool { diff --git a/internal/tui3/taskending_test.go b/internal/tui3/taskending_test.go index 67ad6967dc..8db1315a33 100644 --- a/internal/tui3/taskending_test.go +++ b/internal/tui3/taskending_test.go @@ -8,11 +8,12 @@ import ( "github.com/Agent-Field/codeaf/internal/session" ) -// endedRailText expands the finished report and reads its rows as one line, because the rail wraps a row's -// sentence across its narrow column and a test reads the sentence, not the wrap. +// endedRailText is what the column says about node 7, read as one line: its +// row, and the hint line over it, which is where the finished report went when +// every row became one line. func endedRailText(a *app) string { - a.railSetOpen(a.tasks[7], true) - rows := plain(strings.Join(a.railRows(12), "\n")) + railOpenAll(a) + rows := plain(strings.Join(a.railRows(12), "\n")) + " " + railHint(a, 7) return strings.Join(strings.Fields(strings.ReplaceAll(rows, "│", " ")), " ") } diff --git a/internal/tui3/taskmachinehold_test.go b/internal/tui3/taskmachinehold_test.go index 6b802e9cd2..318d4013ee 100644 --- a/internal/tui3/taskmachinehold_test.go +++ b/internal/tui3/taskmachinehold_test.go @@ -31,7 +31,7 @@ func TestAHeldChildSaysTheMachineHeldItAndNotTheCap(t *testing.T) { if held.waiting != waitWordMachine { t.Fatalf("the held part carries %q, want %q", held.waiting, waitWordMachine) } - if rows := a.railUnder(held, underWidth(railCols)); len(rows) != 1 || !strings.Contains(plain(rows[0]), waitWordMachine) { + if rows := a.railUnder(held, underWidth(underCols)); len(rows) != 1 || !strings.Contains(plain(rows[0]), waitWordMachine) { t.Fatalf("the held part's row is %q, want it to say %q", rows, waitWordMachine) } if status := a.taskStatus(held); status.Reason != waitWordMachine { @@ -42,7 +42,7 @@ func TestAHeldChildSaysTheMachineHeldItAndNotTheCap(t *testing.T) { // cursor wears its reason under its own row. drive(t, a, altT()) railFocusOn(t, a, 3) - roster := rosterText(a, 12) + roster := rosterText(a, 12) + "\n" + a.sideHoverWords() + "\n" + railHint(a, 3) if !strings.Contains(roster, waitWordMachine) { t.Fatalf("the roster does not say the machine is holding a part:\n%s", roster) } diff --git a/internal/tui3/taskmention.go b/internal/tui3/taskmention.go index 3ee60618e5..c96ac0a642 100644 --- a/internal/tui3/taskmention.go +++ b/internal/tui3/taskmention.go @@ -313,15 +313,21 @@ func (c *completion) layoutTasks(lines []compLine) []compLine { for at := range c.taskHits { if c.taskSection[at] != section { section = c.taskSection[at] - lines = append(lines, compLine{header: c.sectionRule(section), task: -1, file: -1}) + line := deadLine() + line.header = c.sectionRule(section) + lines = append(lines, line) } - lines = append(lines, compLine{task: at, file: -1}) + line := deadLine() + line.task = at + lines = append(lines, line) } if c.older > 0 && section != sectionOlder { // Everything the cap cut is older than everything drawn, so its rule goes - // last — and with nothing under it, which is exactly what a collapsed + // last, and with nothing under it, which is exactly what a collapsed // section is. - lines = append(lines, compLine{header: c.sectionRule(sectionOlder), task: -1, file: -1}) + line := deadLine() + line.header = c.sectionRule(sectionOlder) + lines = append(lines, line) } return lines } @@ -413,6 +419,14 @@ func taskNoteWord(entry session.TaskIndexEntry) string { // completeMention is enter on the list: a task becomes its slug, a file becomes // its path (files.go). It is the one door, so that enter means one thing. func (a *app) completeMention() { + if team, ok := a.comp.teamChoice(); ok { + a.completeTeam(team) + return + } + if chat, ok := a.comp.chatChoice(); ok { + a.completeChat(chat) + return + } if entry, ok := a.comp.taskChoice(); ok { a.completeTask(entry) return diff --git a/internal/tui3/taskmodel_test.go b/internal/tui3/taskmodel_test.go index ab4d71bc30..fb152e83d1 100644 --- a/internal/tui3/taskmodel_test.go +++ b/internal/tui3/taskmodel_test.go @@ -116,9 +116,9 @@ func questionBlockText(a *app) string { return plain(strings.Join(a.questionRows(a.width), "\n")) } -// THE NODE KEEPS ITS MODEL AFTERWARDS: the rail says it on the telemetry row -// under the name, the room's header states it, and the landed card keeps it -// beside the working copy. +// THE NODE KEEPS ITS MODEL AFTERWARDS: the column's hint line says it under +// the pointer on the node's row, the room's header states it, and the landed +// card keeps it beside the working copy. func TestTheModelFollowsTheNodeOntoTheRailAndTheLandedCard(t *testing.T) { a, _, advance := taskApp(t) drive(t, a, streamEventMsg{gen: a.gen, ev: modelProposal(a, 7, 0, "openai/gpt-5", nil)}) @@ -130,31 +130,26 @@ func TestTheModelFollowsTheNodeOntoTheRailAndTheLandedCard(t *testing.T) { if node == nil || node.model != "openai/gpt-5" { t.Fatalf("the node did not keep its model: %+v", node) } - // THE MODEL NEVER BUYS ITS CELLS FROM THE NAME. The first line is the state - // glyph, the title and the handle — nothing else — and the model rides the - // telemetry row under it (task.go's [app.railTelemetry]), which is a row that - // gives up its own tail rather than the title's cells. - full := plain(strings.Join(a.railNodeRows(node, railCols), "\n")) - head, under, _ := strings.Cut(full, "\n") - if strings.Contains(head, "gpt-5") || !strings.Contains(head, "#7") { - t.Fatalf("the model is on the title's line:\n%s", full) - } - if !strings.Contains(under, "gpt-5") { - t.Fatalf("the rail did not carry the model under the title:\n%s", full) - } - // A LONG NAME IS NOW THE SAME ROW. It used to cost the row its model, because - // the model was measured against the title; nothing is measured against the - // title any more. + // THE MODEL NEVER BUYS ITS CELLS FROM THE NAME. The row is the state glyph, + // the name and the clock, one line, and the model is the hint line's under + // the pointer (sidecol.go's [app.sideHoverWords] reads the telemetry, + // task.go's [app.railTelemetry]). + row := plain(a.railEntryRow(railEntry{node: node, group: railRunning}, 28)) + if strings.Contains(row, "gpt-5") || !strings.Contains(row, "Fix the nil-map") { + t.Fatalf("the model is on the task's row, or the name is not: %q", row) + } + a.hot = hoverAt{kind: hoverRail, id: node.id} + if hint := a.sideHoverWords(); !strings.Contains(hint, "gpt-5") || !strings.Contains(hint, "Fix the nil-map crash") { + t.Fatalf("the hint line over the row does not carry the name and the model: %q", hint) + } + // A LONG MODEL IS NEVER CUT ON THE HINT LINE: it has the room the row did + // not. node.model = "anthropic/claude-opus-4.8" - long := plain(strings.Join(a.railNodeRows(node, railCols), "\n")) - if !strings.Contains(long, "claude-opus-4.8") || !strings.Contains(long, "#7") { - t.Fatalf("a long model cost the row one of its two facts:\n%s", long) + if hint := a.sideHoverWords(); !strings.Contains(hint, "claude-opus-4.8") { + t.Fatalf("a long model was cut from the hint line: %q", hint) } node.model = "openai/gpt-5" - narrow := plain(strings.Join(a.railNodeRows(node, railSlimCols), "\n")) - if !strings.Contains(narrow, "gpt-5") || !strings.Contains(narrow, "#7") { - t.Fatalf("a slim rail dropped the model with cells to spare:\n%s", narrow) - } + a.hot = hoverAt{} advance(2 * time.Minute) drive(t, a, taskEventMsg{gen: a.taskGen, ev: update(7, "Fix the nil-map crash", session.TaskDone, diff --git a/internal/tui3/taskphase_test.go b/internal/tui3/taskphase_test.go index 656ff6cdca..bc5a1547c6 100644 --- a/internal/tui3/taskphase_test.go +++ b/internal/tui3/taskphase_test.go @@ -59,9 +59,9 @@ func TestANodeUnderTheCheckSaysWhatIsHappeningAtEveryWidth(t *testing.T) { width int want []string }{ - {underWidth(railWideCols), []string{taskCheckingWord, "42s · 9.9k · $0.31 · gpt-5"}}, - {underWidth(railCols), []string{taskCheckingWord, "42s · 9.9k · $0.31 · gpt-5"}}, - {underWidth(railSlimCols), []string{"checking what it le…", "42s · 9.9k · $0.31"}}, + {underWidth(underWideCols), []string{taskCheckingWord, "42s · 9.9k · $0.31 · gpt-5"}}, + {underWidth(underCols), []string{taskCheckingWord, "42s · 9.9k · $0.31 · gpt-5"}}, + {underWidth(underSlimCols), []string{"checking what it le…", "42s · 9.9k · $0.31"}}, } { rows := a.railUnder(node, tc.width) if len(rows) != len(tc.want) { @@ -78,11 +78,11 @@ func TestANodeUnderTheCheckSaysWhatIsHappeningAtEveryWidth(t *testing.T) { } // And through the column a person actually reads, at the widths the rail - // itself narrows to — where the row is cut from the right and the words that - // name the moment are the ones that survive. + // itself narrows to: the row is one line, and what the block says is on the + // hint line over it (sidecol.go's [app.sideTaskHint]). for width, want := range map[int]string{200: "checking what it le", 110: "checking what it le"} { a.width = width - roster := rosterText(a, 12) + roster := rosterText(a, 12) + "\n" + railHint(a, 7) if !strings.Contains(roster, want) { t.Fatalf("the roster at %d columns does not say the work is being checked:\n%s", width, roster) } @@ -99,7 +99,7 @@ func TestARepairRoundSaysTheRoundAndTheFinding(t *testing.T) { drive(t, a, taskEventMsg{gen: a.taskGen, ev: phaseMove(7, session.TaskPhaseRepairing, 1, 1, "not done — go test reports no test files")}) - rows := a.railUnder(node, underWidth(railWideCols)) + rows := a.railUnder(node, underWidth(underWideCols)) want := []string{"closing gaps · round 1 of 1", "not done — go test reports no test files"} if len(rows) != len(want) { t.Fatalf("the under-block is %d rows, want %d:\n%q", len(rows), len(want), rows) @@ -113,15 +113,14 @@ func TestARepairRoundSaysTheRoundAndTheFinding(t *testing.T) { // engine that sends both is an engine whose repair round is running, and // "closing gaps · round 1 of 1" is that same news with the round on it. node.mending = "go test reports no test files" - if got := plain(a.railUnder(node, underWidth(railWideCols))[0]); got != "closing gaps · round 1 of 1" { + if got := plain(a.railUnder(node, underWidth(underWideCols))[0]); got != "closing gaps · round 1 of 1" { t.Fatalf("the gap line took the row back: %q", got) } - // And through the column a person actually reads, where the rail's own width - // cuts both rows from the right — the round and the opener, which are the - // halves that name the moment, always survive. + // And through the column a person actually reads: the hint line over the + // row carries both, the round and the opener. a.width = 200 - roster := rosterText(a, 12) + roster := rosterText(a, 12) + "\n" + railHint(a, 7) for _, line := range []string{"closing gaps · round 1 of", "not done — go test report"} { if !strings.Contains(roster, line) { t.Fatalf("the roster does not carry %q:\n%s", line, roster) @@ -146,7 +145,7 @@ func TestANodeBackAtWorkDrawsNothingExtra(t *testing.T) { } drive(t, a, taskEventMsg{gen: a.taskGen, ev: phaseMove(7, session.TaskPhaseWorking, 0, 0, "")}) - rows := a.railUnder(node, underWidth(railCols)) + rows := a.railUnder(node, underWidth(underCols)) if len(rows) != 1 { t.Fatalf("a working node's under-block is %d rows, want the telemetry alone:\n%q", len(rows), rows) } @@ -258,7 +257,7 @@ func TestANodeBeingSizedSaysSoOnEveryColumn(t *testing.T) { drive(t, a, taskEventMsg{gen: a.taskGen, ev: phaseMove(7, session.TaskPhaseSizing, 0, 0, "")}) // THE RAIL, with the telemetry a person opens this column for kept under it. - rows := a.railUnder(node, underWidth(railWideCols)) + rows := a.railUnder(node, underWidth(underWideCols)) want := []string{taskSizingWord, "42s · 9.9k · $0.31 · gpt-5"} if len(rows) != len(want) { t.Fatalf("the under-block is %d rows, want %d:\n%q", len(rows), len(want), rows) @@ -377,7 +376,7 @@ func TestARequestASizingIsWaitingOnIsDrawnOnTheRailAndInTheRoom(t *testing.T) { } frame := func() (rail, room string) { a.room.dirty = true - return plain(strings.Join(a.railPhase(node, underWidth(railWideCols)), "\n")), roomText(a) + return plain(strings.Join(a.railPhase(node, underWidth(underWideCols)), "\n")), roomText(a) } // BEFORE: the phase and the ladder, and nothing that moves. diff --git a/internal/tui3/taskplan.go b/internal/tui3/taskplan.go index d05f996714..bcf580a5f5 100644 --- a/internal/tui3/taskplan.go +++ b/internal/tui3/taskplan.go @@ -1537,14 +1537,15 @@ func (a *app) taskPlanBody(width int) []string { } } // A TASK WITH CHILDREN SHOWS THEM UNDER ITS STEPS, AND EACH ONE IS DRAWN AS - // THE RAIL DRAWS A TASK: through the node renderer, with the running spinner, - // its `#id`, the old tree's connectors and — while it runs — its call and - // its clock and money line under it ([app.planRailLines]). One kind of row for - // one kind of thing, on the column and on the page alike. The note composer - // and its receipt below are untouched by the tree. + // THE SIDE COLUMN DRAWS A TASK: through the node renderer, one line with its + // state glyph, its name and its time, a part's own parts a level in, and + // under it what the column's hint would say, its call and its clock and + // money ([app.planPageLines]). One kind of row for one kind of thing, on the + // column and on the page alike. The note composer and its receipt below are + // untouched by the tree. if kids := page.Children; len(kids) > 0 { section("under it") - for _, line := range a.planRailLines(planTwigsOf(kids), nil, false, min(width, planPageKinWidth)) { + for _, line := range a.planPageLines(planTwigsOf(kids), 0, min(width, planPageKinWidth)) { add(line.text) } } @@ -1552,8 +1553,8 @@ func (a *app) taskPlanBody(width int) []string { } // planPageKinWidth is the most a task's page spends on one row of its parts. A -// part's row is the rail's row, whose handle stands at the row's far end; on a -// page the width of the terminal that handle would sit a screen away from the +// part's row is the side column's row, whose time stands at the row's far end; on a +// page the width of the terminal that time would sit a screen away from the // title it belongs to, so the rows are drawn at a width a column could have. const planPageKinWidth = 64 diff --git a/internal/tui3/taskplan_test.go b/internal/tui3/taskplan_test.go index ac9127fb14..ea41c7ffc3 100644 --- a/internal/tui3/taskplan_test.go +++ b/internal/tui3/taskplan_test.go @@ -224,8 +224,15 @@ func openWorkTabNow(t *testing.T, a *app) { // planLine is the LIST line a title is on — the half of the frame left of the // seam, because the record pane beside it previews the cursor row and would // answer with the title twice. +// +// THE HEAD IS SKIPPED: the strip of chats is on every page and carries the +// run's tab, so a title can stand on it as well as on the pane's own row. func planLine(text, title string) (string, bool) { - for _, line := range strings.Split(text, "\n") { + lines := strings.Split(text, "\n") + if len(lines) > placeHeadRows { + lines = lines[placeHeadRows:] + } + for _, line := range lines { if at := strings.LastIndex(line, railSeam); at >= 0 { line = line[:at] } diff --git a/internal/tui3/tasksplace.go b/internal/tui3/tasksplace.go index 1e8b3740bd..46c4cbc9ac 100644 --- a/internal/tui3/tasksplace.go +++ b/internal/tui3/tasksplace.go @@ -1227,29 +1227,15 @@ func tasksTreeOf(items []tasksItem, now time.Time, order tasksSort, chats ...ses } } group := map[string]int{} - // THE TITLELESS ROW IS NAMED BY HOME'S OWN LADDER, never by the raw id its - // Title carries: the stem is the session's id, and an id is a machine's - // word in the one column whose whole job is matching names. Home solved this - // for its own lists with one spelling of the word ([listName]'s defect - // note), and this place draws the same row, so it reads the name from there - // rather than spelling it a second time here. - // - // THE TEST IS EQUALITY WITH THE ROW'S OWN ID, FOLDED, because a titleless - // row's Title is never empty — [tasksConversationRows] fills it with - // [homeName], whose title case has already raised the id's first letter, so - // the composer sees `De9ea39e6f4c18c3` where the id is `de9ea39e6f4c18c3` and - // a byte-exact check never fires. EqualFold is the one comparison that does. + // THE TITLELESS ROW IS NAMED BY [homeName], the one rule home's sessions + // list uses too. Spelling the id check here again would be a second rule, + // and the two would drift the day one of them changed. // // ONLY THE NAME CHANGES. The row keeps its place, its age stays empty // (lastUserAt is the zero time and the emptiness law draws nothing), and // [chatProjectWord] still sees the row, so a project that is not this name // does not echo the word back as a project tag beside it. - tasksName := func(row session.SessionRow) string { - if strings.EqualFold(strings.TrimSpace(row.Title), row.ID) || (row.Title == "" && row.Transcript != "") { - return unnamedConversationWord - } - return homeName(row) - } + tasksName := func(row session.SessionRow) string { return homeName(row) } for _, root := range roots { id := tasksChatOf(root) row, named := names[id] diff --git a/internal/tui3/taskstatus_test.go b/internal/tui3/taskstatus_test.go index 924b45ad64..3d65bb399a 100644 --- a/internal/tui3/taskstatus_test.go +++ b/internal/tui3/taskstatus_test.go @@ -166,6 +166,7 @@ func TestUnlandedEditsAskForAPersonWithoutMovingTheState(t *testing.T) { a := statusApp(t) node := &taskNode{id: 6, state: session.TaskDone, merge: mergeWordConflicted, branch: "task/fix-nil"} a.tasks[6] = node + a.taskOrder = append(a.taskOrder, 6) status := a.taskStatus(node) if status.Presence != session.TaskPresenceDone { t.Errorf("presence = %q, want %q", status.Presence, session.TaskPresenceDone) @@ -176,8 +177,8 @@ func TestUnlandedEditsAskForAPersonWithoutMovingTheState(t *testing.T) { if group := a.railGroupOf(node); group != railAttention { t.Errorf("the roster files unlanded edits under %q", railGroupWords[group]) } - if rank := a.railGlyphRank(node); rank != 0 { - t.Errorf("unlanded edits rank %d, want the loudest", rank) + if items := a.sideBand(); len(items) != 1 || !items[0].ask || items[0].key != "task/6" { + t.Errorf("unlanded edits are not the band's one amber item: %+v", items) } } diff --git a/internal/tui3/taskstrip_test.go b/internal/tui3/taskstrip_test.go index 8d10a2df60..3f80ee9838 100644 --- a/internal/tui3/taskstrip_test.go +++ b/internal/tui3/taskstrip_test.go @@ -256,6 +256,7 @@ func TestTheRosterOpensOverTheBodyOnANarrowFrame(t *testing.T) { if a.railShowing() || a.railFull() { t.Fatal("a narrow frame drew a roster nobody asked for") } + railOpenAll(a) drive(t, a, altT()) if !a.railFull() { @@ -363,7 +364,7 @@ func TestARunsNodesReachTheForestThroughTheirNotices(t *testing.T) { t.Fatalf("the run's own row hangs off %q, want a root", got) } kids, byKey := a.railKin() - if len(kids[stripKey(a.tasks[1])]) != 2 || railRootOf(a.tasks[3], byKey) != a.tasks[1] { + if len(kids[stripKey(a.tasks[1])]) != 2 || byKey[a.tasks[3].ParentID()] != a.tasks[1] { t.Fatalf("the run's nodes did not reach the forest: %v", kids) } // AND KINSHIP IS KEPT. A later update that says nothing about the parent has diff --git a/internal/tui3/tasktier_test.go b/internal/tui3/tasktier_test.go index d0ecb8096e..b48107d177 100644 --- a/internal/tui3/tasktier_test.go +++ b/internal/tui3/tasktier_test.go @@ -233,33 +233,40 @@ func TestTheLinearTierStillSpellsEveryState(t *testing.T) { // ── the rail ──────────────────────────────────────────────────────────────── -// THE ORDER IS THE TIER'S: the person's call first, then work in flight, then -// work that is over — with the one rank the design keeps for the news a folded -// family wears, because "something in here did not come off" is louder than -// "something in here has not started". -func TestTheRailRanksYourCallFirstThenMovingThenOver(t *testing.T) { +// THE ORDER IS THE TIER'S: the person's call first, in amber in the band, then +// a failure nobody has opened, in ink in the band, then work in flight, then +// work that has not started, then work that is over, each under its heading. +func TestTheColumnFilesYourCallFirstThenMovingThenOver(t *testing.T) { a, _, _ := taskApp(t) drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})}, streamEventMsg{gen: a.gen, ev: update(2, "Mix audio", session.TaskQueued, session.TaskNotice{})}, streamEventMsg{gen: a.gen, ev: update(3, "Fix the nil-map", session.TaskRunning, session.TaskNotice{})}, + streamEventMsg{gen: a.gen, ev: update(4, "Cut the goldens", session.TaskRunning, session.TaskNotice{})}, streamEventMsg{gen: a.gen, ev: update(4, "Cut the goldens", session.TaskFailed, session.TaskNotice{Ending: session.TaskEndingSteps})}, streamEventMsg{gen: a.gen, ev: update(5, "Port the parser", session.TaskUnverified, session.TaskNotice{Merge: mergeWordAborted, Branch: "task/parser"})}, ) - ranks := map[uint64]int{} - for id := uint64(1); id <= 5; id++ { - ranks[id] = a.railGlyphRank(a.tasks[id]) + band := a.sideBand() + if len(band) != 2 || band[0].key != "task/5" || !band[0].ask || band[1].key != "fail/4" || band[1].ask { + t.Fatalf("the band is not the question in amber then the failure in ink: %+v", band) + } + railOpenAll(a) + var order []uint64 + for _, e := range a.railEntries() { + if e.node != nil { + order = append(order, e.node.id) + } } - if !(ranks[5] < ranks[3] && ranks[3] < ranks[4] && ranks[4] < ranks[2] && ranks[2] < ranks[1]) { - t.Fatalf("the rail ranks are out of order: %v", ranks) + if len(order) != 3 || order[0] != 3 || order[1] != 2 || order[2] != 1 { + t.Fatalf("the list is %v, want running 3, queued 2, done 1, and nothing the band holds", order) } } -// A FOLDED FAMILY WEARS ITS LOUDEST CHILD, and a child whose decision belongs to -// the parent's own agent is not what makes the fold a demand — the parent is -// already holding that question. It is read off the ask's owner and off nothing -// else, and the row still says what it is asking about. -func TestAFoldedFamilyWearsItsLoudestChild(t *testing.T) { +// A QUESTION IS THE PERSON'S UNTIL SOMEBODY ELSE HOLDS IT. A child whose +// decision belongs to the parent's own agent is not a demand on the person, +// so it leaves the band; it is read off the ask's owner and off nothing else, +// and the row still says what it is asking about. +func TestAQuestionSomebodyElseHoldsLeavesTheBand(t *testing.T) { a, _, _ := taskApp(t) drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Port the parser", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})}, @@ -267,20 +274,18 @@ func TestAFoldedFamilyWearsItsLoudestChild(t *testing.T) { Merge: mergeWordAborted, Branch: "task/goldens", })}, ) - // A ROOT QUESTION NOBODY ELSE IS HOLDING IS THE LOUDEST THING ON THE COLUMN. kid := a.tasks[2] - if got := a.railGlyphRank(kid); got != 0 { - t.Fatalf("an unanswered question ranks %d, want 0", got) + if band := a.sideBand(); len(band) != 1 || band[0].key != "task/2" || !band[0].ask { + t.Fatalf("an unanswered question is not the band's: %+v", band) } if glyph := plain(a.railTreeGlyph(kid)); glyph != glyphAsk { t.Fatalf("the child wears %q, want %q", glyph, glyphAsk) } - // Hand the decision to the model and the fold stops being a demand — and the - // row goes on reading its reason either way, because a person watching it is - // owed what it is asking about whoever is answering. kid.decider = session.TaskAskOwnerModel - if got := a.railGlyphRank(kid); got == 0 { - t.Fatalf("a question the model holds still ranks as a demand") + for _, item := range a.sideBand() { + if item.key == "task/2" { + t.Fatalf("a question the model holds is still in the band: %+v", item) + } } if group := a.railGroupOf(kid); group == railDone { t.Fatalf("a question nobody has answered is filed under %q", railGroupWords[group]) @@ -530,5 +535,10 @@ func railSaid(a *app) string { } out = append(out, row) } + // AND THE HINT LINE OVER EACH ROW, which is where what a row has no room + // for is said now that every row is one line. + for _, id := range a.taskOrder { + out = append(out, railHint(a, id)) + } return strings.Join(strings.Fields(strings.Join(out, " ")), " ") } diff --git a/internal/tui3/taskview.go b/internal/tui3/taskview.go index 51bb949915..38eceebf7a 100644 --- a/internal/tui3/taskview.go +++ b/internal/tui3/taskview.go @@ -275,24 +275,17 @@ const ( // the top of the list now ([tasksControlRow]), where the typing lands, and an // echo under the list would be the frame saying one thing twice. taskSheetFilterNone = "nothing matches" - // taskSheetMoreHint is the line at the bottom of the ROSTER'S COLUMN that - // reaches this page (task.go's [app.railFootRows]). It is shaped like the two - // lines under it — the key, then what it reaches — and it is drawn only when - // there is genuinely more here than the column is showing (task.go's - // [app.railFootRows] weighs it against [app.railFoldedAny] and - // [app.railHasRecord]). - taskSheetMoreHint = taskSheetKey + " view more" - // taskSheetPastHint is that SAME LINE when what is behind it is the project's - // own record, and it is the commoner of the two by a long way: any directory - // that has been worked in before has one. + // taskSheetPastHint is the line at the bottom of the ROSTER'S COLUMN that + // reaches this page (task.go's [app.railFootRows]), drawn when what is + // behind it is the project's own record: any directory that has been worked + // in before has one. // - // IT IS ONE DOOR WEARING THE NAME OF WHAT IT OPENS, not a second door. The - // column has exactly one line onto this page and the words on it say which - // question the page will answer — "earlier" when there is history down there, - // "view more" when the only thing the column is holding back is a family it - // folded. A permanent "view more" over a month of finished work never told - // anybody the work existed, which is the whole reason the record was ever - // footnoted onto the column in the first place. + // IT WEARS THE NAME OF WHAT IT OPENS. It used to say `view more` as well, + // when the only thing the column held back was a family it folded; the + // column folds its own groups now and a press on the heading opens them, so + // "earlier" is the one thing this line can promise. A permanent "view more" + // over a month of finished work never told anybody the work existed, which is + // the whole reason the record was ever footnoted onto the column. // // It is [taskSheetPastHead]'s own word rather than a second one, because it is // the section it lands you in. diff --git a/internal/tui3/taskview_test.go b/internal/tui3/taskview_test.go index 02078c44ac..dad024e6b6 100644 --- a/internal/tui3/taskview_test.go +++ b/internal/tui3/taskview_test.go @@ -688,7 +688,7 @@ func TestTheColumnOffersItsDoorOnlyWhenThereIsSomethingBehindIt(t *testing.T) { // One node, nothing folded, and no record: the column is showing the whole of // what there is to show. a.taskUpdate(update(1, "Ship the port", session.TaskRunning, session.TaskNotice{})) - for _, gone := range []string{taskSheetMoreHint, taskSheetPastHint} { + for _, gone := range []string{taskSheetKey + " view more", taskSheetPastHint} { if rail := rosterText(a, a.viewHeight()); strings.Contains(rail, gone) { t.Fatalf("the column offered %q with nothing behind it:\n%s", gone, rail) } @@ -700,7 +700,7 @@ func TestTheColumnOffersItsDoorOnlyWhenThereIsSomethingBehindIt(t *testing.T) { pastTask("1", "ship-the-port", "Ship the port", time.Minute), } a.comp.tasks[0].SessionID = a.taskSheetSelfID() - for _, gone := range []string{taskSheetMoreHint, taskSheetPastHint} { + for _, gone := range []string{taskSheetKey + " view more", taskSheetPastHint} { if rail := rosterText(a, a.viewHeight()); strings.Contains(rail, gone) { t.Fatalf("the column offered %q for a row it is already drawing:\n%s", gone, rail) } @@ -727,41 +727,21 @@ func TestTheColumnOffersItsDoorOnlyWhenThereIsSomethingBehindIt(t *testing.T) { t.Fatalf("the page door does not use the shared hint palette:\n%q", painted) } // The history door stays in the footer after the task actions and hide control. - if hide, history := strings.Index(rail, railStowHint), strings.Index(rail, taskSheetPastHint); hide < 0 || history <= hide { + if hide, history := strings.Index(rail, sideHideKey), strings.Index(rail, taskSheetPastHint); hide < 0 || history <= hide { t.Fatalf("history does not follow the hide control:\n%s", rail) } } -// A FOLDED FAMILY EARNS IT TOO, because a folded root is one row standing for -// work the column is deliberately not drawing — and with no record behind it the -// same line says `view more` instead, because there is no earlier work to -// promise. -func TestAFoldedFamilyEarnsTheViewMoreLine(t *testing.T) { - a, _, _ := taskApp(t) - a.profileDir = t.TempDir() - railRun(a) - if rail := rosterText(a, a.viewHeight()); strings.Contains(rail, taskSheetMoreHint) { - t.Fatalf("an open column with no record offered more:\n%s", rail) - } - a.railSetOpen(a.tasks[1], false) - rail := rosterText(a, a.viewHeight()) - if !strings.Contains(rail, taskSheetMoreHint) { - t.Fatalf("a folded family did not earn the line:\n%s", rail) - } - if strings.Contains(rail, taskSheetPastHint) { - t.Fatalf("a column with no record promised earlier work:\n%s", rail) - } -} - // AND THE LINE IS A BUTTON AS WELL AS A KEY. A row that names a chord and cannot // be pressed is an affordance for one of the two hands — and one that cannot // light under the pointer is a button nothing says is a button. func TestPressingViewMoreOpensTheTaskPage(t *testing.T) { a, _, _ := taskApp(t) + a.file = "/w/.codeaf/v3/sessions/-w/current/session.jsonl" a.profileDir = t.TempDir() railRun(a) - a.railSetOpen(a.tasks[1], false) + a.comp.tasks = []session.TaskIndexEntry{pastTask("9", "port-the-parser", "Port the parser", 40*time.Hour)} at := railMoreLine(t, a) if _, took := a.railPress(a.bodyWidth()+4, at+a.topHeight()); !took { @@ -806,7 +786,7 @@ func railMoreLine(t *testing.T, a *app) int { // ── the column keeps what is running ──────────────────────────────────────── -// The hide control stays pinned while all tasks scroll in creation order. +// The header stays pinned while every task scrolls. func TestSidebarHeaderStaysWhileRunningWorkScrolls(t *testing.T) { a, _, _ := taskApp(t) a.taskUpdate(update(1, "Ship the port", session.TaskRunning, session.TaskNotice{})) @@ -814,6 +794,7 @@ func TestSidebarHeaderStaysWhileRunningWorkScrolls(t *testing.T) { a.taskUpdate(update(uint64(i), "landed "+itoa(i), session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})) } + railOpenAll(a) drive(t, a, altT()) for i := 0; i < 40; i++ { @@ -824,7 +805,7 @@ func TestSidebarHeaderStaysWhileRunningWorkScrolls(t *testing.T) { t.Fatalf("the running task did not scroll with the list:\n%s", rail) } // The hide control remains the first row. - if !strings.Contains(railText(a, a.viewHeight())[0], railStowHint) { + if !strings.Contains(railText(a, a.viewHeight())[0], sideHideKey) { t.Fatal("the hide control moved with the task list") } if strings.Contains(rail, "landed 2 ") { @@ -998,12 +979,11 @@ func TestAColumnFullOfRunningWorkKeepsAllOfItAndStillOffersTheDoor(t *testing.T) if strings.Contains(rail, "Port the parser") { t.Fatalf("the record took a row from running work:\n%s", rail) } - // FOUR AND NOT FIVE, because the column opens with its section label now - // (margin.go): the label is geography and it is pinned above the work like - // every other line of the moving head, so a nine-row column spends one of its - // rows saying where it is. What it must never spend a row on is the RECORD, - // which is what this test is about and is still true above. - for i := 1; i <= 4; i++ { + // THE NEWEST FOUR, because the column opens with its header and the group's + // heading, and the newest work is first under it. What it must never spend a + // row on is the RECORD, which is what this test is about and is still true + // above. + for i := 8; i >= 5; i-- { if !strings.Contains(rail, "running "+itoa(i)) { t.Fatalf("running %d was evicted from the column:\n%s", i, rail) } @@ -1030,7 +1010,7 @@ func TestAnEmptySessionSaysSoAndStillNamesTheDoorOntoTheRecord(t *testing.T) { if strings.Contains(bare, "no tasks yet") { t.Fatalf("an empty column announced its emptiness:\n%s", bare) } - for _, gone := range []string{taskSheetPastHint, taskSheetMoreHint} { + for _, gone := range []string{taskSheetPastHint, taskSheetKey + " view more"} { if strings.Contains(bare, gone) { t.Fatalf("an empty project drew %q, which it does not have:\n%s", gone, bare) } @@ -1081,6 +1061,7 @@ func TestTheRostersCursorStopsAtTheLastTaskOfThisConversation(t *testing.T) { a.comp.tasks = []session.TaskIndexEntry{ pastTask("9", "port-the-parser", "Port the parser", time.Hour), } + railOpenAll(a) rosterText(a, a.viewHeight()) drive(t, a, altT()) diff --git a/internal/tui3/taskwords_test.go b/internal/tui3/taskwords_test.go index e63c30bccd..57160c79cc 100644 --- a/internal/tui3/taskwords_test.go +++ b/internal/tui3/taskwords_test.go @@ -58,8 +58,8 @@ func TestAFinishingNodeSaysWhatItIsClosingAtEveryWidth(t *testing.T) { width int want []string }{ - {underWidth(railCols), []string{"finishing · adding amp-la…", "42s · 9.9k · $0.31 · gpt-5"}}, - {underWidth(railSlimCols), []string{"finishing · adding …", "42s · 9.9k · $0.31"}}, + {underWidth(underCols), []string{"finishing · adding amp-la…", "42s · 9.9k · $0.31 · gpt-5"}}, + {underWidth(underSlimCols), []string{"finishing · adding …", "42s · 9.9k · $0.31"}}, } { rows := a.railUnder(node, tc.width) if len(rows) != len(tc.want) { @@ -79,18 +79,18 @@ func TestAFinishingNodeSaysWhatItIsClosingAtEveryWidth(t *testing.T) { // at two ([railUnderRows]) and the call the node happens to be inside of says // nothing the finishing line and the telemetry do not already say better. node.tool, node.toolBegan = "bash go test ./...", a.now().Add(-24*time.Second) - rows := a.railUnder(node, underWidth(railCols)) + rows := a.railUnder(node, underWidth(underCols)) if len(rows) != railUnderRows || plain(rows[0]) != "finishing · adding amp-la…" { t.Fatalf("a live call displaced the finishing line:\n%q", rows) } node.tool, node.toolBegan = "", time.Time{} - // AND THE COLUMN ITSELF DRAWS IT, at both widths the roster has. The rows - // above are the block; this is the block on screen, under the node's own name - // and in the running group. + // AND THE COLUMN ITSELF SAYS IT, at both widths the roster has. The rows + // above are the block; this is the block on screen, on the hint line over + // the node's own row in the running group. for _, width := range []int{200, 110} { a.width = width - roster := rosterText(a, 12) + roster := rosterText(a, 12) + "\n" + railHint(a, 7) if !strings.Contains(roster, "finishing · adding") { t.Fatalf("the roster at %d columns does not say what the node is finishing:\n%s", width, roster) } @@ -108,7 +108,7 @@ func TestTheFinishingLineDropsWhenTheGapIsClosed(t *testing.T) { node := a.tasks[7] advance(42 * time.Second) node.tool, node.toolBegan = "bash go test ./...", a.now().Add(-24*time.Second) - if got := plain(a.railUnder(node, underWidth(railCols))[0]); !strings.HasPrefix(got, taskFinishingWord) { + if got := plain(a.railUnder(node, underWidth(underCols))[0]); !strings.HasPrefix(got, taskFinishingWord) { t.Fatalf("the finishing line is not on the node at all: %q", got) } @@ -120,7 +120,7 @@ func TestTheFinishingLineDropsWhenTheGapIsClosed(t *testing.T) { if node.mending != "" { t.Fatalf("the node still carries %q", node.mending) } - rows := a.railUnder(node, underWidth(railCols)) + rows := a.railUnder(node, underWidth(underCols)) if len(rows) != railUnderRows { t.Fatalf("the under-block is %d rows after the gap closed:\n%q", len(rows), rows) } @@ -195,7 +195,7 @@ func TestAHeldNodeSaysWhatIsHoldingItAtEveryWidth(t *testing.T) { for _, w := range []struct { width int want string - }{{underWidth(railCols), tc.full}, {underWidth(railSlimCols), tc.slim}} { + }{{underWidth(underCols), tc.full}, {underWidth(underSlimCols), tc.slim}} { rows := a.railUnder(node, w.width) if len(rows) != 1 || plain(rows[0]) != w.want { t.Fatalf("at %d cells the under-block is %q, want one row %q", w.width, rows, w.want) @@ -204,10 +204,11 @@ func TestAHeldNodeSaysWhatIsHoldingItAtEveryWidth(t *testing.T) { t.Fatalf("at %d cells the row is %d cells wide", w.width, got) } } - // AND THE COLUMN ITSELF DRAWS IT, at both widths the roster has. + // AND THE COLUMN ITSELF SAYS IT, at both widths the roster has, on + // the hint line over the row. for _, width := range []int{200, 110} { a.width = width - if roster := rosterText(a, 12); !strings.Contains(roster, a.taskStatus(node).Word+" · ") { + if roster := rosterText(a, 12) + "\n" + railHint(a, 7); !strings.Contains(roster, a.taskStatus(node).Word+" · ") { t.Fatalf("the roster at %d columns does not say the node is held:\n%s", width, roster) } } @@ -222,7 +223,7 @@ func TestAHeldNodeSaysWhatIsHoldingItAtEveryWidth(t *testing.T) { if node.waiting != "" { t.Fatalf("the node still carries %q", node.waiting) } - if rows := a.railUnder(node, underWidth(railCols)); len(rows) != 0 { + if rows := a.railUnder(node, underWidth(underCols)); len(rows) != 0 { t.Fatalf("the under-block outlived the hold: %q", rows) } if strings.Contains(rosterText(a, 12), taskHeldWord) { @@ -249,8 +250,8 @@ func TestAPacedNodeWaitsWhereItsToolLineWouldBe(t *testing.T) { width int want []string }{ - {underWidth(railCols), []string{"waiting · rate limited", "42s · 9.9k · $0.31 · gpt-5"}}, - {underWidth(railSlimCols), []string{"waiting · rate limi…", "42s · 9.9k · $0.31"}}, + {underWidth(underCols), []string{"waiting · rate limited", "42s · 9.9k · $0.31 · gpt-5"}}, + {underWidth(underSlimCols), []string{"waiting · rate limi…", "42s · 9.9k · $0.31"}}, } { rows := a.railUnder(node, tc.width) if len(rows) != len(tc.want) { @@ -273,7 +274,7 @@ func TestAPacedNodeWaitsWhereItsToolLineWouldBe(t *testing.T) { // but the hold. drive(t, a, streamEventMsg{gen: a.gen, ev: update(7, "Write the report", session.TaskRunning, session.TaskNotice{Model: "openai/gpt-5", CostUSD: 0.31})}) - rows := a.railUnder(node, underWidth(railCols)) + rows := a.railUnder(node, underWidth(underCols)) if len(rows) != railUnderRows || plain(rows[0]) != "bash go test ./... · 24s" { t.Fatalf("the call row did not come back:\n%q", rows) } @@ -291,7 +292,7 @@ func TestAWaitingDependencyOutranksTheHoldWord(t *testing.T) { })}, ) node := a.tasks[2] - got := plain(strings.Join(a.railUnder(node, underWidth(railCols)), "\n")) + got := plain(strings.Join(a.railUnder(node, underWidth(underCols)), "\n")) if !strings.Contains(got, "waits: Collect sources") { t.Fatalf("the blocked node says %q, want the prerequisite it waits on", got) } @@ -306,7 +307,7 @@ func TestAWaitingDependencyOutranksTheHoldWord(t *testing.T) { // unblocked, it is still not running, and the row says why. drive(t, a, streamEventMsg{gen: a.gen, ev: update(1, "Collect sources", session.TaskDone, session.TaskNotice{Merge: mergeWordMerged})}) - if got := plain(strings.Join(a.railUnder(node, underWidth(railCols)), "\n")); got != "queued · slot" { + if got := plain(strings.Join(a.railUnder(node, underWidth(underCols)), "\n")); got != "queued · slot" { t.Fatalf("the unblocked node says %q, want the hold", got) } } @@ -423,7 +424,8 @@ func TestNoTerminalStateEverSpeaksOfTheMachinery(t *testing.T) { card.open = true a.touch() } - seen := strings.ToLower(taskText(a) + "\n" + rosterText(a, 20)) + railOpenAll(a) + seen := strings.ToLower(taskText(a) + "\n" + rosterText(a, 20) + "\n" + railHint(a, 7)) // A SWEEP OVER AN EMPTY SCREEN PASSES EVERYTHING, so the screen is // proved to have the node on it before it is proved to be clean. if !strings.Contains(seen, "port the parser") { diff --git a/internal/tui3/teamcard.go b/internal/tui3/teamcard.go new file mode 100644 index 0000000000..ae0d274738 --- /dev/null +++ b/internal/tui3/teamcard.go @@ -0,0 +1,213 @@ +package tui3 + +import ( + "strings" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── WHAT A TEAM SAID TO A CONVERSATION, AS A QUOTED CARD ──────────────────── +// +// A line the manager or a teammate addressed to a conversation reaches it +// through the Traffic, at a step boundary, as ONE note the session wrote +// (internal/session's team.go): a sentence saying these are the team's words +// and not the person's, the lines, and the authority rule under them. The +// journal keeps it as the session's own line, and a page opened on the +// conversation draws it here instead of in the dim lane every other session +// line takes: as the card it is, headed by who said it to whom, +// +// ◆ manager → @lexer do +// │ rewrite the lexer so string escapes are handled in one pass +// +// and never with the person's `›`, because the person did not say it. A member +// the manager started opens on this card: the brief is its first thing, and +// the card is how a person opening that tab sees why it is working. +// +// The shape parsed is the session's, and only the lines are drawn: the +// sentence above them and the rule under them are for the model. + +// teamAsideLead is how the session's team note begins. +const teamAsideLead = "Team traffic in " + +// teamCard is one line of a team note: who said it, to whom, whether it was a +// directive, and what was said. +type teamCard struct { + from, to, tag, text string + // who is the raw speaker (a handle, or manager), and thread the line's own + // entry id when the delivery numbered it; both empty on a card read from + // the note's text alone. + who, thread string +} + +// teamAsideCards reads a session's team note into its lines, and reports +// whether text was one. +func teamAsideCards(text string, mark string) ([]teamCard, bool) { + lines := strings.Split(strings.TrimSpace(text), "\n") + if len(lines) < 2 || !strings.HasPrefix(lines[0], teamAsideLead) { + return nil, false + } + self := mark + " manager" + if at := strings.Index(lines[0], "(@"); at >= 0 { + if end := strings.Index(lines[0][at:], ")"); end > 0 { + self = lines[0][at+1 : at+end] + } + } + var cards []teamCard + for _, line := range lines[1:] { + if strings.HasPrefix(line, "(") { + break + } + if strings.HasPrefix(line, " ") && len(cards) > 0 { + cards[len(cards)-1].text += "\n" + strings.TrimSpace(line) + continue + } + speaker, said, ok := strings.Cut(line, ": ") + if !ok { + continue + } + // A line delivered to a member ends its head with its number, "#42". + if at := strings.LastIndex(speaker, " #"); at >= 0 { + if _, numbered := teamstore.ThreadID(speaker[at+1:]); numbered { + speaker = speaker[:at] + } + } + card := teamCard{to: self, text: strings.TrimSpace(said)} + if who, aim, aimed := strings.Cut(speaker, " to "); aimed { + speaker = who + switch aim { + case "the room": + card.to = "room" + case "everyone": + card.to = "all" + case "the manager": + card.to = mark + " manager" + default: + card.to = aim + } + } + speaker = strings.TrimSpace(strings.TrimPrefix(speaker, "◆")) + switch { + case strings.HasPrefix(speaker, "directive from manager"): + card.from, card.tag = mark+" manager", "do" + case strings.HasPrefix(speaker, "from manager"): + card.from = mark + " manager" + case strings.HasPrefix(speaker, "from "): + card.from = strings.TrimPrefix(speaker, "from ") + default: + card.from = speaker + } + cards = append(cards, card) + } + return cards, len(cards) > 0 +} + +// teamLineCards is the lines the session took apart for a delivery +// ([session.TeamLine]) as cards; the aside's text still says who they were for. +func teamLineCards(lines []session.TeamLine, text, mark string) ([]teamCard, bool) { + if len(lines) == 0 { + return nil, false + } + self := mark + " manager" + if at := strings.Index(text, "(@"); at >= 0 { + if end := strings.Index(text[at:], ")"); end > 0 { + self = text[at+1 : at+end] + } + } + addr := func(s string) string { + switch s { + case "": + return self + case teamstore.FromManager: + return mark + " manager" + case teamstore.FromYou: + return "you" + case teamstore.FromSystem: + return "codeaf" + case teamstore.ToRoom: + return "room" + case teamstore.ToEveryone: + return "all" + } + return "@" + strings.TrimPrefix(s, "@") + } + cards := make([]teamCard, 0, len(lines)) + for _, l := range lines { + c := teamCard{from: addr(l.From), to: addr(l.To), text: strings.TrimSpace(l.Text), who: l.From, thread: l.Thread} + if l.Kind == teamstore.KindDirective { + c.tag = "do" + } + cards = append(cards, c) + } + return cards, true +} + +// teamCardRows draws one team note's lines as quoted cards, width wide. +func (a *app) teamCardRows(e entry, width int) []string { + cards, ok := teamLineCards(e.team, e.text, a.teamManagerMark()) + if !ok { + cards, ok = teamAsideCards(e.text, a.teamManagerMark()) + } + if !ok { + return []string{a.pal.dim("· " + firstLine(e.text))} + } + name := "" + if len(e.team) > 0 { + name = e.team[0].Team + } + // THE MANAGER IS NOT SHOWN AN ANSWER TWICE: one already under its + // question's card in this conversation is left out here, and a note left + // with nothing is one dim line (teamthreadcard.go). + if t, managed := a.teamFrontManaged(); managed && (name == "" || t.Name == name) { + kept := cards[:0:0] + var answered []string + for _, c := range cards { + if c.who != "" && c.who != teamstore.FromManager && c.who != teamstore.FromYou && c.who != teamstore.FromSystem && + a.teamNoteReplyShown(t, c.who, c.text) { + if !strings.Contains(strings.Join(answered, " "), "@"+c.who) { + answered = append(answered, "@"+c.who) + } + continue + } + kept = append(kept, c) + } + if len(kept) == 0 { + return []string{a.pal.dim("· " + strings.Join(answered, " ") + " answered" + hintSegment + "in the thread above")} + } + cards = kept + } + mirror, self := a.teamNoteSelf(name) + pal := a.pal + arrow := a.linearMark("→", "->") + bar := a.linearMark("│", "|") + var out []string + for i, c := range cards { + if i > 0 { + out = append(out, "") + } + head := pal.muted(c.from) + pal.dim(" "+arrow+" ") + pal.muted(c.to) + if strings.HasPrefix(c.from, a.teamManagerMark()) { + head = pal.accent(a.teamManagerMark()) + pal.muted(strings.TrimPrefix(c.from, a.teamManagerMark())) + + pal.dim(" "+arrow+" ") + pal.muted(c.to) + } + if c.tag != "" { + head += " " + pal.dim(c.tag) + } + out = append(out, fit(head, width)) + for _, para := range strings.Split(c.text, "\n") { + for _, line := range wrap(para, max(width-2, 8)) { + out = append(out, pal.dim(bar+" ")+pal.ink(line)) + } + } + // THE MEMBER'S OWN ANSWERS HANG UNDER THE MANAGER'S LINE, muted, as the + // manager's card has them (teamthreadcard.go). + if self != "" && c.who == teamstore.FromManager && c.thread != "" { + if th, found := threadOf(a.traffic.rows[mirror.ID], c.thread); found { + for _, r := range a.threadReplyRows(mirror.ID, th, self, width, func(string) bool { return false }) { + out = append(out, r.text) + } + } + } + } + return out +} diff --git a/internal/tui3/teamclose.go b/internal/tui3/teamclose.go new file mode 100644 index 0000000000..58ee63b2f1 --- /dev/null +++ b/internal/tui3/teamclose.go @@ -0,0 +1,474 @@ +package tui3 + +import ( + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── CLOSING, REOPENING AND DELETING A TEAM (DESIGN.md section 8.5, c-9) ───── +// +// A team is open or closed. `Close…` asks what to do only when there is +// something to decide: with nothing running it closes at once and offers Undo, +// because a question with one useful answer is friction. With work running the +// card offers three ([app.teamSheetOpen]'s close mode): +// +// - `Wrap up first` (the default while a manager has work running): the +// manager is asked, in the team's Traffic, to have everyone finish and +// commit, answer what it can, and bring the person a closing report. The +// team closes only when the person picks `Close` on that report, which is +// an ordinary card in the inbox. +// - `Close now`: every member's current turn is stopped (the person's own +// Stop, nothing deleted), the team's tabs close, and the team moves to +// Closed, in one step, with Undo. +// - `Cancel`. +// +// A CONVERSATION THAT IS ALSO IN ANOTHER OPEN TEAM IS NEVER STOPPED OR CLOSED +// by this: it is still that team's. Closing a team closes the teams under it +// (internal/teams' [teamstore.File.Close]); reopening reopens exactly what the +// close closed. Delete is only ever offered on a closed team, and forgets the +// grouping, the Traffic and the packets; the conversations stay in history. + +// teamsUndoFor is how long a close offers Undo: the wall's own span for an +// Apply, so a person learns one length of time for taking a thing back. +const teamsUndoFor = wallOrganizedFor + +// teamsUndo is the last close this window made, for Undo. +type teamsUndo struct { + team string + name string + shut []string + at time.Time +} + +// teamsCloseKeys is every conversation a close of team id stops and whose tab +// it closes: the members of the team and of every open team under it, less any +// that is also in an open team outside them. +func (a *app) teamsCloseKeys(id string) []string { + closing := map[string]bool{id: true} + for _, t := range a.teamTree().Descendants(id) { + if !t.Closed() { + closing[t.ID] = true + } + } + elsewhere := map[string]bool{} + for _, t := range a.wall.teams { + if closing[t.ID] || t.Closed() || t.Root { + continue + } + for _, m := range t.Members { + elsewhere[m.Key] = true + } + } + var keys []string + seen := map[string]bool{} + for _, t := range a.wall.teams { + if !closing[t.ID] { + continue + } + for _, m := range t.Members { + if elsewhere[m.Key] || seen[m.Key] { + continue + } + seen[m.Key] = true + keys = append(keys, m.Key) + } + } + return keys +} + +// teamsRunning is the members of team id (and the teams under it) that are +// working now, by handle or name, and whether its manager is one of them or +// has any running at all. +func (a *app) teamsRunning(id string) (names []string, managed bool) { + t, ok := a.teamByID(id) + if !ok { + return nil, false + } + front := a.frontTabKey() + for _, key := range a.teamsCloseKeys(id) { + if !a.trafficHeld(key) || a.tabSignalFor(key, key == front) != tabWorking { + continue + } + name := key + for _, u := range a.wall.teams { + if m, ok := u.Member(key); ok { + name = m.Word + if m.Handle != "" { + name = "@" + m.Handle + } + if key == u.Manager { + name = a.teamManagerMark() + " manager" + } + break + } + } + names = append(names, name) + } + return names, t.Manager != "" && len(names) > 0 +} + +// teamsCloseAsk is `Close…`: at once with Undo when nothing runs, and the card +// when something does. +func (a *app) teamsCloseAsk(id string) tea.Cmd { + t, ok := a.teamByID(id) + if !ok || t.Closed() { + return nil + } + if t.Root { + a.tp.msg = "All teams does not close; remove its manager instead" + a.touch() + return nil + } + if a.teamsOff() { + a.tp.msg = teamHostedWord + a.touch() + return nil + } + if names, _ := a.teamsRunning(id); len(names) > 0 { + return a.teamSheetOpen(id, teamSheetClose) + } + return a.teamsCloseNow(id, "") +} + +// teamsCloseNow closes team id at once: every member's turn stopped, the +// team's tabs closed, the team moved to Closed, and Undo offered. report is the +// closing report's packet id when the close was the report's `Close`. +func (a *app) teamsCloseNow(id, report string) tea.Cmd { + t, ok := a.teamByID(id) + if !ok || t.Closed() || t.Root { + return nil + } + now := a.now() + shut := a.teamsStopMembers(id) + if err := a.teamEdit(func(f *teamstore.File) error { return f.Close(id, now, report) }); err != nil { + a.tp.msg = "not closed: " + err.Error() + a.touch() + return nil + } + return a.teamsAfterClose(t, shut, now, true) +} + +// teamsStopMembers is the interface's half of every close (DESIGN.md 8.5): +// each member of team id (and of the open teams under it, less any shared +// with an open team outside them) that is working has its turn stopped, and +// every one but the conversation in front has its tab closed. It answers the +// tabs it closed, for Undo. +func (a *app) teamsStopMembers(id string) []string { + front := a.frontTabKey() + var shut []string + for _, key := range a.teamsCloseKeys(id) { + if !a.trafficHeld(key) { + continue + } + // THE PERSON'S OWN STOP, and nothing more: the current turn ends and + // nothing is deleted (teamtraffic.go's [app.trafficStop]). + if a.tabSignalFor(key, key == front) == tabWorking { + a.trafficStop(key) + } + // The conversation in front is what this page hosts; its tab stays, + // because closing it here would move the person's focus. + if key != front { + a.tabShutKey(key) + shut = append(shut, key) + } + } + return shut +} + +// teamsAfterClose is what follows a close on this window: Undo offered, the +// selection and the wall moved off the team, and its Traffic told when tell +// says the store did not tell it already. +func (a *app) teamsAfterClose(t team, shut []string, now time.Time, tell bool) tea.Cmd { + id := t.ID + // On the page the Undo row says it; off it the close is said where the + // person is standing. + a.tp.undo = teamsUndo{team: id, name: t.Name, shut: shut, at: now} + if !a.at(pageTeams) { + a.note(t.Name + " is closed · its conversations are kept · Closed on the teams page reopens it") + } + if a.tp.sel == id { + a.tp.sel = "" + a.teamsSettle() + } + if a.wall.activeID == id { + a.wall.activeID = "" + } + a.tp.top = teamsTopCache{} + a.touch() + if !tell { + return a.teamsBringManager() + } + return tea.Batch(a.teamsTell(id, teamstore.Entry{Kind: teamstore.KindClose, From: teamstore.FromYou, To: teamstore.ToEveryone, + Text: "the person closed the team"}), a.teamsBringManager()) +} + +// teamsUndoing reports whether Undo is still offered for the last close. +func (a *app) teamsUndoing() bool { + u := a.tp.undo + return u.team != "" && a.now().Sub(u.at) < teamsUndoFor +} + +// teamsUndoClose takes the last close back: the team reopened, and the tabs it +// closed back on the strip (the conversations were held behind the whole time). +func (a *app) teamsUndoClose() tea.Cmd { + if !a.teamsUndoing() { + return nil + } + u := a.tp.undo + a.tp.undo = teamsUndo{} + for _, key := range u.shut { + delete(a.tabShut, key) + } + a.chatTabBar = tabBar{} + if err := a.teamEdit(func(f *teamstore.File) error { return f.Reopen(u.team) }); err != nil { + a.tp.msg = "not reopened: " + err.Error() + a.touch() + return nil + } + a.tp.msg = u.name + " is open again" + a.tp.sel = u.team + a.tp.top = teamsTopCache{} + a.touch() + return tea.Batch(a.teamsTell(u.team, teamstore.Entry{Kind: teamstore.KindReopen, From: teamstore.FromYou, To: teamstore.ToEveryone, + Text: "the person reopened the team"}), a.teamsBringManager()) +} + +// teamsReopen is `Reopen` on a closed team, and `Reopen <parent> too` on one +// whose parent is closed: the closed teams above it are reopened first, top +// down, because the store refuses a child under a closed parent +// ([teamstore.ErrParentClosed]). Its members' tabs come back where this window +// still holds them, and its manager resumes by being brought in front. +func (a *app) teamsReopen(id string, withParents bool) tea.Cmd { + t, ok := a.teamByID(id) + if !ok || !t.Closed() { + return nil + } + var chain []string + if withParents { + ups := a.teamAncestors(id) + for i := len(ups) - 1; i >= 0; i-- { + if ups[i].Closed() { + chain = append(chain, ups[i].ID) + } + } + } else if p, closed := a.teamsParentClosed(t); closed { + a.tp.msg = t.Name + " sits under " + p.Name + ", which is closed: reopen " + p.Name + " too" + a.touch() + return nil + } + chain = append(chain, id) + err := a.teamEdit(func(f *teamstore.File) error { + for _, c := range chain { + if u, ok := f.Team(c); ok && !u.Closed() { + continue + } + if err := f.Reopen(c); err != nil { + return err + } + } + return nil + }) + if err != nil { + a.tp.msg = "not reopened: " + err.Error() + a.touch() + return nil + } + for _, c := range chain { + if u, ok := a.teamByID(c); ok { + for _, m := range u.Members { + delete(a.tabShut, m.Key) + } + } + } + a.chatTabBar = tabBar{} + a.tp.sel = id + a.tp.msg = t.Name + " is open again" + a.tp.top = teamsTopCache{} + a.touch() + var tells []tea.Cmd + for _, c := range chain { + tells = append(tells, a.teamsTell(c, teamstore.Entry{Kind: teamstore.KindReopen, From: teamstore.FromYou, To: teamstore.ToEveryone, + Text: "the person reopened the team"})) + } + return tea.Batch(append(tells, a.teamsBringManager())...) +} + +// teamsWrapUp is `Wrap up first`: the seam's wrap-up door appends the one +// Traffic entry the manager's session reads as the request +// (teamstore.WrapUpRequest, DESIGN.md 8.8), and the session does the rest: the +// manager is woken, told to finish and commit, and brings a closing report, +// which arrives here as a card; past its time or money codeaf raises the +// report itself, marked incomplete. Over a connection whose engine has no +// such door the page says so and offers the other two. +func (a *app) teamsWrapUp(id string) tea.Cmd { + t, ok := a.teamByID(id) + if !ok || t.Manager == "" { + return nil + } + door := a.teamsSeam().WrapUp + if door == nil { + a.tp.msg = teamsNoWrapUpWord + a.touch() + return nil + } + a.tp.msg = "asked " + a.teamManagerMark() + " " + t.Name + "'s manager to wrap up · its closing report will be a card here" + a.touch() + return a.offLoop(func() func(bool) tea.Cmd { + err := door(id, "") + return func(bool) tea.Cmd { + if err != nil { + a.tp.msg = "the wrap-up was not asked for: " + err.Error() + a.touch() + } + return nil + } + }) +} + +// teamsNoWrapUpWord is what the close card and the page say where the seam has +// no wrap-up door: an engine older than the doors, over --host. +const teamsNoWrapUpWord = "Wrap up first is not offered over this connection: Close now, or Cancel" + +// teamsAcceptReport is the person's `Close` on a closing report: the interface +// stops the team's turns and closes its tabs now, and the store closes the +// team with the packet as its report (teamstore.AcceptClosing), after the +// decision is written. The window then reads the teams again, because the +// file moved under it. +func (a *app) teamsAcceptReport(p teamstore.Packet, decision string) tea.Cmd { + t, ok := a.teamByID(p.Origin) + if !ok || t.Closed() { + return nil + } + seam := a.teamsSeam() + if seam.AcceptClosing == nil { + // No door to close it on its report: close it here, the report named. + cmd := a.teamsCloseNow(p.Origin, p.ID) + return tea.Batch(cmd, a.teamsDecideOnly(seam, p.ID, decision)) + } + shut := a.teamsStopMembers(p.Origin) + reserved, now, id := teamReservedHues(a.pal), a.now(), p.ID + return a.offLoop(func() func(bool) tea.Cmd { + _, err := seam.Decide(id, teamstore.Person, decision, "") + closed := false + var teams []team + var stamp string + if err == nil { + closed, err = seam.AcceptClosing(id) + } + if err == nil { + teams, stamp, _, err = seam.ReadSince("", reserved) + } + return func(bool) tea.Cmd { + a.tp.packetsStamp = "" + if err != nil { + a.tp.msg = "not closed: " + err.Error() + a.touch() + return a.teamsRead(false) + } + a.teamAdopt(teamsClone(teams)) + a.traffic.stamp = stamp + var cmd tea.Cmd + if closed { + cmd = a.teamsAfterClose(t, shut, now, false) + } + return tea.Batch(cmd, a.teamsRead(false)) + } + }) +} + +// teamsDecideOnly writes the person's decision on packet id and reads the +// packets again. +func (a *app) teamsDecideOnly(seam TeamsSeam, id, decision string) tea.Cmd { + return a.offLoop(func() func(bool) tea.Cmd { + _, err := seam.Decide(id, teamstore.Person, decision, "") + return func(bool) tea.Cmd { + if err != nil { + a.tp.msg = "not decided: " + err.Error() + a.touch() + } + a.tp.packetsStamp = "" + return a.teamsRead(false) + } + }) +} + +// teamsTell appends one entry to team id's Traffic through the seam, off the +// ordered door line (it is the person's gesture). A seam with no Traffic door +// tells nothing, and the caller has already said so where it matters. +func (a *app) teamsTell(id string, e teamstore.Entry) tea.Cmd { + door := a.teamsSeam().Append + if door == nil { + return nil + } + return a.offLoop(func() func(bool) tea.Cmd { + err := door(id, e) + return func(bool) tea.Cmd { + if err != nil { + a.tp.msg = "the team's Traffic did not take it: " + err.Error() + a.touch() + } + return nil + } + }) +} + +// teamsDelete forgets closed team id through the seam, off the loop, and then +// reads the teams again, because the file moved under the window. +func (a *app) teamsDelete(id string) tea.Cmd { + t, ok := a.teamByID(id) + if !ok { + return nil + } + if !t.Closed() { + a.tp.msg = "only a closed team can be deleted" + a.touch() + return nil + } + seam := a.teamsSeam() + if seam.Delete == nil { + a.tp.msg = "delete is not available over this connection" + a.touch() + return nil + } + reserved, name := teamReservedHues(a.pal), t.Name + return a.offLoop(func() func(bool) tea.Cmd { + _, err := seam.Delete(id) + var teams []team + var stamp string + if err == nil { + teams, stamp, _, err = seam.ReadSince("", reserved) + } + return func(bool) tea.Cmd { + if err != nil { + a.tp.msg = "not deleted: " + err.Error() + a.touch() + return nil + } + a.teamAdopt(teamsClone(teams)) + a.traffic.stamp = stamp + a.tp.msg = name + " is forgotten; its conversations stay in your history" + if a.tp.sel == id { + a.tp.sel = "" + a.teamsSettle() + } + a.tp.top = teamsTopCache{} + a.touch() + return nil + } + }) +} + +// teamsCloseWords is the close card's sentence about what is running. +func teamsCloseWords(names []string) string { + switch len(names) { + case 0: + return "nothing is running" + case 1: + return names[0] + " is still working" + } + return strings.Join(names[:len(names)-1], ", ") + " and " + names[len(names)-1] + " are still working" +} diff --git a/internal/tui3/teamcoherence_test.go b/internal/tui3/teamcoherence_test.go new file mode 100644 index 0000000000..499215e48d --- /dev/null +++ b/internal/tui3/teamcoherence_test.go @@ -0,0 +1,416 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// titledAgent is a fake conversation that has a title, as a resumed one does. +type titledAgent struct { + *fakeAgent + title string +} + +func (f titledAgent) Title() string { return f.title } + +// teamAwayApp is trafficApp's team, harbor, with one member more that this window +// does not have open: a conversation the team kept from another day. +func teamAwayApp(t *testing.T) (a *app, harbor, awayKey string) { + t.Helper() + a, harbor, _, _ = trafficApp(t) + file := "/tmp/lab/quantum-gravity.jsonl" + awayKey = a.convKey(file) + m := teamMember{Key: awayKey, File: file, Where: "/tmp/lab", Word: "quantum gravity research"} + if err := a.teamEdit(func(f *teamstore.File) error { return f.AddMember(harbor, m) }); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + a.touch() + return a, harbor, awayKey +} + +// THE STRIP AND THE WALL AGREE ABOUT A TEAM. Both are what is open in this +// window, narrowed to it: a member not open here is not a tab and not a tile, +// the Teams row counts it apart, and the title offers it once, `1 more in +// harbor · Open them`. The owner's screen read `test 1` over three tabs. +func TestTheStripAndTheWallAgreeAboutATeam(t *testing.T) { + a, _, awayKey := teamAwayApp(t) + if row := plain(a.tabsRow(a.width)); strings.Contains(row, "quantum") { + t.Fatalf("a member not open here has a tab: %q", row) + } + for _, hit := range a.chatTabHits { + if hit.tab.key == awayKey { + t.Fatalf("a member not open here is a strip target: %+v", hit) + } + } + spend(t, a, a.openWall()) + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + open := len(a.wallShown(a.now())) + for _, want := range []string{ + "open in this window · in harbor", + "1 more in harbor · Open them", + "harbor " + itoa(open), + } { + if !strings.Contains(frame, want) { + t.Fatalf("the wall lacks %q:\n%s", want, frame) + } + } + if strings.Contains(frame, "quantum") { + t.Fatalf("a member not open here is a tile:\n%s", frame) + } +} + +// OPEN THEM RESUMES BEHIND AND MOVES NOTHING. The member becomes a tab and a +// tile, the conversation in front and the box stay as they were, the focus +// stays on the tile it was on, and the button is gone because every member is +// open now (the emptiness law). +func TestOpenThemResumesTheRestBehindAndMovesNothing(t *testing.T) { + a, _, awayKey := teamAwayApp(t) + opened := 0 + a.open = func(workspace, transcript string) (Conversation, error) { + opened++ + return Conversation{Agent: titledAgent{&fakeAgent{model: "m"}, "quantum gravity research"}, SessionFile: transcript, Workspace: workspace}, nil + } + a.input.insert("half a thought") + front := a.frontTabKey() + spend(t, a, a.openWall()) + _ = a.wallFrame(a.width, a.height) + focused := a.wallFocusedKey(a.wallShown(a.now())) + spend(t, a, wallKeyPress(a, "r")) + if opened != 1 { + t.Fatalf("Open them opened %d conversations", opened) + } + if a.frontTabKey() != front || string(a.input.value) != "half a thought" { + t.Fatalf("Open them moved the front: %q (was %q), box %q", a.frontTabKey(), front, string(a.input.value)) + } + if a.behind[awayKey] == nil { + t.Fatal("the member is not held behind") + } + if got := a.wallFocusedKey(a.wallShown(a.now())); got != focused { + t.Fatalf("the focus moved from %q to %q", focused, got) + } + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + if strings.Contains(frame, wallResumeWord) { + t.Fatalf("every member is open, yet the title still offers more:\n%s", frame) + } + if !strings.Contains(frame, "quantum gravity") { + t.Fatalf("the resumed member is not a tile:\n%s", frame) + } + a.touch() + if row := plain(a.tabsRow(a.width)); !strings.Contains(row, "quantum") { + t.Fatalf("the resumed member has no tab: %q", row) + } +} + +// THE GRAMMAR. A handle of a member of a team this conversation is in is a +// link; an `@word` that is no one's handle, an address and this conversation's +// own handle are plain text; a team's name is a link where it is written as a +// team and plain where it is an ordinary word. +func TestTheTeamLinkGrammar(t *testing.T) { + test := team{ID: "t1", Name: "test", Members: []teamMember{ + {Key: "k-sec", Handle: "security", Word: "santosh dev2 branch code complexity & security review"}, + {Key: "k-mil", Handle: "milestones", Word: "CodeAF repo issue tags & milestones"}, + {Key: "k-me", Handle: "boss"}, + }} + pal := newPalette(tokens.ANSI256, false) + for _, tc := range []struct { + name, text string + want []string + }{ + {"handles", "Ask @security, then @milestones.", []string{"@security", "@milestones"}}, + {"unknown handle", "Ask @nobody about it.", nil}, + {"own handle", "I am @boss here.", nil}, + {"address", "Write to santosh@security.dev today.", nil}, + {"team word before", "The team test has two members.", []string{"test"}}, + {"team word after", "Everything in the test team is done.", []string{"test"}}, + {"quoted", `Team traffic in "test" for you.`, []string{"test"}}, + {"ordinary word", "Run the test again.", nil}, + {"both", "@security is in team test.", []string{"@security", "test"}}, + } { + out, links := linkifyTeams(tc.text, pal, []team{test}, []team{test}, "k-me", true, -1) + var got []string + for _, l := range links { + got = append(got, ansi.Strip(ansi.Cut(out, l.span.from, l.span.to))) + } + if strings.Join(got, "|") != strings.Join(tc.want, "|") { + t.Errorf("%s: %q linked %q, want %q", tc.name, tc.text, got, tc.want) + } + if ansi.Strip(out) != tc.text { + t.Errorf("%s: the words changed: %q", tc.name, ansi.Strip(out)) + } + } +} + +// linkChat is trafficApp's manager in front, with one more member this window +// does not have open, @gravity, and a reply from the manager naming members. +func linkChat(t *testing.T, said string) (a *app, gravityKey string) { + t.Helper() + a, harbor, _, _ := trafficApp(t) + file := "/tmp/lab/quantum-gravity.jsonl" + gravityKey = a.convKey(file) + m := teamMember{Key: gravityKey, File: file, Where: "/tmp/lab", Word: "quantum gravity research", Handle: "gravity"} + if err := a.teamEdit(func(f *teamstore.File) error { return f.AddMember(harbor, m) }); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + a.width, a.height = 160, 30 + a.entries = append(a.entries, entry{kind: entryAssistant, text: said, settled: true}) + a.touch() + return a, gravityKey +} + +// teamLinkedRow is the first frame row carrying a team link, and its screen y. +func teamLinkedRow(a *app) (row, int, bool) { + body, _ := a.window(a.bodyWidth(), a.viewHeight()) + for i, r := range body { + for _, l := range r.links { + if l.team != "" { + return r, a.bodyTop() + i, true + } + } + } + return row{}, 0, false +} + +// A REPLY'S HANDLES ARE DOORS WITH A GROUND AND A HINT, AND A PRESS RESUMES. The +// manager writes about @gravity, which this window does not have open, and +// @nobody, which is no one: the one is a link that lights on a ground under the +// pointer, says `Resume @gravity · quantum gravity research · click` on the +// hint line, and opens the conversation when pressed; the other stays text. +func TestAHandleInAReplyIsADoorThatResumesItsMember(t *testing.T) { + a, gravityKey := linkChat(t, "Ask @gravity for the numbers, and @nobody else.") + r, y, ok := teamLinkedRow(a) + if !ok { + t.Fatalf("the reply grew no team link:\n%s", strings.Join(plainRows(a), "\n")) + } + if len(r.links) != 1 || r.links[0].member != gravityKey { + t.Fatalf("links %+v, want @gravity alone", r.links) + } + if got := plainCells(ansi.Strip(r.text), r.links[0].span.from, r.links[0].span.to); got != "@gravity" { + t.Fatalf("the link covers %q", got) + } + drive(t, a, motionTo(r.links[0].span.from+1, y)) + if got := a.hoveringLink(r.entry); got != r.links[0].ord || got < teamLinkOrd { + t.Fatalf("the hover recorded %d, want %d", got, r.links[0].ord) + } + if strings.Contains(r.text, "\x1b[48") { + t.Fatalf("a team link at rest wears a ground:\n%q", r.text) + } + again, _, _ := teamLinkedRow(a) + if !strings.Contains(again.text, "\x1b[48") { + t.Fatalf("a hovered team link took no ground:\n%q", again.text) + } + if hint := a.dockHoverWords(); hint != "Resume @gravity · quantum gravity research · click" { + t.Fatalf("the hint line says %q", hint) + } + opened := "" + a.open = func(workspace, transcript string) (Conversation, error) { + opened = transcript + return Conversation{Agent: titledAgent{&fakeAgent{model: "m"}, "quantum gravity research"}, SessionFile: transcript, Workspace: workspace}, nil + } + x := again.links[0].span.from + 1 + cmd := a.press(x, y) + spend(t, a, cmd) + if opened != "/tmp/lab/quantum-gravity.jsonl" || a.frontTabKey() != gravityKey { + t.Fatalf("the press did not resume @gravity: opened %q, front %q", opened, a.frontTabKey()) + } +} + +// A TOOL CALL AND A TEAM'S CARD CARRY THE SAME DOORS. +func TestTeamToolRowsAndCardsLinkTheirHandles(t *testing.T) { + a, gravityKey := linkChat(t, "") + a.entries = append(a.entries, + entry{kind: entryTool, tool: "team_send", text: "team_send @gravity: send the numbers", settled: true}, + entry{kind: entryTeam, text: "Team traffic in \"harbor\" for you (@gravity).\n◆ from manager to @gravity: send the numbers\n(rule)", settled: true}, + ) + a.touch() + rows := a.visible(a.bodyWidth()) + found := map[entryKind]bool{} + for _, r := range rows { + if r.entry < 0 { + continue + } + for _, l := range r.links { + if l.member == gravityKey { + found[a.entries[r.entry].kind] = true + } + } + } + if !found[entryTeam] { + t.Errorf("the team card's @gravity is not a link:\n%s", strings.Join(plainRows(a), "\n")) + } + if !found[entryTool] { + t.Errorf("the team_send row's @gravity is not a link:\n%s", strings.Join(plainRows(a), "\n")) + } +} + +// teamNameLink is the first on-screen link that names team id and no member, +// with its screen y. +func teamNameLink(a *app, id string) (taskLink, int, bool) { + body, _ := a.window(a.bodyWidth(), a.viewHeight()) + for i, r := range body { + for _, l := range r.links { + if l.team == id && l.member == "" { + return l, a.bodyTop() + i, true + } + } + } + return taskLink{}, 0, false +} + +// assertTeamPage is the landing a team-name press owes: the teams place, that +// team selected, the rail's cursor on its row, the conversation that was in +// front still in front. +func assertTeamPage(t *testing.T, a *app, id, front string) { + t.Helper() + if !a.at(pageTeams) || a.wall.on { + t.Fatalf("the press landed on page %q, wall %v", a.page.word(), a.wall.on) + } + if a.tp.sel != id { + t.Fatalf("the pane is on %q, want %q", a.tp.sel, id) + } + if a.frontTabKey() != front { + t.Fatalf("the press moved the front from %q to %q", front, a.frontTabKey()) + } + if !a.tp.focus || a.tp.cur != (teamsRef{act: teamsActSelect, id: id}) { + t.Fatalf("the rail cursor is focus %v %+v", a.tp.focus, a.tp.cur) + } + if hint := a.dockHoverWords(); strings.Contains(hint, "teams page") { + t.Fatalf("the chat link's hint outlived the press: %q", hint) + } + a.frame() + got, ok := a.teamsCursorTarget() + if !ok || got.pane || got.act != teamsActSelect || got.id != id { + t.Fatalf("the drawn cursor is %+v (ok %v)", got, ok) + } +} + +// A TEAM'S NAME IN A REPLY OPENS THE TEAMS PAGE ON IT. The rail's cursor lands +// on the team, the pane is that team, and the conversation in front stays. +func TestATeamNameInAReplyOpensTheTeamsPage(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.entries = append(a.entries, entry{kind: entryAssistant, text: "Ask the harbor team for the numbers.", settled: true}) + a.touch() + link, y, ok := teamNameLink(a, harbor) + if !ok { + t.Fatalf("the reply grew no team-name link:\n%s", strings.Join(plainRows(a), "\n")) + } + front := a.frontTabKey() + drive(t, a, motionTo(link.span.from+1, y)) + if hint := a.dockHoverWords(); hint != "Open harbor on the teams page · click" { + t.Fatalf("the hint line says %q", hint) + } + spend(t, a, a.press(link.span.from+1, y)) + assertTeamPage(t, a, harbor, front) +} + +// A SENT ●slug IS THE SAME DOOR. The @ chip a person inserted opens the teams +// page on that team, with the same hint. +func TestAMentionChipOpensTheTeamsPage(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.entries = append(a.entries, entry{kind: entryUser, text: "see ●harbor", settled: true}) + a.touch() + link, y, ok := teamNameLink(a, harbor) + if !ok { + t.Fatalf("the chip grew no team link:\n%s", strings.Join(plainRows(a), "\n")) + } + front := a.frontTabKey() + drive(t, a, motionTo(link.span.from+1, y)) + if hint := a.dockHoverWords(); hint != "Open harbor on the teams page · click" { + t.Fatalf("the chip's hint says %q", hint) + } + spend(t, a, a.press(link.span.from+1, y)) + assertTeamPage(t, a, harbor, front) +} + +// A TEAM TOOL'S ROW CARRIES THE SAME DOOR as a reply. +func TestATeamNameOnAToolRowOpensTheTeamsPage(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.entries = append(a.entries, entry{kind: entryTool, tool: "team_send", text: "team_send the harbor team the numbers", settled: true}) + a.touch() + link, y, ok := teamNameLink(a, harbor) + if !ok { + t.Fatalf("the tool row grew no team-name link:\n%s", strings.Join(plainRows(a), "\n")) + } + front := a.frontTabKey() + spend(t, a, a.press(link.span.from+1, y)) + assertTeamPage(t, a, harbor, front) +} + +// A CLOSED TEAM IS SELECTED INSIDE CLOSED, and the fold is opened so the row +// is on the rail. +func TestAClosedTeamLinkSelectsItInsideClosed(t *testing.T) { + a, _, _, _ := trafficApp(t) + var behind []chatTab + for _, tab := range a.tabList() { + if tab.key != a.frontTabKey() { + behind = append(behind, tab) + break + } + } + orbit, err := a.teamMake("orbit", behind) + if err != nil { + t.Fatal(err) + } + if err := a.teamEdit(func(f *teamstore.File) error { return f.Close(orbit, a.now(), "") }); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + if got, _ := a.teamByID(orbit); !got.Closed() { + t.Fatal("orbit did not close") + } + a.width, a.height = 160, 40 + a.entries = append(a.entries, entry{kind: entryAssistant, text: "The orbit team is put away.", settled: true}) + a.touch() + link, y, ok := teamNameLink(a, orbit) + if !ok { + t.Fatalf("the closed team's name is not a link:\n%s", strings.Join(plainRows(a), "\n")) + } + front := a.frontTabKey() + spend(t, a, a.press(link.span.from+1, y)) + assertTeamPage(t, a, orbit, front) + if !a.tp.closedOpen { + t.Fatal("the Closed fold stayed shut") + } + if text := teamsFrameText(a); !strings.Contains(text, "Closed") || !strings.Contains(text, "orbit") || !strings.Contains(text, "closed without a report") { + t.Fatalf("the closed team is not in the pane:\n%s", text) + } +} + +// OVER --host WITH NO TEAMS DOORS the press keeps the conversations view, and +// the hint says that rather than the teams page. +func TestATeamLinkOverHostFallsBackToTheWall(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.host = "devbox" + if !a.teamsOff() { + t.Fatal("a hosted window with no seam still has teams") + } + a.width, a.height = 160, 40 + a.entries = append(a.entries, entry{kind: entryAssistant, text: "Ask the harbor team.", settled: true}) + a.touch() + link, y, ok := teamNameLink(a, harbor) + if !ok { + t.Fatalf("the reply grew no team-name link:\n%s", strings.Join(plainRows(a), "\n")) + } + drive(t, a, motionTo(link.span.from+1, y)) + want := "Show harbor on the conversations view · " + wallMembersWord(len(mustTeam(t, a, harbor).Members)) + " · click" + if hint := a.dockHoverWords(); hint != want { + t.Fatalf("the fallback hint says %q, want %q", hint, want) + } + front := a.frontTabKey() + spend(t, a, a.press(link.span.from+1, y)) + if a.at(pageTeams) || !a.wall.on || a.wall.activeID != harbor { + t.Fatalf("the fallback landed on page %q wall %v team %q", a.page.word(), a.wall.on, a.wall.activeID) + } + if a.frontTabKey() != front { + t.Fatalf("the wall moved the front from %q to %q", front, a.frontTabKey()) + } +} diff --git a/internal/tui3/teamcrew.go b/internal/tui3/teamcrew.go new file mode 100644 index 0000000000..ec485f80f6 --- /dev/null +++ b/internal/tui3/teamcrew.go @@ -0,0 +1,753 @@ +package tui3 + +import ( + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── A TEAM'S MEMBERS: ACTIVE ONES ON THE HEADER, EVERYONE ON A CARD ───────── +// +// The pane's header is one line (owner feedback 2026-09-24, which replaced two +// wrapped rows of every member as prose): +// +// ● harbor ◆ Manager @news ⠿ working @review ? asking +4 idle $0.42 today Settings Close… Open ▦ +// +// ONLY A MEMBER WITH SOMETHING HAPPENING IS A CHIP: working, asking (in the +// needs-you amber) or failed, each a door to its conversation with its title in +// the hint. Everyone else is one quiet word, `+4 idle`, or `6 members` when +// nobody is doing anything: the emptiness law, which says an idle thing draws +// nothing, applied to people. Whether a conversation is open in this window is +// a fact about the window, not the team, so the page never says `not open`; +// the members card's `Open` or `Resume` carries it. +// +// NARROW, THE LINE GIVES UP ITS PARTS IN ORDER OF WHAT IT CAN LIVE WITHOUT: the +// idle word first (the card is still `p`), then the spend, then the chips from +// the last, then the manager's chip, then the action buttons from the right. +// The team's name is never dropped. +// +// THE MEMBERS CARD (`+4 idle`, `6 members`, or `p`) is every member, one row +// each: handle, title, state, when it last moved, `also in test` for a +// conversation that reports to another team's manager, and `Open` or `Resume`. +// Its rows are also where a member is dragged from to ADD it to another team +// on the rail (teamdrag.go), so the card hangs over the pane and never over the +// rail it drops onto. + +// teamCrewLetter is the page's letter for the members card. +const teamCrewLetter = "p" + +// teamsCrewRow is one member as the header and the card draw it. +type teamsCrewRow struct { + key, handle, title string + // word is the state in one word: working, asking, failed or idle. + word string + asking bool + manager bool + held bool + at time.Time + // also is the team whose manager a shared member reports to, "" for this + // team's own. + also string + file string +} + +// active reports whether the member has something happening, which is what +// earns it a chip on the header. +func (r teamsCrewRow) active() bool { return r.word != "idle" } + +// name is the member as the page spells it: `@handle`, else its title. +func (r teamsCrewRow) name() string { + if r.handle != "" { + return "@" + r.handle + } + if r.title != "" { + return r.title + } + return "member" +} + +// teamsCrewMembers is who the header and the card list for team t: its members, +// or, on the root with a manager, the managers of the top-level teams, which +// are the global manager's members (DESIGN.md 8.10), never their chats. +func (a *app) teamsCrewMembers(t team) []teamMember { + if t.Root && t.Manager != "" { + tops := a.teamTree().TopManagers() + out := make([]teamMember, 0, len(tops)+1) + if m, ok := t.Member(t.Manager); ok { + out = append(out, m) + } + return append(out, tops...) + } + return t.Members +} + +// teamsCrew is every member of team t, the manager first. Memory only. +func (a *app) teamsCrew(t team) []teamsCrewRow { + tree := a.teamTree() + members := a.teamsCrewMembers(t) + out := make([]teamsCrewRow, 0, len(members)) + for pass := 0; pass < 2; pass++ { + for _, m := range members { + if (m.Key == t.Manager) != (pass == 0) { + continue + } + st := a.teamsMember(m) + r := teamsCrewRow{key: m.Key, handle: m.Handle, title: strings.TrimSpace(m.Word), word: "idle", + manager: m.Key == t.Manager, held: a.trafficHeld(m.Key), at: st.at, file: m.File} + switch { + case st.asking: + r.word, r.asking = "asking", true + case st.word == "running": + r.word = "working" + case a.teamsFailed(t, m): + r.word = "failed" + } + if home, ok := tree.Home(m.Key); ok && home.Team != t.ID && home.Via != t.ID && !r.manager { + r.also = a.teamNameOf(home.Team) + } + if r.title == "" && r.handle == "" { + continue + } + out = append(out, r) + } + } + return out +} + +// teamsFailed reports whether member m's newest event in team t's Traffic says +// its last turn failed. It reads the Traffic this window already holds and +// allocates nothing. +func (a *app) teamsFailed(t team, m teamMember) bool { + rows := a.traffic.rows[t.ID] + for i := len(rows) - 1; i >= 0; i-- { + e := rows[i] + if e.Kind != teamstore.KindEvent || (e.Member != m.Key && (m.Handle == "" || e.From != m.Handle)) { + continue + } + return e.State == teamstore.StateFailed + } + return false +} + +// teamsCrewMark is a state's mark: `⠿` working, `?` asking, `✗` failed. +func (a *app) teamsCrewMark(word string) string { + switch word { + case "working": + return a.linearMark("⠿", "*") + case "asking": + return "?" + case "failed": + return a.linearMark(a.icon(tokens.GFailed), "x") + } + return "" +} + +// teamsCrewInk is the ink a state is drawn in: asking in the needs-you amber, +// failed in the failure red, working muted, idle dim. +func (a *app) teamsCrewInk(word string) func(string) string { + switch word { + case "asking": + return a.pal.ask + case "failed": + return a.pal.bad + case "working": + return a.pal.muted + } + return a.pal.dim +} + +// teamsCrewHint is what the hint line says over a member: who it is, what it +// is doing, and what a press does. +// +// @news · weekly news digest · working 3m · click opens +func (a *app) teamsCrewHint(r teamsCrewRow) string { + words := r.name() + if r.title != "" && r.handle != "" { + words += hintSegment + r.title + } + state := r.word + if age := sinceAt(r.at, a.now()); age != "" && r.word != "working" { + state += " " + age + } + words += hintSegment + state + if r.also != "" { + words += hintSegment + "reports to " + r.also + "'s manager" + } + if r.held { + return words + hintSegment + "click opens" + } + return words + hintSegment + "click resumes it behind, in its own tab" +} + +// ── THE HEADER ────────────────────────────────────────────────────────────── + +// teamsHeadPiece is one optional piece of the header line, in the order the +// line drops them when it is narrow. +type teamsHeadPiece struct { + s string + w int + t teamsTarget + btn bool + drop int +} + +// teamsHeader is the header row: the team's name, its manager, the members +// with something happening, the idle word, the spend, and the three buttons. +// +// ● harbor ◆ Manager @news ⠿ working +4 idle $0.42 today Settings Close… Open ▦ +func (a *app) teamsHeader(d *teamsDraw, t team, width, y int) string { + pal := a.pal + name := t.Name + if t.Root { + name = teamstore.RootName + } + left := " " + a.tabTeamDot(t) + " " + pal.bold(pal.ink(name)) + type btn struct { + word string + t teamsTarget + } + var bs []btn + if t.Closed() { + bs = append(bs, + btn{"Reopen", teamsTarget{act: teamsActReopen, id: t.ID, hint: "Reopen " + t.Name + ": its tabs come back and its manager resumes" + hintSegment + "r"}}, + btn{"Delete" + a.linearMark("…", "..."), teamsTarget{act: teamsActDelete, id: t.ID, hint: "Forget this team, its Traffic and its packets; the conversations stay" + hintSegment + "d"}}) + if p, ok := a.teamsParentClosed(t); ok { + bs = append([]btn{{"Reopen " + p.Name + " too", teamsTarget{act: teamsActReopenParent, id: t.ID, + hint: t.Name + " sits under " + p.Name + ", which is closed" + hintSegment + "r"}}}, bs[1:]...) + } + } else { + bs = append(bs, + btn{"Settings", teamsTarget{act: teamsActSettings, id: t.ID, hint: "What this team overrides, and what it inherits" + hintSegment + "s"}}) + if !t.Root { + bs = append(bs, btn{"Close" + a.linearMark("…", "..."), teamsTarget{act: teamsActClose, id: t.ID, hint: "Close " + t.Name + ": wrap up first, or now" + hintSegment + "c"}}) + } + bs = append(bs, btn{"Open " + a.linearMark("▦", "#"), teamsTarget{act: teamsActWall, id: t.ID, hint: "The wall, showing " + name + "'s open conversations" + hintSegment + "w"}}) + } + // THE OPTIONAL PIECES, each with the rank at which a narrow line drops it: + // the higher the rank, the sooner it goes. + var pieces []teamsHeadPiece + const ( + dropIdle = 1000 + dropSpend = 900 + dropChip = 800 // minus the chip's place, so the last chip goes first + dropBoss = 100 + ) + if !t.Closed() { + crew := a.teamsCrew(t) + if t.Manager != "" { + word := a.teamManagerMark() + " Manager" + hint := "Talk to " + name + "'s manager" + for _, r := range crew { + if r.manager && r.active() { + word += " " + a.teamsCrewMark(r.word) + hint += hintSegment + r.word + } + } + if a.teamsHosting() { + hint += hintSegment + "it is the conversation below" + } else { + hint += hintSegment + "click brings it in front" + } + pieces = append(pieces, teamsHeadPiece{s: word, w: ansi.StringWidth(word), + t: teamsTarget{act: teamsActManagerGo, id: t.ID, hint: hint}, btn: true, drop: dropBoss}) + } + idle, total := 0, 0 + for _, r := range crew { + if r.manager { + continue + } + total++ + if !r.active() { + idle++ + continue + } + mark := a.teamsCrewMark(r.word) + plain := r.name() + " " + mark + " " + r.word + ink := a.teamsCrewInk(r.word) + s := pal.ink(r.name()) + " " + ink(mark+" "+r.word) + pieces = append(pieces, teamsHeadPiece{s: s, w: ansi.StringWidth(plain), + t: teamsTarget{act: teamsActMember, id: t.ID, arg: r.key, hint: a.teamsCrewHint(r)}, drop: dropChip - len(pieces)}) + } + if total > 0 { + word := "+" + itoa(idle) + " idle" + if idle == total { + word = itoa(total) + " members" + if total == 1 { + word = "1 member" + } + } + if idle > 0 { + pieces = append(pieces, teamsHeadPiece{s: word, w: ansi.StringWidth(word), + t: teamsTarget{act: teamsActCrew, id: t.ID, hint: "Every member of " + name + ": open one, resume one, or drag one onto another team to add it" + hintSegment + teamCrewLetter}, btn: true, drop: dropIdle}) + } + } + } + spend := a.teamsSpendWords(t) + if t.Closed() { + spend = a.teamsClosedWords(t) + } + if spend != "" { + pieces = append(pieces, teamsHeadPiece{s: pal.dim(spend), w: ansi.StringWidth(spend), drop: dropSpend}) + } + // WHAT FITS. The name and the buttons are the floor; the pieces are added + // back from the one a narrow line keeps longest. + bw := 0 + for _, b := range bs { + bw += ansi.StringWidth(b.word) + 2 + } + leftW := ansi.StringWidth(left) + room := width - 1 - leftW - bw + for room < 0 && len(bs) > 0 { + // Too narrow for the buttons: they go from the right, the name never. + last := bs[len(bs)-1] + bs = bs[:len(bs)-1] + bw -= ansi.StringWidth(last.word) + 2 + room = width - 1 - leftW - bw + } + keep := make([]bool, len(pieces)) + used := 0 + for { + best := -1 + for i, p := range pieces { + if !keep[i] && (best < 0 || p.drop < pieces[best].drop) { + best = i + } + } + if best < 0 { + break + } + w := pieces[best].w + 3 + if pieces[best].btn { + w++ + } + if used+w > room { + break + } + keep[best] = true + used += w + } + head := left + x := leftW + for i, p := range pieces { + if !keep[i] { + continue + } + if p.btn { + // A button's own cell of air is the third cell of the gap. + head += " " + x += 2 + tg := p.t + tg.x0, tg.y = x, y + s, w := d.button(p.s, tg, pal.muted) + head += s + x += w + continue + } + head += " " + x += 3 + if p.t.act != teamsActNone { + tg := p.t + tg.x0, tg.x1, tg.y = x, x+p.w, y + d.targets = append(d.targets, tg) + s := p.s + hot, cur := d.lit(tg.ref()) + switch { + case cur: + s = pal.selected(s, 0) + case hot: + s = pal.cursor(s, 0) + } + head += s + } else { + head += p.s + } + x += p.w + } + head = teamsPad(head, max(width-bw, 0)) + x = max(width-bw, 0) + for _, b := range bs { + b.t.x0, b.t.y = x, y + s, w := d.button(b.word, b.t, pal.ink) + head += s + x += w + } + return head +} + +// teamsManagerGo is the header's `◆ Manager`: the manager's conversation in +// front, which on this page is the pane. +func (a *app) teamsManagerGo(id string) tea.Cmd { + t, ok := a.teamByID(id) + if !ok || t.Manager == "" { + return nil + } + if t.Manager == a.frontTabKey() { + // It is in front already: the keyboard goes to its box. + a.tp.focus = false + a.tp.top = teamsTopCache{} + a.touch() + return nil + } + a.tp.sel = id + return a.teamsBringManager() +} + +// ── THE MEMBERS CARD ──────────────────────────────────────────────────────── + +// teamCrew is the members card's state. +type teamCrew struct { + on bool + team string + // cursor is the row the keyboard is on; hot the row under the pointer and + // hotButton whether it is on that row's Open or Resume (-1 none). + cursor, hot int + hotButton bool + hotClose bool + top int + rect wallRect + hits []wallHit +} + +// The card's targets, as its hits carry them in arg. +const ( + crewHitRow = iota + crewHitButton + crewHitClose + crewHitTag +) + +// teamCrewOpen puts the card up for team id. +func (a *app) teamCrewOpen(id string) tea.Cmd { + if _, ok := a.teamByID(id); !ok { + return nil + } + a.tcrew = teamCrew{on: true, team: id, hot: -1} + a.touch() + return nil +} + +// teamCrewShut puts the card away. +func (a *app) teamCrewShut() { + a.tcrew = teamCrew{} + a.touch() +} + +// teamCrewRows is the card's members, the manager first. +func (a *app) teamCrewRows() []teamsCrewRow { + t, ok := a.teamByID(a.tcrew.team) + if !ok { + return nil + } + return a.teamsCrew(t) +} + +// teamCrewKey is a key while the card is up: it has the keyboard. +func (a *app) teamCrewKey(msg tea.KeyPressMsg) tea.Cmd { + rows := a.teamCrewRows() + c := &a.tcrew + a.touch() + switch msg.String() { + case "esc", teamCrewLetter: + a.teamCrewShut() + case "up", "k": + c.cursor = max(c.cursor-1, 0) + case "down", "j": + c.cursor = min(c.cursor+1, max(len(rows)-1, 0)) + case "enter", "space": + if c.cursor >= 0 && c.cursor < len(rows) { + return a.teamCrewGo(rows[c.cursor]) + } + } + return nil +} + +// teamCrewGo is `Open` or `Resume` on a member: one this window holds is +// opened and the card goes; one it does not is resumed behind and the card +// stays, so the person sees it change to `Open`. +func (a *app) teamCrewGo(r teamsCrewRow) tea.Cmd { + id := a.tcrew.team + if r.held { + a.teamCrewShut() + } + return a.teamsMemberGo(id, r.key) +} + +// teamCrewHitAt is the card's target under the pointer. +func (a *app) teamCrewHitAt(x, y int) (wallHit, bool) { + for _, hit := range a.tcrew.hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit, true + } + } + return wallHit{}, false +} + +// teamCrewMouse is a pointer event while the card is up. A press on a row puts +// the cursor there and holds it for a drag; a press on `Open` or `Resume` does +// it; `Close` and a press off the card put it away. It reports whether the +// card took the event. +func (a *app) teamCrewMouse(msg tea.Msg, m tea.Mouse) (tea.Cmd, bool) { + c := &a.tcrew + hit, on := a.teamCrewHitAt(m.X, m.Y) + switch msg.(type) { + case tea.MouseClickMsg: + if m.Button != tea.MouseLeft { + return nil, true + } + if !on { + if !c.rect.holds(m.X, m.Y) { + a.teamCrewShut() + } + return nil, true + } + rows := a.teamCrewRows() + switch hit.kind { + case crewHitClose: + a.teamCrewShut() + return nil, true + case crewHitButton: + if hit.arg >= 0 && hit.arg < len(rows) { + c.cursor = hit.arg + return a.teamCrewGo(rows[hit.arg]), true + } + default: + if hit.arg >= 0 && hit.arg < len(rows) { + c.cursor = hit.arg + a.teamDragPress(m.X, m.Y, true, c.team, rows[hit.arg].key, teamsTarget{}, false) + a.touch() + } + } + return nil, true + case tea.MouseMotionMsg: + if a.tdrag.press { + a.teamDragMotion(m.X, m.Y, m.Button == tea.MouseLeft) + return nil, true + } + hot, button, closing := -1, false, false + if on { + switch hit.kind { + case crewHitClose: + closing = true + default: + hot, button = hit.arg, hit.kind == crewHitButton + } + } + if hot != c.hot || button != c.hotButton || closing != c.hotClose { + c.hot, c.hotButton, c.hotClose = hot, button, closing + a.touch() + } + return nil, c.rect.holds(m.X, m.Y) + case tea.MouseReleaseMsg: + if cmd, took := a.teamDragRelease(); took { + return cmd, true + } + return nil, c.rect.holds(m.X, m.Y) + } + return nil, c.rect.holds(m.X, m.Y) +} + +// teamCrewHint is what the hint line says with the card up. +func (a *app) teamCrewHint() string { + c := a.tcrew + rows := a.teamCrewRows() + if c.hotClose { + return "Close the members" + hintSegment + "esc" + } + at := c.cursor + if c.hot >= 0 { + at = c.hot + } + if at < 0 || at >= len(rows) { + return "↑↓ walk" + hintSegment + "enter open" + hintSegment + "esc close" + } + r := rows[at] + if c.hot >= 0 && c.hotButton { + if r.held { + return "Open " + r.name() + hintSegment + "enter" + } + return "Resume " + r.name() + " behind, in its own tab; you stay here" + hintSegment + "enter" + } + words := r.name() + if r.title != "" && r.handle != "" { + words += hintSegment + r.title + } + if r.also != "" { + words += hintSegment + "reports to " + r.also + "'s manager" + } + return words + hintSegment + "drag onto a team on the left to add it there" + hintSegment + "enter opens" +} + +// teamCrewOver lays the card over a finished frame, over the pane and clear of +// the rail, under the header. +func (a *app) teamCrewOver(frame string) string { + if !a.tcrew.on || !a.at(pageTeams) { + return frame + } + width, height := a.width, a.height + x := 1 + if a.tp.railW > 0 { + x = a.tp.railW + 1 + } + y := placeHeadRows + for _, t := range a.tp.targets { + if t.act == teamsActSettings || t.act == teamsActCrew { + y = t.y + 1 + break + } + } + card := a.teamCrewCard(x, y, width-x-1, height-y) + a.tcrew.hits = card.hits + if len(card.rows) == 0 { + a.tcrew.rect = wallRect{} + return frame + } + a.tcrew.rect = wallRect{card.x, card.y, card.x + card.w, card.y + len(card.rows)} + rows := strings.Split(frame, "\n") + for len(rows) < height { + rows = append(rows, "") + } + for dy, cr := range card.rows { + if yy := card.y + dy; yy >= 0 && yy < len(rows) { + rows[yy] = wallSplice(rows[yy], cr, card.x, width) + } + } + return strings.Join(rows[:height], "\n") +} + +// teamCrewCard is the card at x, y, at most w wide and h tall. +// +// ╭─ harbor · 6 members ──────────────────────────────────────────────╮ +// │ ◆ @boss harbor's manager working Open │ +// │ @review code review asking also in test Resume │ +// │ Close esc │ +// ╰───────────────────────────────────────────────────────────────────╯ +func (a *app) teamCrewCard(x, y, w, h int) wallCard { + pal := a.pal + t, ok := a.teamByID(a.tcrew.team) + if !ok { + return wallCard{} + } + rows := a.teamCrewRows() + w = min(w, 88) + if w < 36 || h < 6 { + return wallCard{} + } + const padX = 1 + inner := w - 2 - 2*padX + room := max(h-4, 1) + c := &a.tcrew + c.cursor = min(max(c.cursor, 0), max(len(rows)-1, 0)) + top := min(c.top, max(len(rows)-room, 0)) + if c.cursor < top { + top = c.cursor + } + if c.cursor >= top+room { + top = c.cursor - room + 1 + } + c.top = top + // The columns: handle, state and age, the tag and the button are sized; + // the title takes what is left. + const nameW, stateW, ageW, buttonW = 13, 10, 5, 8 + tagW := 0 + for _, r := range rows { + if r.also != "" { + tagW = max(tagW, ansi.StringWidth("also in "+r.also)+2) + } + } + tagW = min(tagW, 20) + titleW := inner - nameW - stateW - ageW - tagW - buttonW + if titleW < 8 { + titleW, tagW = max(inner-nameW-stateW-ageW-buttonW, 0), 0 + } + var lines []wallCardLine + if len(rows) == 0 { + lines = append(lines, wallCardLine{s: pal.dim("no members yet")}) + } + now := a.now() + for i, r := range rows[top:min(top+room, len(rows))] { + at := top + i + name := r.name() + if r.manager { + name = a.teamManagerMark() + " " + name + } + title := r.title + if r.manager && title == "" { + title = t.Name + "'s manager" + } + age := "" + if r.word != "working" { + age = sinceAt(r.at, now) + } + ink := a.teamsCrewInk(r.word) + text := pal.ink(teamsPad(fitConversationTitle(name, nameW-1), nameW)) + + pal.muted(teamsPad(fitConversationTitle(title, max(titleW-2, 1)), titleW)) + + ink(teamsPad(r.word, stateW)) + pal.dim(teamsPad(age, ageW)) + hits := []wallHit{{x0: 0, x1: inner - buttonW, y1: 1, kind: crewHitRow, arg: at}} + if tagW > 0 { + tag := "" + if r.also != "" { + tag = "also in " + r.also + hits = append(hits, wallHit{x0: inner - buttonW - tagW, x1: inner - buttonW - 2, y1: 1, kind: crewHitTag, arg: at}) + } + text += pal.dim(teamsPad(fit(tag, tagW-2), tagW)) + } + word := "Resume" + if r.held { + word = "Open" + } + chip := " " + word + " " + lit := c.hot == at && c.hotButton + switch { + case lit: + chip = pal.cursor(pal.ink(chip), 0) + default: + chip = pal.ink(chip) + } + text = teamsPad(text, inner-buttonW) + chip + hits = append(hits, wallHit{x0: inner - buttonW, x1: inner - buttonW + ansi.StringWidth(" "+word+" "), y1: 1, kind: crewHitButton, arg: at}) + if at == c.cursor || (c.hot == at && !c.hotButton) { + text = pal.cursor(teamsPad(text, inner), inner) + } + // A dragged row is dim until it drops, so the person sees what moves. + if a.tdrag.on && a.tdrag.member && a.tdrag.key == r.key { + text = pal.dim(ansi.Strip(teamsPad(text, inner))) + } + lines = append(lines, wallCardLine{s: text, hits: hits}) + } + closeWord := " Close " + pal.dim("esc") + " " + cw := ansi.StringWidth(" Close esc ") + cs := closeWord + if c.hotClose { + cs = pal.cursor(" Close esc ", 0) + } + lines = append(lines, wallCardLine{s: strings.Repeat(" ", max(inner-cw, 0)) + cs, + hits: []wallHit{{x0: inner - cw, x1: inner, y1: 1, kind: crewHitClose, arg: -1}}}) + // THE COUNT IS THE HEADER'S COUNT: the members beside the manager, with + // the manager named apart, so the header's `◆ Manager 1 member` and this + // title never disagree about the same team. + members, managed := 0, false + for _, r := range rows { + if r.manager { + managed = true + continue + } + members++ + } + count := itoa(members) + " members" + if members == 1 { + count = "1 member" + } + if managed { + count = a.teamManagerMark() + " Manager " + a.teamsDot() + " " + count + } + title := t.Name + " " + a.teamsDot() + " " + count + if t.Root { + title = teamstore.RootName + " " + a.teamsDot() + " the top teams' managers" + } + return wallCardBuild(pal, title, lines, x, y, w, padX, 0) +} diff --git a/internal/tui3/teamdrag.go b/internal/tui3/teamdrag.go new file mode 100644 index 0000000000..6023143bae --- /dev/null +++ b/internal/tui3/teamdrag.go @@ -0,0 +1,296 @@ +package tui3 + +import ( + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── DRAG AND DROP IN THE TEAMS RAIL: THE SHORTCUT (rulings c-12, c-13) ────── +// +// `Move into…` is the main road; a drag is the shortcut for a person whose +// hand is already on the pointer. Two things can be dragged: +// +// - A TEAM ROW of the rail, onto another team row (`Drop to move api into +// harbor`) or onto the empty rail under the tree, which is the top level. +// Teams picked with `space` travel together when the one dragged is among +// them. The move then goes exactly the way the picker's does +// ([app.teamMoveAsk]): at once with Undo, or after the one consequence line. +// - A MEMBER, from the members card, onto a team row. That ADDS the +// conversation to the team (`Add @security to harbor`) and never takes it +// out of the one it was dragged from: removing a conversation from a team is +// always its own explicit act, so a drag cannot lose one. +// +// A DRAG STARTS ONLY AFTER TWO CELLS OF HELD MOVEMENT. A press that lets go +// where it landed, or a cell away, is a click and does what a click does (a +// team row selects its team, a member opens), because a hand on a mouse is +// never still and a one-cell wobble must not turn a click into a move. +// +// ONLY A TARGET THAT CAN TAKE THE DROP IS GROUNDED. Every other row under the +// pointer stays as it is and the hint line says why it will not take it, in +// the picker's own words. `esc` drops the drag and nothing happens. +// +// Like everything on the page it is memory: the rows and their targets are the +// last frame's ([teamsTarget]), and the write is an ordinary edit. + +// teamDragCells is how far a held press must move before it is a drag. +const teamDragCells = 2 + +// teamDrag is one press on something that can be dragged, and the drag it +// became. +type teamDrag struct { + // press says a press is held on a draggable thing; on says it moved far + // enough to be a drag. + press, on bool + // member says a member is dragged (key, from team id) rather than team id. + member bool + id string + key string + // x0 and y0 are where the press landed. + x0, y0 int + // over is what a release here would drop on: a team id, [teamMoveTop], or + // "" for nothing; ok says it takes the drop and why says why it does not. + over string + ok bool + why string + // click is what the press does when it lets go without a drag, for a + // target whose press waits for the release. + click teamsTarget + clicked bool +} + +// teamDragPress holds a press on team row id, or on member key of team from. +func (a *app) teamDragPress(x, y int, member bool, id, key string, click teamsTarget, deferred bool) { + a.tdrag = teamDrag{press: true, member: member, id: id, key: key, x0: x, y0: y, click: click, clicked: deferred} +} + +// teamDragging reports whether a drag is under way. +func (a *app) teamDragging() bool { return a.tdrag.on } + +// teamDragIDs is the teams a team drag moves: every team picked with `space` +// when the dragged one is among them, else the dragged one alone. +func (a *app) teamDragIDs() []string { + if a.tp.picked[a.tdrag.id] { + return a.teamsPickedIDs() + } + return []string{a.tdrag.id} +} + +// teamDragMotion is the pointer moving while a press is held. It reports +// whether the drag took the motion. +func (a *app) teamDragMotion(x, y int, held bool) bool { + d := &a.tdrag + if !d.press { + return false + } + if !held { + // The release was never heard (a terminal that drops it): the press is + // over, and nothing is dropped. + *d = teamDrag{} + a.touch() + return false + } + if !d.on { + if abs(x-d.x0) < teamDragCells && abs(y-d.y0) < teamDragCells { + return true + } + d.on = true + a.tp.hot = teamsRef{} + } + over, ok, why := a.teamDropAt(x, y) + if over != d.over || ok != d.ok || why != d.why { + d.over, d.ok, d.why = over, ok, why + a.tp.top = teamsTopCache{} + a.touch() + } + return true +} + +// teamDropAt is what a release at x, y would drop on: a team row, the All +// teams row or the empty rail under the tree (the top level), each with +// whether it takes this drag and why not. +func (a *app) teamDropAt(x, y int) (string, bool, string) { + d := a.tdrag + lastTree := -1 + for _, t := range a.tp.targets { + if t.pane || t.act != teamsActSelect { + continue + } + if tt, ok := a.teamByID(t.id); ok && tt.Closed() { + continue + } + lastTree = max(lastTree, t.y) + } + for _, t := range a.tp.targets { + if t.pane || y != t.y || x < t.x0 || x >= t.x1 { + continue + } + switch { + case t.act == teamsActSelect && t.id != teamsAllRow: + tt, ok := a.teamByID(t.id) + if !ok { + return "", false, "" + } + if tt.Root { + return a.teamDropJudge(teamMoveTop) + } + return a.teamDropJudge(tt.ID) + case t.act == teamsActSelect || t.act == teamsActRootManager: + return a.teamDropJudge(teamMoveTop) + } + } + // THE EMPTY RAIL UNDER THE TREE IS THE TOP LEVEL, for a team; a member has + // no top level to go to. + if !d.member && a.tp.railW > 0 && x < a.tp.railW-1 && lastTree >= 0 && y > lastTree { + return a.teamDropJudge(teamMoveTop) + } + return "", false, "" +} + +// teamDropJudge is whether the drag can drop on target, and why not. +func (a *app) teamDropJudge(target string) (string, bool, string) { + d := a.tdrag + if !d.member { + ok, why := a.teamMoveCheck(a.teamDragIDs(), target) + return target, ok, why + } + name := a.teamDragMemberName() + if target == teamMoveTop { + return target, false, "drop " + name + " on a team to add it" + } + t, ok := a.teamByID(target) + switch { + case !ok: + return "", false, "" + case t.Closed(): + return target, false, t.Name + " is closed" + case t.Holds(d.key): + return target, false, name + " is in " + t.Name + " already" + } + return target, true, "" +} + +// teamDragMember is the member being dragged, as its team keeps it. +func (a *app) teamDragMember() (teamMember, bool) { + if t, ok := a.teamByID(a.tdrag.id); ok { + return t.Member(a.tdrag.key) + } + return teamMember{}, false +} + +// teamDragMemberName is the dragged member as a sentence says it: `@handle`, +// else its title. +func (a *app) teamDragMemberName() string { + m, ok := a.teamDragMember() + switch { + case !ok: + return "the conversation" + case m.Handle != "": + return "@" + m.Handle + case m.Word != "": + return m.Word + } + return "the conversation" +} + +// teamDragRelease is the press let go: a drag drops, a press that never moved +// far enough does what its click does. +func (a *app) teamDragRelease() (tea.Cmd, bool) { + d := a.tdrag + if !d.press { + return nil, false + } + a.tdrag = teamDrag{} + a.tp.top = teamsTopCache{} + a.touch() + if !d.on { + if d.clicked { + return a.teamsDo(d.click), true + } + return nil, true + } + if d.over == "" || !d.ok { + if d.why != "" { + a.tp.msg = d.why + } + return nil, true + } + if d.member { + return a.teamDropMember(d), true + } + ids := []string{d.id} + if a.tp.picked[d.id] { + ids = a.teamsPickedIDs() + a.tp.picked = nil + } + return a.teamMoveAsk(ids, d.over, teamMoveFromPage), true +} + +// teamDropMember adds the dragged member to the team it was dropped on, with +// what its own team kept of it, which is enough to open it again there. +func (a *app) teamDropMember(d teamDrag) tea.Cmd { + src, ok := a.teamByID(d.id) + if !ok { + return nil + } + m, ok := src.Member(d.key) + if !ok { + return nil + } + target, _ := a.teamByID(d.over) + add := teamstore.Member{Key: m.Key, File: m.File, Where: m.Where, Word: m.Word} + name := a.teamDragMemberName() + if err := a.teamEdit(func(f *teamstore.File) error { return f.AddMember(d.over, add) }); err != nil { + a.tp.msg = name + " was not added: " + err.Error() + } else { + a.tp.msg = name + " is in " + target.Name + " too" + } + a.touch() + return nil +} + +// teamDragCancel drops the drag, and nothing happens. +func (a *app) teamDragCancel() { + a.tdrag = teamDrag{} + a.tp.top = teamsTopCache{} + a.touch() +} + +// teamDragHint is what the hint line says while a drag is under way, "" with +// none. +// +// Drop to move api into harbor · esc cancel +func (a *app) teamDragHint() string { + d := a.tdrag + if !d.on { + return "" + } + tail := hintSegment + "esc cancel" + switch { + case d.over == "": + if d.member { + return "Drag " + a.teamDragMemberName() + " onto a team to add it" + tail + } + return "Drag onto a team, or below the teams for the top level" + tail + case !d.ok: + return d.why + tail + case d.member: + return "Add " + a.teamDragMemberName() + " to " + a.teamNameOf(d.over) + tail + } + return "Drop to " + lowerFirst(a.teamMoveDoing(a.teamDragIDs(), d.over)) + tail +} + +// lowerFirst is s with its first letter lowered: `Move api` inside a sentence. +func lowerFirst(s string) string { + if s == "" { + return s + } + return string(s[0]|0x20) + s[1:] +} + +// teamDropLit reports whether team id's rail row is the drop the pointer is +// over and takes it, which is the only row grounded during a drag. +func (a *app) teamDropLit(id string) bool { + d := a.tdrag + return d.on && d.ok && d.over == id +} diff --git a/internal/tui3/teamedit_test.go b/internal/tui3/teamedit_test.go new file mode 100644 index 0000000000..4ea1f69333 --- /dev/null +++ b/internal/tui3/teamedit_test.go @@ -0,0 +1,154 @@ +package tui3 + +import ( + "errors" + "strings" + "testing" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// AN EDIT HERE IS A READ-MODIFY-WRITE, NOT A SAVE OF WHAT THIS WINDOW LOADED. +// The team tools a model calls write the same file from another process: a +// handle set there, a member added there, a manager made there. The interface +// then renames the team and adds a conversation, from a list it loaded before +// any of that, and every one of those writes is still on disk afterwards, and +// in the window's own memory too. +func TestTeamEditKeepsWhatAnotherProcessWrote(t *testing.T) { + dir := t.TempDir() + a := newTestAppWithProfile(dir, nil) + id, err := a.teamMake("harbor", []chatTab{ + {key: "k1", file: "f1", where: "/w", word: "parser work"}, + {key: "k2", file: "f2", where: "/w", word: "web front"}, + }) + if err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + + // Another process, through the store's own door. + if err := teamstore.Update(dir, func(f *teamstore.File) error { + if err := f.AddMember(id, teamstore.Member{Key: "k3", File: "f3", Word: "docs pass"}); err != nil { + return err + } + if err := f.SetHandle(id, "k1", "pp"); err != nil { + return err + } + return f.SetManager(id, "k2") + }); err != nil { + t.Fatal(err) + } + + // This window has not seen any of it, and edits. + if err := a.teamRename(id, "dock"); err != nil { + t.Fatal(err) + } + if err := a.teamAdd(id, []chatTab{{key: "k4", file: "f4", where: "/w", word: "lexer rewrite"}}); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + + check := func(where string, got team) { + t.Helper() + if got.Name != "dock" { + t.Fatalf("%s: the rename was lost: %q", where, got.Name) + } + if got.Manager != "k2" { + t.Fatalf("%s: the manager another process made is gone: %q", where, got.Manager) + } + if m, ok := got.ByHandle("pp"); !ok || m.Key != "k1" { + t.Fatalf("%s: the handle another process set is gone: %+v", where, got.Members) + } + if !got.Holds("k3") { + t.Fatalf("%s: the member another process added is gone: %+v", where, got.Members) + } + if m, ok := got.Member("k4"); !ok || m.Handle != "lexer" { + t.Fatalf("%s: the conversation added here did not join with a handle: %+v", where, got.Members) + } + } + disk, err := loadTeams(dir, nil) + if err != nil || len(disk) != 1 { + t.Fatalf("loaded %+v %v", disk, err) + } + check("on disk", disk[0]) + mine, _ := a.teamByID(id) + check("in the window", mine) +} + +// A CONVERSATION THAT JOINED BEFORE IT HAD A TITLE HAS NO HANDLE, and takes one +// the first time the team is written after its tab has a name. The handle is +// derived from the title and never changed afterwards by a later title. +func TestTeamUntitledMemberTakesAHandleOnceItHasATitle(t *testing.T) { + dir := t.TempDir() + a := newTestAppWithProfile(dir, nil) + id, err := a.teamMake("harbor", []chatTab{{key: "k1", file: "f1", word: "parser work"}}) + if err != nil { + t.Fatal(err) + } + // A member with no title, as a conversation joining on its first key is. + if err := a.teamEdit(func(f *teamstore.File) error { + return f.AddMember(id, teamstore.Member{Key: "k2", File: "f2"}) + }); err != nil { + t.Fatal(err) + } + if m, _ := a.wall.teams[0].Member("k2"); m.Handle != "" { + t.Fatalf("an untitled member has handle %q", m.Handle) + } + a.chatTabs = []chatTab{{key: "k2", file: "f2", word: "lexer rewrite"}} + if err := a.teamRecolor(id, teamHueSpec{Hue: 40, Tier: 1}); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + disk, _ := loadTeams(dir, nil) + if m, _ := disk[0].Member("k2"); m.Handle != "lexer" || m.Word != "lexer rewrite" { + t.Fatalf("the titled member was saved as %+v", m) + } + // A later title leaves the handle alone. + a.chatTabs = []chatTab{{key: "k2", file: "f2", word: "totally different"}} + if err := a.teamRename(id, "dock"); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + disk, _ = loadTeams(dir, nil) + if m, _ := disk[0].Member("k2"); m.Handle != "lexer" { + t.Fatalf("a new title moved the handle to %q", m.Handle) + } +} + +// A DISK THAT REFUSES LEAVES THE EDIT IN THE WINDOW. The change is made to what +// the window holds before the store is asked, and the store is asked off the +// loop; its refusal comes back as a note saying the change is kept for this +// window, and the person still sees what they did. +func TestTeamEditKeptInTheWindowWhenTheDiskRefuses(t *testing.T) { + dir := t.TempDir() + a := newTestAppWithProfile(dir, nil) + id, err := a.teamMake("harbor", []chatTab{{key: "k1", file: "f1", word: "parser work"}}) + if err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + refused := errors.New("refused") + calls := 0 + err = a.teamEdit(func(f *teamstore.File) error { + calls++ + if calls == 2 { + return refused + } + i := teamIndex(f.Teams, id) + f.Teams[i].Name = "dock" + return nil + }) + if err != nil { + t.Fatalf("the window's own change was refused: %v", err) + } + teamsFlush(t, a) + if got := lastNote(t, a); !strings.Contains(got, "kept for this window") || !strings.Contains(got, "refused") { + t.Fatalf("the refusal was said as %q", got) + } + if got, _ := a.teamByID(id); got.Name != "dock" { + t.Fatalf("the window lost the edit: %q", got.Name) + } + if disk, _ := loadTeams(dir, nil); disk[0].Name != "harbor" { + t.Fatalf("a refused edit reached the disk: %q", disk[0].Name) + } +} diff --git a/internal/tui3/teamhue.go b/internal/tui3/teamhue.go new file mode 100644 index 0000000000..2dd7709a14 --- /dev/null +++ b/internal/tui3/teamhue.go @@ -0,0 +1,250 @@ +package tui3 + +import ( + "math" + "sync" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── A TEAM'S COLOUR, GENERATED ────────────────────────────────────────────── +// +// A team is told apart by a colour, and the colours are generated rather +// than picked from a list, so that the tenth team is as easy to tell from the +// other nine as the second is from the first. +// +// THE COLOURS LIVE IN OKLCH, where equal steps of hue look like equal steps. +// A team keeps only its hue angle and a lightness tier; the lightness and +// chroma come from the tier and the ladder being drawn on, so one team reads +// right on a dark terminal and a light one. +// +// THE HUES THAT ALREADY MEAN SOMETHING ARE KEPT OUT. Amber is a question +// waiting, the live ink is work running, red is a failure and the accent is the +// cursor; a team in any of those would say a second thing in a colour that +// already says one. Their hues are read off the ramp being drawn with, never +// written down here, so a theme that moves them moves the bands with them. +// +// EACH NEW TEAM TAKES THE FARTHEST HUE: of every allowed degree, the one whose +// nearest used hue is farthest away. The second team lands opposite the +// first, the third splits the widest gap, and so on; past six the tiers +// alternate so neighbours differ in lightness as well. + +// teamHueSpec is a team's colour as stored: a hue angle in degrees and a +// lightness tier, 0 or 1. The spacing arithmetic is the store's +// (internal/teams/hue.go), because a team is coloured on load there; the +// palette's side of it, which hues are reserved and how a hue is drawn, is +// here. +type teamHueSpec = teamstore.HueSpec + +// teamHueBand is how many degrees either side of a meaningful hue no team +// may take. +const teamHueBand = teamstore.HueBand + +// ── OKLAB AND OKLCH ───────────────────────────────────────────────────────── + +func srgbToLinear(c float64) float64 { + if c <= 0.04045 { + return c / 12.92 + } + return math.Pow((c+0.055)/1.055, 2.4) +} + +func linearToSRGB(c float64) float64 { + if c <= 0.0031308 { + return 12.92 * c + } + return 1.055*math.Pow(c, 1/2.4) - 0.055 +} + +// rgbToOKLab is an 8-bit sRGB colour in OKLab. +func rgbToOKLab(r, g, b uint8) (L, A, B float64) { + lr, lg, lb := srgbToLinear(float64(r)/255), srgbToLinear(float64(g)/255), srgbToLinear(float64(b)/255) + l := math.Cbrt(0.4122214708*lr + 0.5363325363*lg + 0.0514459929*lb) + m := math.Cbrt(0.2119034982*lr + 0.6806995451*lg + 0.1073969566*lb) + s := math.Cbrt(0.0883024619*lr + 0.2817188376*lg + 0.6299787005*lb) + return 0.2104542553*l + 0.7936177850*m - 0.0040720468*s, + 1.9779984951*l - 2.4285922050*m + 0.4505937099*s, + 0.0259040371*l + 0.7827717662*m - 0.8086757660*s +} + +// oklchToSRGB is an OKLCH colour as sRGB channels in 0..1, which may fall +// outside that range when the colour is outside the gamut. +func oklchToSRGB(L, C, h float64) (r, g, b float64) { + A, B := C*math.Cos(h*math.Pi/180), C*math.Sin(h*math.Pi/180) + l := L + 0.3963377774*A + 0.2158037573*B + m := L - 0.1055613458*A - 0.0638541728*B + s := L - 0.0894841775*A - 1.2914855480*B + l, m, s = l*l*l, m*m*m, s*s*s + r = linearToSRGB(4.0767416621*l - 3.3077115913*m + 0.2309699292*s) + g = linearToSRGB(-1.2684380046*l + 2.6097574011*m - 0.3413193965*s) + b = linearToSRGB(-0.0041960863*l - 0.7034186147*m + 1.7076147010*s) + return r, g, b +} + +// inGamut reports whether three sRGB channels are all drawable. +func inGamut(r, g, b float64) bool { + const eps = 1e-4 + return r >= -eps && r <= 1+eps && g >= -eps && g <= 1+eps && b >= -eps && b <= 1+eps +} + +func to8(c float64) uint8 { + return uint8(math.Round(math.Min(math.Max(c, 0), 1) * 255)) +} + +// oklabHue is the OKLCH hue of an 8-bit colour, in degrees 0..360. +func oklabHue(r, g, b uint8) float64 { + _, A, B := rgbToOKLab(r, g, b) + h := math.Atan2(B, A) * 180 / math.Pi + if h < 0 { + h += 360 + } + return h +} + +// hueGap is the distance between two hues around the circle, 0..180. +func hueGap(a, b float64) float64 { return teamstore.HueGap(a, b) } + +// ── THE GENERATOR ─────────────────────────────────────────────────────────── + +// teamReservedHues is the hues the palette already spends on meaning: the +// question's amber, the running ink, the failure red and the cursor's accent. +func teamReservedHues(p palette) []float64 { + return teamReservedFrom(p.ramp) +} + +func teamReservedFrom(r ramp) []float64 { + out := make([]float64, 0, 4) + for _, h := range []hue{r.warn, r.live, r.bad, r.accent} { + out = append(out, oklabHue(h.r, h.g, h.b)) + } + return out +} + +// teamHueAllowed reports whether a hue is clear of every reserved band. +func teamHueAllowed(h float64, reserved []float64) bool { return teamstore.HueAllowed(h, reserved) } + +// nextTeamHue is the colour for a new team beside the used ones +// ([teamstore.NextHue]). +func nextTeamHue(used []teamHueSpec, reserved []float64) teamHueSpec { + return teamstore.NextHue(used, reserved) +} + +// teamHueChoices is k colours a new team could take, best first. They are +// what the new-team card offers as swatches and what shuffle walks through. +func teamHueChoices(used []teamHueSpec, reserved []float64, k int) []teamHueSpec { + return teamstore.HueChoices(used, reserved, k) +} + +// ── DRAWING ONE ───────────────────────────────────────────────────────────── + +// teamGround is the luminance of the background a team colour must read on: +// the one the terminal reported, else the middle of the assumed dark range, or +// white on the light ladder (styles.go's THE GLARE LAW names both). +func teamGround(p palette) float64 { + switch { + case p.measured: + return luminanceOf(p.ground.r, p.ground.g, p.ground.b) + case p.light: + return luminanceOf(0xFF, 0xFF, 0xFF) + } + return luminanceOf(0x1A, 0x1B, 0x26) +} + +// teamLight reports whether the palette is drawing on a light background. +func teamLight(p palette) bool { + if p.measured { + return luminanceOf(p.ground.r, p.ground.g, p.ground.b) > 0.18 + } + return p.light +} + +// teamRGB is a team colour as 8-bit sRGB for this palette: the tier's +// lightness and chroma, the chroma eased until the colour is drawable, and the +// lightness moved away from the background until it reads at 3:1. +func teamRGB(p palette, h teamHueSpec) (uint8, uint8, uint8) { + light := teamLight(p) + L, C := 0.80, 0.11 + if h.Tier == 1 { + L, C = 0.68, 0.13 + } + if light { + L, C = 0.55, 0.13 + if h.Tier == 1 { + L = 0.45 + } + } + ground := teamGround(p) + for step := 0; step < 40; step++ { + c := C + r, g, b := oklchToSRGB(L, c, h.Hue) + for !inGamut(r, g, b) && c > 0 { + c = math.Max(c-0.005, 0) + r, g, b = oklchToSRGB(L, c, h.Hue) + } + r8, g8, b8 := to8(r), to8(g), to8(b) + if contrastRatio(luminanceOf(r8, g8, b8), ground) >= 3 || L <= 0.05 || L >= 0.98 { + return r8, g8, b8 + } + if light { + L -= 0.02 + } else { + L += 0.02 + } + } + r, g, b := oklchToSRGB(L, 0, h.Hue) + return to8(r), to8(g), to8(b) +} + +// xterm256Lab is the OKLab of every cube and grey index, computed once. +var ( + xterm256Once sync.Once + xterm256Lab [256][3]float64 +) + +// nearest256Lab is the closest xterm-256 index to a colour by OKLab distance, +// over the cube and the grey ramp and never the first sixteen, which are the +// person's own theme. +func nearest256Lab(r, g, b uint8) uint8 { + xterm256Once.Do(func() { + for i := 16; i < 256; i++ { + var cr, cg, cb int + if i < 232 { + n := i - 16 + cr, cg, cb = cubeLevels[n/36], cubeLevels[(n/6)%6], cubeLevels[n%6] + } else { + v := 8 + 10*(i-232) + cr, cg, cb = v, v, v + } + L, A, B := rgbToOKLab(uint8(cr), uint8(cg), uint8(cb)) + xterm256Lab[i] = [3]float64{L, A, B} + } + }) + L, A, B := rgbToOKLab(r, g, b) + best, bestD := 16, math.Inf(1) + for i := 16; i < 256; i++ { + c := xterm256Lab[i] + d := (L-c[0])*(L-c[0]) + (A-c[1])*(A-c[1]) + (B-c[2])*(B-c[2]) + if d < bestD { + best, bestD = i, d + } + } + return uint8(best) +} + +// teamHueOf is a team colour as a hue this palette can paint with. +func teamHueOf(p palette, h teamHueSpec) hue { + r, g, b := teamRGB(p, h) + return hue{r: r, g: g, b: b, idx: nearest256Lab(r, g, b), tier: flat} +} + +// teamInk is the pen a team's colour is drawn with, or nil where there is no +// colour to draw: a terminal under 256 colours, NO_COLOR, or the ASCII floor. +// A caller given nil draws the team's initial, dim, instead of a dot. +func (p palette) teamInk(h teamHueSpec) func(string) string { + if p.ascii || p.profile < tokens.ANSI256 { + return nil + } + hh := teamHueOf(p, h) + return func(s string) string { return p.paint(s, hh) } +} diff --git a/internal/tui3/teamhue_test.go b/internal/tui3/teamhue_test.go new file mode 100644 index 0000000000..aa27cf09ea --- /dev/null +++ b/internal/tui3/teamhue_test.go @@ -0,0 +1,230 @@ +package tui3 + +import ( + "fmt" + "math" + "os" + "path/filepath" + "testing" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// teamHueSequence is the first n hues the generator hands out, one team at a +// time. +func teamHueSequence(n int, reserved []float64) []teamHueSpec { + var used []teamHueSpec + for len(used) < n { + used = append(used, nextTeamHue(used, reserved)) + } + return used +} + +// THE FARTHEST POINT SPREADS THE HUES: however many teams there are, the +// closest two are about as far apart as an even share of the allowed circle +// would put them. +func TestTeamHueFarthestPointIsWellSpread(t *testing.T) { + reserved := teamReservedFrom(darkRamp) + // The circle's allowed share: every degree outside the bands. + allowed := 0 + for d := 0; d < 360; d++ { + if teamHueAllowed(float64(d), reserved) { + allowed++ + } + } + for n := 2; n <= 12; n++ { + seq := teamHueSequence(n, reserved) + least := 360.0 + for i := range seq { + for j := range seq[:i] { + least = math.Min(least, hueGap(seq[i].Hue, seq[j].Hue)) + } + } + // Farthest-point insertion is within a factor of two of the best + // spacing; on this circle it does far better, and the floor is the + // share each would get minus the part the bands take from it. + floor := 0.9*float64(allowed)/float64(n) - float64(2*teamHueBand) + if least < floor { + t.Errorf("n=%d: the closest two hues are %.0f° apart, want at least %.0f (%v)", n, least, floor, seq) + } + } +} + +// NO TEAM TAKES A HUE THAT ALREADY MEANS SOMETHING. +func TestTeamHueKeepsOutOfTheReservedBands(t *testing.T) { + for name, r := range map[string]ramp{"dark": darkRamp, "light": lightRamp} { + reserved := teamReservedFrom(r) + if len(reserved) != 4 { + t.Fatalf("%s: %d reserved hues, want amber, live, red and accent", name, len(reserved)) + } + for _, h := range teamHueSequence(24, reserved) { + for _, res := range reserved { + if hueGap(h.Hue, res) < teamHueBand { + t.Fatalf("%s: hue %.0f sits %.1f° from reserved %.1f", name, h.Hue, hueGap(h.Hue, res), res) + } + } + } + } +} + +// THE TIERS: six at the first lightness, then alternating. +func TestTeamHueTiersAlternateAfterSix(t *testing.T) { + seq := teamHueSequence(10, teamReservedFrom(darkRamp)) + want := []int{0, 0, 0, 0, 0, 0, 1, 0, 1, 0} + for i, h := range seq { + if h.Tier != want[i] { + t.Fatalf("team %d: tier %d, want %d", i, h.Tier, want[i]) + } + } +} + +// OKLCH TO sRGB AND BACK: the conversion is sane, and every colour a team is +// given is inside the gamut and reads at 3:1 on the dark ramp's ground. +func TestTeamHueRoundTripGamutAndContrast(t *testing.T) { + for _, c := range [][3]uint8{{0x9D, 0xC3, 0xE6}, {0xEB, 0xCB, 0x8B}, {0x80, 0x80, 0x80}, {0xFF, 0x00, 0x00}} { + L, A, B := rgbToOKLab(c[0], c[1], c[2]) + C := math.Hypot(A, B) + h := math.Atan2(B, A) * 180 / math.Pi + r, g, b := oklchToSRGB(L, C, h) + if got := [3]uint8{to8(r), to8(g), to8(b)}; got != c { + if absDiff(got[0], c[0]) > 1 || absDiff(got[1], c[1]) > 1 || absDiff(got[2], c[2]) > 1 { + t.Fatalf("#%02x%02x%02x came back as #%02x%02x%02x", c[0], c[1], c[2], got[0], got[1], got[2]) + } + } + } + pal := newPalette(tokens.TrueColor, false) + ground := teamGround(pal) + for i, h := range teamHueSequence(12, teamReservedHues(pal)) { + r, g, b := teamRGB(pal, h) + if ratio := contrastRatio(luminanceOf(r, g, b), ground); ratio < 3 { + t.Fatalf("team %d #%02x%02x%02x is %.2f:1 on the ground", i, r, g, b, ratio) + } + // The drawn colour carries the hue it was given. + if got := oklabHue(r, g, b); hueGap(got, h.Hue) > 6 { + t.Fatalf("team %d asked for %.0f° and drew %.0f°", i, h.Hue, got) + } + } +} + +func absDiff(a, b uint8) uint8 { + if a > b { + return a - b + } + return b - a +} + +// THE 256-COLOUR MAPPING IS THE SAME EVERY TIME, and never one of the first +// sixteen, which are the person's own theme. +func TestTeamHueANSI256IsDeterministic(t *testing.T) { + pal := newPalette(tokens.ANSI256, false) + for _, h := range teamHueSequence(8, teamReservedHues(pal)) { + a, b := teamHueOf(pal, h).idx, teamHueOf(pal, h).idx + if a != b || a < 16 { + t.Fatalf("hue %.0f maps to %d then %d", h.Hue, a, b) + } + } + if newPalette(tokens.ANSI16, false).teamInk(teamHueSpec{Hue: 100}) != nil { + t.Fatal("sixteen colours drew a team colour") + } + if newPalette(tokens.TrueColor, true).teamInk(teamHueSpec{Hue: 100}) != nil { + t.Fatal("the ASCII floor drew a team colour") + } +} + +// THE FIRST EIGHT COLOURS ON THE DARK RAMP, for the record. +func TestTeamHuePrintsTheFirstEight(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + for i, h := range teamHueSequence(8, teamReservedHues(pal)) { + r, g, b := teamRGB(pal, h) + t.Logf("team %d: hue %3.0f° tier %d #%02x%02x%02x %.2f:1", i+1, h.Hue, h.Tier, r, g, b, + contrastRatio(luminanceOf(r, g, b), teamGround(pal))) + } + t.Logf("reserved: %v", fmtHues(teamReservedHues(pal))) +} + +func fmtHues(hs []float64) string { + s := "" + for _, h := range hs { + s += fmt.Sprintf("%.0f° ", h) + } + return s +} + +// A FILE FROM BEFORE COLOURS IS COLOURED ON LOAD, THE SAME WAY EVERY TIME, and +// around the teams that already have theirs. +func TestTeamHueLegacyLoadIsStable(t *testing.T) { + dir := t.TempDir() + legacy := `{"spaces":[{"name":"a","members":[{"key":"k1"}]},{"name":"b","members":[],"hue":200,"tier":0},{"name":"c","members":[]}]}` + if err := os.WriteFile(filepath.Join(dir, teamsLegacyFile), []byte(legacy), 0o600); err != nil { + t.Fatal(err) + } + load := func() []team { + a := newTestAppWithProfile(dir, nil) + a.teamsEnsure() + return a.wall.teams + } + first, second := load(), load() + if first[1].Hue != 200 { + t.Fatalf("a stored hue was replaced: %v", first[1].Hue) + } + for i := range first { + if first[i].Hue != second[i].Hue || first[i].Tier != second[i].Tier { + t.Fatalf("team %d coloured %v then %v", i, first[i].HueSpec(), second[i].HueSpec()) + } + } + if hueGap(first[0].Hue, 200) < 60 || hueGap(first[2].Hue, 200) < 60 || hueGap(first[0].Hue, first[2].Hue) < 60 { + t.Fatalf("legacy teams crowd each other: %v %v %v", first[0].Hue, first[1].Hue, first[2].Hue) + } +} + +// EACH NEW TEAM TAKES A HUE NO OTHER HAS; toggling, recolouring and renaming +// are saved. +func TestTeamColourAndEditsPersist(t *testing.T) { + dir := t.TempDir() + a := newTestAppWithProfile(dir, nil) + seen := map[float64]bool{} + var ids []string + for i, name := range []string{"one", "two", "three", "four"} { + id, err := a.teamMake(name, []chatTab{{key: fmt.Sprintf("k%d", i)}}) + if err != nil { + t.Fatal(err) + } + ids = append(ids, id) + made, _ := a.teamByID(id) + h := made.Hue + if seen[h] { + t.Fatalf("team %s took hue %.0f, which another team has", name, h) + } + seen[h] = true + } + tab := chatTab{key: "k9", word: "nine"} + if err := a.teamToggleMember(ids[0], tab); err != nil { + t.Fatal(err) + } + if got := a.teamsOf("k9"); len(got) != 1 || got[0] != ids[0] { + t.Fatalf("after toggling in: %v", got) + } + if err := a.teamToggleMember(ids[1], tab); err != nil { + t.Fatal(err) + } + if got := a.teamsOf("k9"); len(got) != 2 { + t.Fatalf("a conversation in two teams is in %v", got) + } + if err := a.teamRecolor(ids[0], teamHueSpec{Hue: 123, Tier: 1}); err != nil { + t.Fatal(err) + } + if err := a.teamRename(ids[0], "renamed"); err != nil { + t.Fatal(err) + } + if err := a.teamRename(ids[1], "RENAMED"); err == nil { + t.Fatal("a second team took a name already used") + } + if err := a.teamToggleMember(ids[1], tab); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + got, _ := loadTeams(dir, nil) + if got[0].Name != "renamed" || got[0].Hue != 123 || got[0].Tier != 1 || !teamHolds(got[0], "k9") || teamHolds(got[1], "k9") { + t.Fatalf("on disk: %+v", got[:2]) + } +} diff --git a/internal/tui3/teamjump.go b/internal/tui3/teamjump.go new file mode 100644 index 0000000000..21a0ec658d --- /dev/null +++ b/internal/tui3/teamjump.go @@ -0,0 +1,206 @@ +package tui3 + +import ( + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── TAKEN TO THE MESSAGE ──────────────────────────────────────────────────── +// +// A handle on the Traffic, or on a thread card's answer, opens that member's +// conversation SCROLLED TO THE MESSAGE the row is about, not just the +// conversation: a thread's header lands at the directive as the member was +// told it, and an answer lands at the member's own post. The words on the +// thread's header land at the thread card in the manager's own conversation. +// +// Every place a Traffic entry sits in a transcript carries its number: a +// delivered note ends each line with ` #N` (session's teamLine, read back as +// [session.TeamLine.Thread]), a team_send's answer says `(#N)` and a +// team_post's says ` as #N`. The jump finds the newest entry carrying the +// number, scrolls it into view and lifts it for [trafficLandFor]. The focus +// stays on the conversation just opened: nothing here takes the keyboard. +// +// A conversation that is still opening is waited for: the jump is kept, with +// its member's key, until that conversation is in front, and is dropped after +// [trafficJumpWait] so a later visit does not scroll by surprise. A number +// that is in no entry (an older message, from before this conversation's +// history) opens at the bottom and says so in the hint line. + +// trafficLandFor is how long a landed message stays lifted, and +// trafficJumpWait how long a jump waits for its conversation to open. +const ( + trafficLandFor = 1600 * time.Millisecond + trafficJumpWait = 10 * time.Second +) + +// trafficOlderWords is what the hint line says when the message is not in the +// conversation's history. +const trafficOlderWords = "that message is older than this chat's history" + +// trafficJumpTo is a jump waiting for its conversation, and trafficLanding +// the entry lifted after one, or the hint said when it found nothing. +type trafficJumpTo struct { + key, id string + until time.Time +} + +type trafficLanding struct { + entry int + older bool + until time.Time +} + +// trafficLandedMsg is the lift expiring: one repaint. +type trafficLandedMsg struct{} + +// trafficJump opens member key's conversation at Traffic entry id, or in +// front at id when key is "" or already in front. +func (a *app) trafficJump(key, id string) tea.Cmd { + var cmd tea.Cmd + if key != "" && key != a.frontTabKey() { + cmd = a.trafficGo(key) + } + if key == "" { + key = a.frontTabKey() + } + a.traffic.jump = trafficJumpTo{key: key, id: id, until: a.now().Add(trafficJumpWait)} + return tea.Batch(cmd, a.trafficLand()) +} + +// trafficLand finishes a waiting jump once its conversation is in front. It +// runs on the loop after every message (app.go's Update). +func (a *app) trafficLand() tea.Cmd { + j := a.traffic.jump + if j.key == "" { + return nil + } + if a.now().After(j.until) { + a.traffic.jump = trafficJumpTo{} + return nil + } + if a.frontTabKey() != j.key { + return nil + } + a.traffic.jump = trafficJumpTo{} + if j.id == "" { + return nil + } + at := a.teamEntryAt(j.id) + land := trafficLanding{entry: at, until: a.now().Add(trafficLandFor)} + if at < 0 { + a.offset, a.stick = 0, true + land.older = true + land.until = a.now().Add(3 * trafficLandFor) + } else { + a.revealMiddle(at) + } + a.traffic.landing = land + a.touch() + wait := land.until.Sub(a.now()) + 50*time.Millisecond + return tea.Tick(wait, func(time.Time) tea.Msg { return trafficLandedMsg{} }) +} + +// teamEntryAt is the newest entry of the conversation that carries Traffic +// entry id, -1 for none. +func (a *app) teamEntryAt(id string) int { + if id == "" { + return -1 + } + number := teamstore.ThreadNumber(id) + for i := len(a.entries) - 1; i >= 0; i-- { + e := &a.entries[i] + switch e.kind { + case entryTeam: + for _, l := range e.team { + if l.Thread == id { + return i + } + } + case entryTool: + switch e.tool { + case "team_send": + if strings.Contains(e.detail.Output, "("+number+")") { + return i + } + case "team_post": + if strings.Contains(e.detail.Output, " as "+number+",") || strings.Contains(e.detail.Output, " as "+number+".") { + return i + } + } + } + } + return -1 +} + +// revealMiddle scrolls so entry's first row sits a third of the way down the +// view, which puts the message and a little of what came after it in sight. +func (a *app) revealMiddle(entry int) { + height := a.viewHeight() + if height <= 0 { + return + } + rows := a.visible(a.bodyWidth()) + for i, r := range rows { + if r.entry != entry { + continue + } + bottom := max(len(rows)-height, 0) + at := min(max(i-height/3, 0), bottom) + a.offset, a.stick = at, at == bottom + return + } +} + +// trafficLandRows lifts the landed entry's rows on the ground a selected row +// wears. It copies only while a lift is on. +func (a *app) trafficLandRows(rows []row, width int) []row { + l := a.traffic.landing + if l.older || l.entry < 0 || !a.now().Before(l.until) { + return rows + } + var out []row + for i, r := range rows { + if r.entry != l.entry { + continue + } + if out == nil { + out = append([]row(nil), rows...) + } + out[i].text = a.pal.selected(r.text, width) + } + if out == nil { + return rows + } + return out +} + +// trafficJumpWords is the hint line's word after a jump found nothing, "" at +// every other time. +func (a *app) trafficJumpWords() string { + l := a.traffic.landing + if l.older && a.now().Before(l.until) { + return trafficOlderWords + } + return "" +} + +// threadRowLand is the Traffic entry a handle on this row of a thread card +// opens its member at: the answer on an answer's row, the card's own message +// on its header, "" on any other row. +func (a *app) threadRowLand(r row) string { + if r.open != "" { + _, id, _ := strings.Cut(r.open, "/") + return id + } + if r.entry < 0 || r.entry >= len(a.entries) { + return "" + } + if m := a.entries[r.entry].thread; m != nil && m.found { + return m.root + } + return "" +} diff --git a/internal/tui3/teamjump_test.go b/internal/tui3/teamjump_test.go new file mode 100644 index 0000000000..6ce3037460 --- /dev/null +++ b/internal/tui3/teamjump_test.go @@ -0,0 +1,210 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// fillEntries puts n settled notes on the conversation, so a message among +// them is off screen until something scrolls to it. +func fillEntries(a *app, n int, word string) { + for i := 0; i < n; i++ { + a.entries = append(a.entries, entry{kind: entryNote, text: word + " " + itoa(i), settled: true}) + } + a.touch() +} + +// landedRow is the drawn row of the body holding want, and whether it wears +// the lift. +func landedRow(a *app, want string) (bool, bool) { + body, _ := a.bodyRows(a.bodyWidth(), a.viewHeight()) + plainRows, _ := a.window(a.bodyWidth(), a.viewHeight()) + for i, r := range body { + if strings.Contains(ansi.Strip(r.text), want) { + return true, i < len(plainRows) && r.text != plainRows[i].text + } + } + return false, false +} + +// A HANDLE ON A THREAD'S HEADER OPENS ITS MEMBER AT THE DIRECTIVE, scrolled into +// view and lifted, with the member's conversation in front; a handle on an +// answer is a door onto the member's own post. +func TestTrafficJumpOpensTheMemberAtTheMessage(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 30 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q := threadScenario(t, a, harbor, price, rail) + // The column's handles carry where they land: the work row's at the + // directive, and a reply's, laid open, at the member's own post. + a.sideToggleThread(sideThreadKey(harbor, q)) + _ = railLines(t, a) + var header, answer string + for _, row := range a.side.last { + for _, d := range row.doors { + if d.act.kind != sideActJump || d.act.key != priceKey { + continue + } + if row.key == "thread/"+q { + header = d.act.entry + } else if strings.HasPrefix(row.key, "reply/") { + answer = d.act.entry + } + } + } + if header != q || answer == "" || answer == q { + t.Fatalf("the handles do not carry their message: header %q answer %q", header, answer) + } + // In the member's conversation the directive sits above a long tail. + spend(t, a, a.trafficGo(priceKey)) + if a.frontTabKey() != priceKey { + t.Fatal("the member is not in front") + } + fillEntries(a, 5, "before") + note := "Team traffic in \"harbor\" for you (@" + price + "). These are the team's messages, not the person's words:\n◆ directive from manager " + teamstore.ThreadNumber(q) + ": Please provide a brief status update on your part\n(rule)" + a.entries = append(a.entries, entry{kind: entryTeam, text: note, settled: true, + team: []session.TeamLine{{Team: "harbor", From: teamstore.FromManager, Kind: teamstore.KindDirective, Text: "Please provide a brief status update on your part", Thread: q}}}) + fillEntries(a, 60, "after") + a.offset, a.stick = 0, true + if shown, _ := landedRow(a, "brief status update"); shown { + t.Fatal("the directive is on screen before the jump") + } + spend(t, a, a.trafficJump(priceKey, q)) + shown, lifted := landedRow(a, "brief status update") + if !shown || !lifted || a.frontTabKey() != priceKey { + t.Fatalf("the jump did not bring the directive into view, lifted (shown %v lifted %v)", shown, lifted) + } + // AND AN ANSWER'S HANDLE LANDS AT THE MEMBER'S OWN POST. + fillEntries(a, 3, "gap") + a.entries = append(a.entries, entry{kind: entryTool, tool: "team_post", status: toolOK, settled: true, text: "team_post", + detail: toolDetail{Args: `{"to":"manager","text":"my own answer"}`, Output: "Posted to the manager in \"harbor\" as " + teamstore.ThreadNumber(answer) + ", answering " + teamstore.ThreadNumber(q) + ". It arrives at the start of their next step."}}) + fillEntries(a, 60, "tail") + a.offset, a.stick = 0, true + if at := a.teamEntryAt(answer); at != len(a.entries)-61 { + t.Fatalf("the member's own post is not found: %d", at) + } + spend(t, a, a.trafficJump(priceKey, answer)) + if a.traffic.landing.entry != len(a.entries)-61 { + t.Fatalf("the jump landed on entry %d", a.traffic.landing.entry) + } + // AND A JUMP WAITS FOR ITS CONVERSATION: kept while another is in front. + a.traffic.jump = trafficJumpTo{key: "somebody-else", id: q, until: a.now().Add(trafficJumpWait)} + if a.trafficLand(); a.traffic.jump.key == "" { + t.Fatal("a jump for a conversation not in front was dropped") + } +} + +// A MESSAGE OLDER THAN THE CONVERSATION'S HISTORY opens at the bottom and the +// hint line says so. +func TestTrafficJumpToAnOlderMessage(t *testing.T) { + a, _, _, _ := trafficApp(t) + a.width, a.height = 160, 30 + fillEntries(a, 60, "line") + a.offset, a.stick = 0, false + spend(t, a, a.trafficJump("", "000000000999")) + if !a.stick || a.dockHoverWords() != trafficOlderWords { + t.Fatalf("an older message left stick %v and the hint %q", a.stick, a.dockHoverWords()) + } +} + +// IN THE MANAGER'S CONVERSATION a press on a row of work brings the thread +// card into view, lifted, and the conversation in front stays in front; a +// handle on the card's answer opens the member at its own post. +func TestTrafficJumpBringsTheCardIntoView(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 30 + price, _ := trafficHandle(t, a, harbor, "openrouter") + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "status?"}) + reply, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "prices are cached", Answers: q}) + trafficReadNow(t, a) + fillEntries(a, 5, "before") + sendRow(a, `{"to":"`+price+`","text":"status?","kind":"directive"}`, "Sent a directive to @"+price+" ("+teamstore.ThreadNumber(q)+").") + fillEntries(a, 60, "after") + if shown, _ := landedRow(a, "│ status?"); shown { + t.Fatal("the card is on screen before the press") + } + front := a.frontTabKey() + _ = railLines(t, a) + x, y := sideRowOn(t, a, "thread/"+q) + sideClick(t, a, x, y) + if shown, lifted := landedRow(a, "│ status?"); !shown || !lifted || a.frontTabKey() != front { + t.Fatalf("the press did not bring the card into view, lifted, here (shown %v lifted %v)", shown, lifted) + } + // The card's answer row names the answer for its handle. + body, _ := bodyRows(a) + found := false + for _, r := range body { + if strings.Contains(ansi.Strip(r.text), "prices are cached") && r.open != "" { + found = a.threadRowLand(r) == reply + } + } + if !found { + t.Fatal("the card's answer does not open its member at the answer") + } +} + +// A PRESS ON THE ROW, NOT ONLY THE HANDLE, OPENS THE CHAT THE MESSAGE BELONGS +// TO, at that message. The manager's own words stay here and scroll. A reply +// opens the member who wrote it. In the member's chat, the member's own reply +// scrolls in place, and a message the manager wrote opens the manager. +func TestTrafficPressOpensTheConversationTheMessageBelongsTo(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + manager := a.frontTabKey() + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: teamstore.ToEveryone, Text: "all hands on the parser"}) + reply, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "parser numbers are in", Answers: q}) + trafficReadNow(t, a) + fillEntries(a, 8, "before") + sendRow(a, `{"to":"everyone","text":"all hands on the parser","kind":"directive"}`, "Sent a directive to everyone ("+teamstore.ThreadNumber(q)+").") + fillEntries(a, 60, "after") + a.offset, a.stick = 0, true + _ = railLines(t, a) + x, y := sideRowOn(t, a, "thread/"+q) + sideClick(t, a, x, y) + shown, lifted := landedRow(a, "all hands on the parser") + if !shown || !lifted || a.frontTabKey() != manager { + t.Fatalf("a press on the manager's row did not stay and lift it (shown %v lifted %v front %q)", shown, lifted, a.frontTabKey()) + } + if a.traffic.landing.entry < 0 { + t.Fatal("the manager's row did not highlight an entry") + } + + // THE REPLY OPENS THE MEMBER WHO WROTE IT. + a.sideToggleThread(sideThreadKey(harbor, q)) + _ = railLines(t, a) + x, y = sideRowOn(t, a, "reply/"+reply) + sideClick(t, a, x, y) + if a.frontTabKey() != priceKey { + t.Fatalf("a press on the reply opened %q, want %q", a.frontTabKey(), priceKey) + } + + // IN THE MEMBER'S CHAT the member's own line scrolls here, and the + // manager's line opens the manager. + note := "Posted to the manager in \"harbor\" as " + teamstore.ThreadNumber(reply) + ", answering " + teamstore.ThreadNumber(q) + "." + a.entries = nil + fillEntries(a, 8, "pad") + a.entries = append(a.entries, entry{kind: entryTool, tool: "team_post", status: toolOK, settled: true, text: "team_post", + detail: toolDetail{Output: note}}) + fillEntries(a, 60, "tail") + a.offset, a.stick = 0, true + a.sideSetView(sideTraffic) + _ = railLines(t, a) + x, y = sideRowOn(t, a, railKeyOfReply(t, a, "parser numbers")) + front := a.frontTabKey() + sideClick(t, a, x, y) + if a.frontTabKey() != front || a.traffic.landing.entry < 0 { + t.Fatalf("a press on the member's own row left %q or highlighted nothing (entry %d)", a.frontTabKey(), a.traffic.landing.entry) + } + x, y = sideRowOn(t, a, railKeyOfReply(t, a, "all hands")) + sideClick(t, a, x, y) + if a.frontTabKey() != manager { + t.Fatalf("a press on the manager's message in the member's chat opened %q", a.frontTabKey()) + } +} diff --git a/internal/tui3/teamlink.go b/internal/tui3/teamlink.go new file mode 100644 index 0000000000..f733ce870c --- /dev/null +++ b/internal/tui3/teamlink.go @@ -0,0 +1,350 @@ +package tui3 + +import ( + "sort" + "strings" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── TEAM REFERENCES IN A CHAT ARE DOORS ───────────────────────────────────── +// +// A conversation in a team talks about its team all the time: the manager's +// replies name members (`@security has the branch`), a member's card says who +// wrote to it (`◆ manager → @gravity`), a tool call names who it is for +// (`team_send @milestones`). Every one of those names a conversation a person +// may want to look at, so every one of them is a link, exactly as a task +// reference is (markdown.go's [linkifyTasks]): the same pass over rendered rows, +// the same columns recorded on the row, the same click resolved by column +// before the row's own answer, and the same hover held as (block, ordinal). +// +// WHAT IS A LINK IS DECIDED FROM MEMORY AND NEVER GUESSED. An `@word` is a +// link only when it is the handle of a member of a team this conversation is +// in ([app.wall.teams], loaded at an opening; the frame reads no disk). Any +// other `@word` stays exactly as the model wrote it: a link that opens nothing +// is the surface claiming a door it does not have. A team's name is a link only +// where it is written AS a team, `team test`, `the test team` or `"test"`, +// because a team named `test` is also an ordinary word. +// +// A PRESS ON A MEMBER OPENS IT, and resumes it first when this window does not +// have it open, through the strip's own door ([app.tabGo]). A press on a team +// opens the teams page with that team selected: the rail's cursor on its row, +// the pane showing it, and the keyboard left on that row rather than moved +// into the pane. A closed team is selected inside `Closed`, and that fold is +// opened so the row is there. Over --host against an engine without the teams +// doors ([app.teamsOff]) the page cannot open, so the press still opens the +// conversations view on that team, and the hint says that rather than the +// page. A member's hint names the title: `Open @security · santosh dev2 +// branch… · click`. +// +// THE HOVER IS A GROUND, as every other control on this surface answers the +// pointer, and not the task link's brightening: the owner's bar is that +// everything clickable has a hover ground. +// +// THE ORDINALS ARE THE TASK LINKS' OWN SPACE, offset by [teamLinkOrd]. A block +// numbers its task references from zero across its rows; its team references +// are numbered from teamLinkOrd, so one hover state holds either and neither +// pass can light the other's link. + +// teamLinkOrd is the first ordinal a block's team references take. +const teamLinkOrd = 1 << 16 + +// teamLinkRow reports whether a row of entry e may carry team references: the +// model's prose, a team's quoted card, the surface's own notes, and the rows of +// a team tool's call. Everything else is someone else's text. +func teamLinkRow(e *entry) bool { + switch e.kind { + case entryAssistant, entryTeam, entryNote: + return true + case entryTool: + return strings.HasPrefix(e.tool, "team_") + } + return false +} + +// teamLinkScope is the teams this conversation's handles resolve in: every +// team it is a member of. nil when it is in none, which is almost every +// conversation, and the pass then costs one comparison per row. Frame-safe: +// memory only. +func (a *app) teamLinkScope() []team { + if !a.wall.loaded || len(a.wall.teams) == 0 { + return nil + } + front := a.frontTabKey() + var scope []team + for _, t := range a.wall.teams { + if teamHolds(t, front) { + scope = append(scope, t) + } + } + return scope +} + +// teamLinkPass inks every team reference on the rows of out, after they were +// laid out and before the indent law moves them. It is the team half of the +// link pass render.go's [app.deckRows] runs, over the same rows. +func (a *app) teamLinkPass(out []row, es []entry) { + scope := a.teamLinkScope() + if len(scope) == 0 { + return + } + front := a.frontTabKey() + block, n := -1, 0 + for i := range out { + r := &out[i] + if r.entry < 0 || r.entry >= len(es) || !teamLinkRow(&es[r.entry]) || r.hit == hitPictureOriginal { + continue + } + if r.entry != block { + block, n = r.entry, 0 + } + hot := -1 + if at := a.hoveringLink(r.entry); at >= teamLinkOrd { + hot = at - teamLinkOrd - n + } + prose := es[r.entry].kind == entryAssistant || es[r.entry].kind == entryNote + text, links := linkifyTeams(r.text, a.pal, scope, a.wall.teams, front, prose, hot) + if len(links) == 0 { + continue + } + for j := range links { + links[j].ord = teamLinkOrd + n + j + } + n += len(links) + r.text = text + r.links = append(r.links, links...) + } +} + +// linkifyTeams is the pass over one painted row: its references to scope's +// members and to teams inked, and their columns recorded. self is this +// conversation's key, whose own handle is not a door. prose says the row is +// the model's words, where inline code is code and a fence is source. +func linkifyTeams(text string, pal palette, scope, all []team, self string, prose bool, hot int) (string, []taskLink) { + if !strings.Contains(text, "@") && !teamNameIn(text, all) { + return text, nil + } + flat, ground := flatten(text) + if prose && strings.Contains(flat, tokens.GlyphCodeGutter) { + return text, nil + } + refs := append(teamHandleRefs(flat, scope, self), teamNameRefs(flat, all)...) + sort.SliceStable(refs, func(i, j int) bool { return refs[i].from < refs[j].from }) + kept := refs[:0] + end := 0 + for _, ref := range refs { + if ref.from < end { + continue + } + if prose && (grounded(ground, ref.from, ref.to) || masked(flat, ref.from)) { + continue + } + kept = append(kept, ref) + end = ref.to + } + if len(kept) == 0 { + return text, nil + } + return paintLinksWith(text, flat, kept, pal, hot, teamLinkInk, teamLinkHotInk) +} + +// teamLinkInk is what a team reference wears: the task link's own ink, the +// accent underlined, because both are the same kind of door. +func teamLinkInk(pal palette, s string) string { return taskLinkInk(pal, s) } + +// teamLinkHotInk is a team reference under the pointer: ink on the cursor +// ground, still underlined. +func teamLinkHotInk(pal palette, s string) string { + return pal.cursor(pal.underline(pal.ink(s)), 0) +} + +// teamNameIn is the cheap reject for names: whether any team's name appears +// in the painted row at all, ignoring case. +func teamNameIn(text string, all []team) bool { + for _, t := range all { + if name := strings.TrimSpace(t.Name); name != "" && indexFoldAny(text, name, 0) >= 0 { + return true + } + } + return false +} + +// teamHandleRefs is every `@handle` in s that names a member of scope other +// than self. An `@` inside a word (an address, `a@b`) opens nothing. +func teamHandleRefs(s string, scope []team, self string) []taskRef { + var out []taskRef + for i := 0; i < len(s); i++ { + if s[i] != '@' || (i > 0 && (wordByte(s[i-1]) || s[i-1] == '.' || s[i-1] == '@')) { + continue + } + j := i + 1 + for j < len(s) && (wordByte(s[j]) || s[j] == '-') { + j++ + } + for j > i+1 && s[j-1] == '-' { + j-- + } + if j == i+1 { + continue + } + handle := strings.ToLower(s[i+1 : j]) + for _, t := range scope { + if m, ok := t.ByHandle(handle); ok && m.Key != self { + out = append(out, taskRef{from: i, to: j, member: m.Key, team: t.ID}) + break + } + } + i = j - 1 + } + return out +} + +// teamNameRefs is every place in s a team's name is written as a team: after +// the word `team`, before it, or in quotes. +func teamNameRefs(s string, all []team) []taskRef { + var out []taskRef + for _, t := range all { + name := strings.TrimSpace(t.Name) + if name == "" { + continue + } + for at := 0; ; { + i := indexFoldAny(s, name, at) + if i < 0 { + break + } + j := i + len(name) + at = j + if (i > 0 && wordByte(s[i-1])) || (j < len(s) && wordByte(s[j])) { + continue + } + if teamNamedAsTeam(s, i, j) { + out = append(out, taskRef{from: i, to: j, team: t.ID}) + } + } + } + return out +} + +// teamNamedAsTeam reports whether s[i:j] is written as a team's name. +func teamNamedAsTeam(s string, i, j int) bool { + if i > 0 && j < len(s) && s[i-1] == '"' && s[j] == '"' { + return true + } + before := strings.TrimRight(strings.TrimRight(s[:i], `"`), " ") + if len(before) >= 4 && strings.EqualFold(before[len(before)-4:], "team") && + (len(before) == 4 || !wordByte(before[len(before)-5])) { + return true + } + after := strings.TrimLeft(strings.TrimLeft(s[j:], `"`), " ") + if len(after) < len(s[j:]) && len(after) >= 4 && strings.EqualFold(after[:4], "team") && + (len(after) == 4 || !wordByte(after[4])) { + return true + } + return false +} + +// indexFoldAny is [indexFold] for a needle in any case. +func indexFoldAny(s, needle string, from int) int { + for i := from; i+len(needle) <= len(s); i++ { + if strings.EqualFold(s[i:i+len(needle)], needle) { + return i + } + } + return -1 +} + +// teamLinkPress is a press on a team reference: the member opened, resumed +// first when this window does not have it open, or the team opened on the +// teams page ([app.openTeamFromLink]). +func (a *app) teamLinkPress(link taskLink) tea.Cmd { + t, ok := a.teamByID(link.team) + if !ok { + return nil + } + if link.member == "" { + if a.teamsOff() { + // THE PAGE IS NOT THERE. An older engine over --host has no teams + // doors, so the press keeps the door it had: the conversations + // view narrowed to this team. The hint says that, and only that. + a.wall.activeID = t.ID + a.chatTabBar = tabBar{} + return a.openWall() + } + return a.openTeamFromLink(t) + } + m, ok := t.Member(link.member) + if !ok || m.Key == a.frontTabKey() { + return nil + } + for _, tab := range a.tabList() { + if tab.key == m.Key { + return a.tabGo(tab) + } + } + word := m.Word + if strings.TrimSpace(word) == "" && m.Handle != "" { + word = "@" + m.Handle + } + return a.tabGo(chatTab{key: m.Key, file: m.File, where: m.Where, word: word, full: word}) +} + +// openTeamFromLink stands the teams page on team t. The rail's cursor is the +// landing and the pane shows the team. The keyboard stays on that row: a +// managed team's page otherwise hands it to the manager's composer, which +// would move the person into a sentence they did not ask to type. A closed +// team is selected inside the Closed fold, opened so the row exists. +func (a *app) openTeamFromLink(t team) tea.Cmd { + if t.Closed() { + a.tp.closedOpen = true + } + // The pointer was on a link in the chat that is no longer drawn; kept, it + // would leave that link's hint on a page that has no such link. + a.dropHover() + a.tp.sel = t.ID + cmd := a.showPage(pageTeams) + a.tp.focus = true + a.tp.cur = teamsRef{act: teamsActSelect, id: t.ID} + return cmd +} + +// teamLinkHint is what the hint line says with the pointer on a team +// reference, "" when it is not on one. +func (a *app) teamLinkHint() string { + if a.hot.kind != hoverLink || a.hot.index < teamLinkOrd || a.hot.key == "" { + return "" + } + id, key, _ := strings.Cut(a.hot.key, "\x00") + if id == "" && key != "" { + return a.mentionChatHint(key) + } + t, ok := a.teamByID(id) + if !ok { + return "" + } + if key == "" { + if a.teamsOff() { + return "Show " + t.Name + " on the conversations view" + hintSegment + wallMembersWord(len(t.Members)) + hintSegment + "click" + } + return "Open " + t.Name + " on the teams page" + hintSegment + "click" + } + m, ok := t.Member(key) + if !ok { + return "" + } + return a.teamMemberHint(m) +} + +// teamLinkHintTitle is the most cells of a member's title the hint line spends. +const teamLinkHintTitle = 28 + +// teamLinkKey is a team reference's identity for the hover, from which the +// hint is read again off memory: the team, and the member when there is one. +func teamLinkKey(link taskLink) string { + if link.team == "" && link.member == "" { + return "" + } + return link.team + "\x00" + link.member +} diff --git a/internal/tui3/teammanager.go b/internal/tui3/teammanager.go new file mode 100644 index 0000000000..194638b894 --- /dev/null +++ b/internal/tui3/teammanager.go @@ -0,0 +1,388 @@ +package tui3 + +import ( + "path/filepath" + "strings" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE MANAGER: ONE CONVERSATION THE TEAM IS RUN FROM ───────────────────── +// +// A team may have one manager, recorded in the store as a member key +// ([teamstore.Team.Manager]). The person's words go to the manager, and the +// manager's to the members, through the Traffic log (teamtraffic.go). What is +// here is how the interface shows it and how a person makes one. +// +// THE MANAGER'S PLACE IS THE FIRST TAB. While a team narrows the strip, its +// first position is the manager: the manager's own tab, `◆ harbor`, named after +// the team rather than after its title, because it speaks for the team. Until +// the team has one, the place is a quiet `+ Manager`, a word button that costs +// nothing: no conversation exists behind it until it is pressed, and pressing it +// starts one, in the team's folder, as the manager ([app.teamManagerStart]). +// +// A MANAGER IS ALSO MADE FROM A MEMBER, and unmade. The strip's team switcher +// (teammenu.go) and a tile's Teams popover (wallpop.go) offer `Make manager` on a +// member of the team shown, and `Remove manager` on the manager, which leaves it +// an ordinary member. +// +// ON THE WALL the manager's tile is pinned first while its team is shown, and +// wears the same `◆` before its name. +// +// Everything a frame calls here reads memory only (framedisk_law_test.go); the +// writes are [app.teamEdit]'s. + +// teamManagerGlyph is the manager's mark, and its ASCII spelling. +const ( + teamManagerGlyph = "◆" + teamManagerGlyphASCII = "*" +) + +// teamManagerSlotWord is the manager's place while the team has none, and +// teamManagerWord what it says once there is one: `+ Manager` becomes +// `◆ Manager`, and the place never changes shape. It is named for what it is +// rather than for the team, because the chip beside it already names the team +// and `● harbor ▾ ◆ harbor` read as two harbors. +const ( + teamManagerSlotWord = "+ Manager" + teamManagerWord = "Manager" +) + +// teamManagerSlotFloor is the narrowest strip that offers `+ Manager`; under +// it the offer is the team switcher's alone. +const teamManagerSlotFloor = 100 + +// teamHostedWord is what the manager's doors say over --host when the engine +// has no teams doors ([app.teamsOff]): an engine from before them. The team's +// Traffic is written where the session runs, and this window's profile is not +// that one, so a manager made from here would talk into a log nobody reads. +// An engine with the doors answers for its own profile (teamseam.go), and +// then every door here works over --host as it does locally. +const teamHostedWord = "managers are not available over --host yet" + +// teamManagerMark is the manager's mark in this terminal's glyphs. +func (a *app) teamManagerMark() string { + if a.pal.ascii { + return teamManagerGlyphASCII + } + return a.linearMark(teamManagerGlyph, teamManagerGlyphASCII) +} + +// teamManaged is the team whose manager is key: the team shown when it is one, +// and otherwise the first in stored order. Frame-safe: memory only, and it +// allocates nothing, because the composer asks it on every frame. +func (a *app) teamManaged(key string) (team, bool) { + if !a.wall.loaded || key == "" { + return team{}, false + } + if t, ok := a.teamActive(); ok && t.Manager == key { + return t, true + } + for _, t := range a.wall.teams { + if t.Manager == key { + return t, true + } + } + return team{}, false +} + +// teamFrontManaged is the team the conversation in front manages. +func (a *app) teamFrontManaged() (team, bool) { + if !a.wall.loaded || len(a.wall.teams) == 0 { + return team{}, false + } + return a.teamManaged(a.frontTabKey()) +} + +// teamMakeManager makes the conversation tab team id's manager. It joins the +// team first when it is not a member, with its title, file and folder, and +// then takes the team's one manager's place, so a manager there before goes +// back to being an ordinary member. +func (a *app) teamMakeManager(id string, tab chatTab) error { + if tab.key == "" || tab.start || tab.work { + return nil + } + if a.teamsOff() { + a.note(teamHostedWord) + return nil + } + if _, err := a.teamAt(id); err != nil { + return err + } + m := teamFromTabs("", []chatTab{tab}, a.now()).Members + return a.teamEdit(func(f *teamstore.File) error { + if len(m) > 0 { + if err := f.AddMember(id, m[0]); err != nil { + return err + } + } + return f.SetManager(id, tab.key) + }) +} + +// teamClearManager leaves team id without a manager. The conversation stays in +// the team as an ordinary member, and nothing about it is ended. +func (a *app) teamClearManager(id string) error { + if _, err := a.teamAt(id); err != nil { + return err + } + return a.teamEdit(func(f *teamstore.File) error { return f.ClearManager(id) }) +} + +// teamToggleManager is `Make manager` or `Remove manager` on tab in team id, +// whichever it is. +func (a *app) teamToggleManager(id string, tab chatTab) error { + t, ok := a.teamByID(id) + if !ok { + return nil + } + if t.Manager != "" && t.Manager == tab.key { + return a.teamClearManager(id) + } + return a.teamMakeManager(id, tab) +} + +// teamWhere is the folder a new conversation for t opens in: its manager's, +// else the one its members share, else this window's. +func (a *app) teamWhere(t team) string { + if m, ok := t.Member(t.Manager); ok && strings.TrimSpace(m.Where) != "" { + return m.Where + } + where := "" + for _, m := range t.Members { + w := strings.TrimSpace(m.Where) + if w == "" { + continue + } + if where == "" { + where = filepath.Clean(w) + } else if filepath.Clean(w) != where { + where = "" + break + } + } + if where != "" { + return where + } + return a.workspace +} + +// teamStartIn opens a fresh conversation for team t, in its folder, and puts it +// in front, with the conversation that was there going on running behind. It +// says why when it could not. +func (a *app) teamStartIn(t team) (tea.Cmd, string) { + where := a.teamWhere(t) + if a.start != nil && strings.TrimSpace(where) != "" && where != a.workspace { + return a.startBeside(where) + } + if a.start != nil { + return a.startBeside(a.workspace) + } + cmd, ok := a.renew() + if !ok { + return nil, newUnavailableWord + } + return cmd, "" +} + +// teamManagerStart is `+ Manager` pressed: a new conversation, in the team's +// folder, made the team's manager. It is the one press that makes a manager out +// of nothing, and the conversation it opens is in front for the person's first +// words to it. +func (a *app) teamManagerStart() tea.Cmd { + t, ok := a.teamActive() + if !ok || t.Manager != "" { + return nil + } + if a.teamsOff() { + a.note(teamHostedWord) + return nil + } + // THE CONVERSATION IS OPENED ON THE DOOR LINE, off the loop, because + // opening one is a call to the engine; a window whose engine holds one + // conversation at a time, or that has no door beside, takes the one road it + // has, in place. + if a.start == nil || a.shared { + cmd, refusal := a.teamStartIn(t) + if refusal != "" { + a.note(refusal) + return nil + } + return tea.Batch(cmd, a.teamManagerTake(t.ID)) + } + if !a.canStart() { + a.note(newUnavailableWord) + return nil + } + start, where, id := a.start, a.teamWhere(t), t.ID + return a.besideLine(func() func(bool) tea.Cmd { + conv, err := start(where) + return func(bool) tea.Cmd { + if err != nil || conv.Agent == nil { + why := newUnavailableWord + if err != nil { + why = err.Error() + } + a.note(why) + return nil + } + return tea.Batch(a.takeBeside(conv), a.teamManagerTake(id)) + } + }) +} + +// teamManagerTake makes the conversation now in front team id's manager. +func (a *app) teamManagerTake(id string) tea.Cmd { + tab := chatTab{key: a.convKey(a.file), file: a.file, where: a.workspace} + if err := a.teamMakeManager(id, tab); err != nil { + a.note("the manager is set for this window, but " + err.Error()) + } + a.touch() + return nil +} + +// teamStripManager is t's members as the strip draws them, with the manager's +// place first: the manager's own tab named `◆ <team>`, or `+ Manager` while +// the team has none. tabs is [teamTabs]'s answer for t, and it is changed in +// place and returned. Frame-safe: memory only. +func (a *app) teamStripManager(t team, tabs []chatTab) []chatTab { + if t.Manager == "" { + slot := chatTab{word: teamManagerSlotWord, full: teamManagerSlotWord, slot: true, pinned: true} + return append([]chatTab{slot}, tabs...) + } + word := a.teamManagerMark() + " " + teamManagerWord + for i, tab := range tabs { + if tab.key != t.Manager { + continue + } + tab.full = tab.word + tab.word, tab.pinned = word, true + copy(tabs[1:i+1], tabs[:i]) + tabs[0] = tab + return tabs + } + // THE MANAGER IS DRAWN BEFORE IT HAS A TITLE. The strip draws no nameless + // tab ([app.tabList]), but the manager's tab is named for the team, so a + // manager just started, or closed before its first answer, still has its + // place: the conversation in front as itself, and one held behind from + // what the team kept. A manager this window does not have open gets no + // tab, as no member does ([teamTabs]); the wall's `Open them` resumes it. + m, _ := t.Member(t.Manager) + here := t.Manager == a.frontTabKey() + if !here && (m.File == "" || !a.teamHeldOpen(t.Manager)) { + return tabs + } + tab := chatTab{key: t.Manager, file: m.File, where: m.Where, word: word, full: m.Word, here: here, pinned: true} + if here { + tab.file, tab.where = a.file, a.workspace + } + return append([]chatTab{tab}, tabs...) +} + +// teamManagerTitle is what team t's manager is called, "" with none: its tab's +// title where this window has one, else what the team kept. +func (a *app) teamManagerTitle(t team) string { + if t.Manager == "" { + return "" + } + for _, tab := range a.chatTabs { + if tab.key == t.Manager && strings.TrimSpace(tab.word) != "" { + return tab.word + } + } + if t.Manager == a.frontTabKey() { + if name := a.conversationName(); name != unnamedConversationWord { + return name + } + } + if m, ok := t.Member(t.Manager); ok { + return m.Word + } + return "" +} + +// teamManagerMenuWord is the switcher's and the Teams popover's row for making +// or unmaking a manager, which says which team it acts on and what it replaces: +// `◆ Make this harbor's manager (replaces Shipping the parser)`, and on the +// manager itself `◇ Make an ordinary member`. +func (a *app) teamManagerMenuWord(t team, key string) string { + if t.Manager != "" && t.Manager == key { + mark := a.linearMark("◇", "o") + if a.pal.ascii { + mark = "o" + } + return mark + " Make an ordinary member" + } + word := a.teamManagerMark() + " Make this " + t.Name + "'s manager" + if title := a.teamManagerTitle(t); title != "" { + word += " (replaces " + fitConversationTitle(title, 24) + ")" + } + if a.teamsOff() { + word += " · not over --host" + } + return word +} + +// teamHoverWords is what the hint line says with the pointer on one of a +// team's doors: the manager's place on the strip, the team chip, and the +// Traffic's rows and words. "" anywhere else. +func (a *app) teamHoverWords() string { + // The move picker and a team's card, over whatever is drawn; a drag, the + // members card, and then the teams page's own buttons while it hosts the + // manager. + if a.tmove.on { + return a.teamMoveHint() + } + if a.tsheet.on { + return a.teamSheetHint() + } + if a.at(pageTeams) { + if words := a.teamDragHint(); words != "" { + return words + } + if a.tcrew.on { + return a.teamCrewHint() + } + } + if words := a.teamsPageHint(); words != "" { + return words + } + if words := a.sideHoverWords(); words != "" { + return words + } + if words := a.teamLinkHint(); words != "" { + return words + } + if words := a.threadHoverWords(); words != "" { + return words + } + hit, ok := a.hotTab() + if !ok { + return "" + } + t, shown := a.teamActive() + switch { + case hit.kind == tabTeam: + if !shown { + return "Show one team's conversations" + hintSegment + "click" + } + return "Switch team, add this conversation, or make a manager" + hintSegment + "click" + case hit.kind == tabManager: + if a.teamsOff() { + return teamHostedWord + } + return "Start a manager: a chat that runs " + t.Name + " for you" + hintSegment + "also in the " + a.linearMark("▾", "v") + " menu" + case hit.tab.pinned && shown && hit.tab.key == t.Manager && (hit.kind == tabHere || hit.kind == tabOther): + words := t.Name + "'s manager" + if title := a.teamManagerTitle(t); title != "" { + words += hintSegment + title + } + if hit.kind == tabOther { + words += hintSegment + teamManagerKey + } + return words + } + return "" +} diff --git a/internal/tui3/teammanager_test.go b/internal/tui3/teammanager_test.go new file mode 100644 index 0000000000..967c9a415e --- /dev/null +++ b/internal/tui3/teammanager_test.go @@ -0,0 +1,196 @@ +package tui3 + +import ( + "fmt" + "strings" + "testing" +) + +// stripHitKind is the first piece of kind on the last laid-out strip. +func stripHitKind(t *testing.T, a *app, kind tabKind) tabHit { + t.Helper() + for _, hit := range a.chatTabHits { + if hit.kind == kind { + return hit + } + } + t.Fatalf("no strip piece of kind %d on %q\n%+v", kind, plain(a.tabsRow(a.width)), a.chatTabHits) + return tabHit{} +} + +// THE MANAGER'S PLACE IS THE FIRST TAB. A team shown with no manager starts +// its run of tabs with a quiet `+ Manager`, which has no conversation behind it +// and no close cells. Pressed, it starts a conversation in the team's folder, +// which joins the team and becomes its manager, on disk as in the window, and +// the place then reads `◆ harbor` and is that conversation. +func TestTeamManagerSlotStartsAManager(t *testing.T) { + a, harbor := managerApp(t) + n := 0 + var where string + a.start = func(workspace string) (Conversation, error) { + n++ + where = workspace + return Conversation{Agent: &fakeAgent{model: "m"}, SessionFile: fmt.Sprintf("/tmp/lab/boss-%d.jsonl", n), Workspace: workspace}, nil + } + a.touch() + row := plain(a.tabsRow(a.width)) + slot := stripHitKind(t, a, tabManager) + if got := strings.TrimSpace(plainCells(row, slot.span.from, slot.span.to)); got != teamManagerSlotWord { + t.Fatalf("the manager's place reads %q on %q", got, row) + } + for _, hit := range a.chatTabHits { + if hit.kind == tabOther || hit.kind == tabHere { + if hit.span.from < slot.span.from { + t.Fatalf("a member is drawn before the manager's place: %q", row) + } + } + if hit.kind == tabClose && hit.tab.slot { + t.Fatal("the manager's empty place has close cells") + } + } + + cmd, took := a.tabPress(slot.span.from+1, tabStripRow) + if !took { + t.Fatal("the strip did not take the press") + } + // The conversation is opened on the door line, off the loop. + spend(t, a, cmd) + if n != 1 { + t.Fatalf("the press started %d conversations", n) + } + if where != "/tmp/lab" { + t.Fatalf("the manager was started in %q, not the team's folder", where) + } + boss := a.frontTabKey() + got := mustTeam(t, a, harbor) + if got.Manager != boss || !got.Holds(boss) { + t.Fatalf("the new conversation is not the manager: %q, %+v", got.Manager, got.Members) + } + teamsFlush(t, a) + disk, _ := loadTeams(a.profileDir, nil) + if len(disk) == 0 || disk[0].Manager != boss { + t.Fatalf("the manager did not reach the disk: %+v", disk) + } + + // The place is now the manager's own tab, named for the team. + a.touch() + row = plain(a.tabsRow(a.width)) + for _, hit := range a.chatTabHits { + if hit.kind == tabManager { + t.Fatalf("the empty place is still drawn beside a manager: %q", row) + } + } + first := tabHit{span: hudSpan{from: 1 << 30}} + for _, hit := range a.chatTabHits { + if (hit.kind == tabOther || hit.kind == tabHere) && hit.span.from < first.span.from { + first = hit + } + } + if first.tab.key != boss || !strings.Contains(row, teamManagerGlyph+" "+teamManagerWord) { + t.Fatalf("the first tab is %+v on %q, want the manager as ◆ Manager", first.tab, row) + } +} + +// managerApp is [menuApp] with its teams on a profile of the test's own. +func managerApp(t *testing.T) (*app, string) { + t.Helper() + a, harbor, _ := menuApp(t) + a.profileDir = t.TempDir() + if err := saveTeams(a.profileDir, a.wall.teams); err != nil { + t.Fatal(err) + } + return a, harbor +} + +// mustTeam is team id as the window holds it. +func mustTeam(t *testing.T, a *app, id string) team { + t.Helper() + got, ok := a.teamByID(id) + if !ok { + t.Fatalf("no team %s", id) + } + return got +} + +// plainCells is the plain cells from to to of a plain row. +func plainCells(row string, from, to int) string { + r := []rune(row) + if from < 0 || to > len(r) || from >= to { + return "" + } + return string(r[from:to]) +} + +// MAKE MANAGER AND REMOVE MANAGER ARE ONE ROW OF THE SWITCHER. On a member of +// the team shown it makes that conversation the manager; on the manager it +// reads Remove manager and leaves it an ordinary member. The menu stays up so +// the word is seen to flip. +func TestTeamMenuMakesAndRemovesTheManager(t *testing.T) { + a, harbor := managerApp(t) + front := a.frontTabKey() + if _, took := a.tabPress(a.wall.chip.from+1, tabStripRow); !took || !a.teamMenu.on { + t.Fatal("the chip did not open the switcher") + } + frame, _ := menuFrame(t, a) + if !strings.Contains(frame, teamManagerGlyph+" Make this harbor's manager") { + t.Fatalf("the switcher does not offer Make manager:\n%s", frame) + } + hit := menuHit(t, a, teamMenuManager, "") + _ = a.teamMenuPress(hit.x0+1, hit.y0) + if got := mustTeam(t, a, harbor); got.Manager != front { + t.Fatalf("Make manager left %q", got.Manager) + } + if !a.teamMenu.on { + t.Fatal("the switcher closed on Make manager") + } + frame, _ = menuFrame(t, a) + if !strings.Contains(frame, "Make an ordinary member") { + t.Fatalf("the row did not flip:\n%s", frame) + } + hit = menuHit(t, a, teamMenuManager, "") + _ = a.teamMenuPress(hit.x0+1, hit.y0) + got := mustTeam(t, a, harbor) + if got.Manager != "" || !got.Holds(front) { + t.Fatalf("Remove manager left manager %q, members %+v", got.Manager, got.Members) + } +} + +// ON THE WALL, A TILE'S TEAMS POPOVER CARRIES THE SAME ROW for its one +// conversation in the team shown, and the manager's tile is pinned first and +// marked. +func TestWallPopoverMakesTheManagerAndPinsItsTile(t *testing.T) { + a, harbor := managerApp(t) + _ = a.openWall() + tiles := a.wallShown(a.now()) + if len(tiles) < 2 { + t.Fatalf("the wall shows %d tiles of harbor", len(tiles)) + } + last := tiles[len(tiles)-1].tab + a.wallOpenMembers([]string{last.key}, wallPop{x: 2, y0: 2, y1: 3}) + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + if !strings.Contains(frame, teamManagerGlyph+" Make this harbor's manager") { + t.Fatalf("the popover does not offer Make manager:\n%s", frame) + } + var row wallHit + for _, h := range a.wall.hits { + if h.kind == wallHitPopRow && h.arg == wallPopManager { + row = h + } + } + if row.kind != wallHitPopRow { + t.Fatalf("no manager row among %+v", a.wall.hits) + } + _, _ = a.wallPress(row.x0+1, row.y0) + if got := mustTeam(t, a, harbor); got.Manager != last.key { + t.Fatalf("the popover's row left manager %q, want %q", got.Manager, last.key) + } + a.wall.pop = wallPop{} + tiles = a.wallShown(a.now()) + if tiles[0].tab.key != last.key || !tiles[0].manager { + t.Fatalf("the manager's tile is not pinned first: %+v", tiles[0].tab) + } + frame = wallPlainFrame(a.wallFrame(a.width, a.height)) + if !strings.Contains(frame, teamManagerGlyph+" "+teamManagerWord+" · ") { + t.Fatalf("the manager's tile is not titled ◆ Manager · <title>:\n%s", frame) + } +} diff --git a/internal/tui3/teammenu.go b/internal/tui3/teammenu.go new file mode 100644 index 0000000000..63dde51f2c --- /dev/null +++ b/internal/tui3/teammenu.go @@ -0,0 +1,465 @@ +package tui3 + +import ( + "strconv" + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── THE STRIP'S TEAM SWITCHER ─────────────────────────────────────────────── +// +// The chip at the strip's left end, ` ● harbor ▾ ` while a team narrows the +// strip, is the switcher: a press opens a small menu hung under it, on every +// page the strip is drawn on, the conversations view included. +// +// ╭─ Teams ──────────────────╮ +// │ ◉ ● harbor 3 │ +// │ ○ ● orbit 5 │ +// │ ○ All 12 │ +// │ ──────────────────────── │ +// │ + Add this conversation │ +// │ ◆ Make manager │ +// │ + New team… │ +// │ Team settings… │ +// ╰──────────────────────────╯ +// +// Choosing a team narrows the strip as the wall's segments do, and switches the +// conversation in front only when it is not a member ([app.teamActivate]). +// The rows under the rule act on the conversation in front: into or out of the +// team that is shown, a new team starting with it, or the shown team's settings, +// the last two on the wall, where teams are edited. `Make manager` makes a +// member the team's manager, and on the manager it reads `Remove manager` +// (teammanager.go). +// +// WITH NO TEAM SHOWN THE CHIP IS STILL THERE, AS A QUIET ` teams ▾ `, whenever +// there is a team to switch to. The strip is the one control on every page, +// and a switcher that appeared only once a team was already chosen could not be +// used to choose the first; with no team at all there is nothing to switch to +// and the chip takes no cells. +// +// It is modal as every menu is: while it is up it has the keyboard (↑ ↓ enter +// esc), and a press anywhere off it puts it away and does nothing else. It is +// drawn from memory alone; the teams were loaded on an opening (teamsEnsure). + +// teamMenu is the switcher's state: whether it is up, the row the keyboard is +// on, the row the pointer is on, and where the last frame drew it and its rows, +// in frame cells. +type teamMenu struct { + on bool + cursor int + hover wallHitRef + card wallRect + hits []wallHit +} + +// The switcher's rows that are not a team. A team's row is a wallHitPopRow +// with arg wallPopTeam and the team's id. +const ( + teamMenuAll = -10 // All + teamMenuToggle = -11 // + Add this conversation, or − Remove it + teamMenuNew = -12 // + New team… + teamMenuSettings = -13 // Team settings… + teamMenuManager = -14 // ◆ Make manager, or Remove manager + teamMenuClosed = -15 // Closed · N, folded, which opens the teams page +) + +// teamMenuRow is one row of the switcher, as the painter and the keys both +// read it. +type teamMenuRow struct { + code int + id string + rule bool + // depth is how far a team's row is indented: a sub-team stands under the + // team it is in, as it does on the teams page's rail. + depth int +} + +// teamMenuRows is the switcher's rows in order: each team, All, a rule, then +// the acts on the conversation in front. Add and settings are offered only +// while a team is shown, and Add only for a conversation that can be a member. +func (a *app) teamMenuRows() []teamMenuRow { + var rows []teamMenuRow + // THE TEAMS ARE THE TREE, each sub-team indented under its team, in the + // order the teams page's rail draws them (ruling c-12). + for _, r := range a.teamsOpenTree() { + rows = append(rows, teamMenuRow{code: wallPopTeam, id: r.id, depth: r.depth}) + } + rows = append(rows, teamMenuRow{code: teamMenuAll}) + // THE CLOSED TEAMS ARE ONE FOLDED ROW (ruling c-9), never a team on the + // switcher: a press opens the teams page with its Closed fold open. + if len(a.teamsClosed()) > 0 { + rows = append(rows, teamMenuRow{code: teamMenuClosed}) + } + rows = append(rows, teamMenuRow{rule: true}) + _, shown := a.teamActive() + if shown && a.frontTabKey() != "" { + rows = append(rows, teamMenuRow{code: teamMenuToggle}) + if t, _ := a.teamActive(); teamHolds(t, a.frontTabKey()) { + rows = append(rows, teamMenuRow{code: teamMenuManager}) + } + } + rows = append(rows, teamMenuRow{code: teamMenuNew}) + if shown { + rows = append(rows, teamMenuRow{code: teamMenuSettings}) + } + return rows +} + +// teamMenuPicks is the rows the keyboard can land on, the rule left out. +func teamMenuPicks(rows []teamMenuRow) []teamMenuRow { + out := rows[:0:0] + for _, r := range rows { + if !r.rule { + out = append(out, r) + } + } + return out +} + +// openTeamMenu puts the switcher up with the keyboard on the team that is +// shown, or on All. +func (a *app) openTeamMenu() { + a.teamsEnsure() + a.teamMenu = teamMenu{on: true} + picks := teamMenuPicks(a.teamMenuRows()) + for i, r := range picks { + if (r.code == wallPopTeam && r.id == a.wall.activeID) || (r.code == teamMenuAll && a.wall.activeID == "") { + a.teamMenu.cursor = i + break + } + } + a.touch() +} + +func (a *app) closeTeamMenu() { + a.teamMenu = teamMenu{} + a.touch() +} + +// teamMenuFront is the conversation in front as a member: its strip tab when +// the strip has one, and otherwise what this window knows of it. +func (a *app) teamMenuFront() chatTab { + key := a.frontTabKey() + for _, tab := range a.tabList() { + if tab.key == key { + return tab + } + } + return chatTab{key: key, file: a.file, where: a.workspace} +} + +// teamMenuDo is one row chosen, by the keyboard or the pointer. +func (a *app) teamMenuDo(r teamMenuRow) tea.Cmd { + switch r.code { + case wallPopTeam, teamMenuAll: + a.closeTeamMenu() + if a.wall.on { + // On the wall the choice is the wall's own segment's, which keeps + // each team's place and never switches the conversation in front. + a.wallSetTeam(r.id) + return nil + } + return a.teamActivate(r.id) + case teamMenuToggle: + // The menu stays up, so the row's word is seen to flip. + t, ok := a.teamActive() + if !ok { + return nil + } + if err := a.teamToggleMember(t.ID, a.teamMenuFront()); err != nil { + a.note("the team is changed for this window, but " + err.Error()) + } + a.touch() + return nil + case teamMenuManager: + // The menu stays up, so the row's word is seen to flip. + t, ok := a.teamActive() + if !ok { + return nil + } + if err := a.teamToggleManager(t.ID, a.teamMenuFront()); err != nil { + a.note("the manager is changed for this window, but " + err.Error()) + } + a.touch() + return nil + case teamMenuNew: + a.closeTeamMenu() + return a.teamMenuNewTeam() + case teamMenuClosed: + a.closeTeamMenu() + a.tp.closedOpen = true + return a.showPage(pageTeams) + case teamMenuSettings: + a.closeTeamMenu() + // The team's card, over whatever is drawn (teamsheet.go): its name, + // its colour, the settings it overrides and its close. + return a.teamSheetOpen(a.wall.activeID, teamSheetSettings) + } + return nil +} + +// teamMenuNewTeam opens the wall with the new-team card, the conversation in +// front already picked. A team shown that it is not a member of would hide its +// tile, so the wall widens to All first: the card makes a team of the tiles it +// can see. +func (a *app) teamMenuNewTeam() tea.Cmd { return a.teamMenuNewTeamIn("") } + +// teamMenuNewTeamIn is [app.teamMenuNewTeam] with the new team made inside +// team parent ("" the top level): the teams page's `+ New team in harbor`. A +// parent that cannot take one more level says why and opens nothing. +func (a *app) teamMenuNewTeamIn(parent string) tea.Cmd { + if parent != "" { + if ok, why := a.teamsCanNest(parent); !ok { + a.tp.msg = why + a.touch() + return nil + } + } + var open tea.Cmd + if !a.wall.on { + open = a.openWall() + } + front := a.frontTabKey() + if t, ok := a.teamActive(); ok && !teamHolds(t, front) { + a.wallSetTeam("") + } + tiles := a.wallShown(a.now()) + a.wall.marked = map[string]bool{} + for i, tile := range tiles { + if tile.tab.key == front { + a.wall.marked[front] = true + a.wallMove(i, len(tiles)) + } + } + naming := a.wallStartNaming(tiles) + a.wall.nameParent = parent + return tea.Batch(open, naming) +} + +// teamMenuKey is a key while the switcher is up: the arrows walk its rows, +// enter takes one, esc puts it away, and nothing else leaks to what is under +// it. +func (a *app) teamMenuKey(msg tea.KeyPressMsg) tea.Cmd { + picks := teamMenuPicks(a.teamMenuRows()) + m := &a.teamMenu + switch msg.String() { + case "esc": + a.closeTeamMenu() + case "up", "k": + m.cursor = max(m.cursor-1, 0) + a.touch() + case "down", "j": + m.cursor = min(m.cursor+1, len(picks)-1) + a.touch() + case "enter", "space": + if m.cursor >= 0 && m.cursor < len(picks) { + return a.teamMenuDo(picks[m.cursor]) + } + } + return nil +} + +// teamMenuHitAt is the switcher's row under the pointer on the last frame. +func (a *app) teamMenuHitAt(x, y int) (wallHit, bool) { + for _, hit := range a.teamMenu.hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit, true + } + } + return wallHit{}, false +} + +// teamMenuPress answers a left press while the switcher is up. A press on a +// row takes it; one on the card between rows does nothing; one anywhere else +// puts the switcher away and does nothing else, the chip included, so the +// chip that opened it also closes it. +func (a *app) teamMenuPress(x, y int) tea.Cmd { + if hit, ok := a.teamMenuHitAt(x, y); ok { + for _, r := range a.teamMenuRows() { + if !r.rule && r.code == hit.arg && r.id == hit.id { + return a.teamMenuDo(r) + } + } + return nil + } + if !a.teamMenu.card.holds(x, y) { + a.closeTeamMenu() + } + return nil +} + +// teamMenuMotion lights the row under the pointer. +func (a *app) teamMenuMotion(x, y int) { + hit, _ := a.teamMenuHitAt(x, y) + if ref := hit.ref(); ref != a.teamMenu.hover { + a.teamMenu.hover = ref + a.touch() + } +} + +// ── DRAWING IT ────────────────────────────────────────────────────────────── + +// teamMenuOver lays the switcher over a finished frame, under the chip, and +// writes down where its rows landed. With the switcher down it hands the frame +// back as it was given. +func (a *app) teamMenuOver(frame string) string { + if !a.teamMenu.on { + return frame + } + width, height := a.size() + card := a.teamMenuCard(width, height) + a.teamMenu.hits = card.hits + if len(card.rows) == 0 { + a.teamMenu.card = wallRect{} + return frame + } + a.teamMenu.card = wallRect{card.x, card.y, card.x + card.w, card.y + len(card.rows)} + rows := strings.Split(frame, "\n") + for len(rows) < height { + rows = append(rows, "") + } + for dy, cr := range card.rows { + if y := card.y + dy; y >= 0 && y < len(rows) { + rows[y] = wallSplice(rows[y], cr, card.x, width) + } + } + return strings.Join(rows[:height], "\n") +} + +// teamMenuCard is the switcher as a card, hung from the chip's first cell on +// the row under the strip, kept a cell inside the frame's sides, and not drawn +// on a frame too small to hold it whole. +func (a *app) teamMenuCard(width, height int) wallCard { + pal := a.pal + g := wallGlyphsFor(pal.ascii) + k := wallKeysFor(pal.ascii) + on, off := "◉", pal.glyph(tokens.GEmptyCell) + if pal.ascii { + on, off = "*", "o" + } + rows := a.teamMenuRows() + picks := teamMenuPicks(rows) + lit := func(r teamMenuRow) bool { + if a.teamMenu.hover == (wallHitRef{kind: wallHitPopRow, arg: r.code, id: r.id}) { + return true + } + c := a.teamMenu.cursor + return c >= 0 && c < len(picks) && picks[c].code == r.code && picks[c].id == r.id + } + + // The counts are of open conversations, as the wall's are. + open := map[string]bool{} + for _, tab := range a.tabList() { + if !tab.start && !tab.work { + open[tab.key] = true + } + } + type line struct { + row teamMenuRow + left, right string + leftW int + } + var lines []line + front := a.frontTabKey() + shown, _ := a.teamActive() + for _, r := range rows { + ln := line{row: r} + switch r.code { + case wallPopTeam: + t, _ := a.teamByID(r.id) + radio := off + if t.ID == a.wall.activeID { + radio = on + } + name := t.Name + if ansi.StringWidth(name) > wallChipCap { + name = ansi.Truncate(name, wallChipCap, g.more) + } + n := 0 + for _, m := range t.Members { + if open[m.Key] { + n++ + } + } + indent := strings.Repeat(" ", min(r.depth, 4)) + ln.left = pal.ink(radio) + " " + indent + a.tabTeamDot(t) + " " + pal.ink(name) + ln.leftW = ansi.StringWidth(radio) + 3 + len(indent) + ansi.StringWidth(name) + ln.right = strconv.Itoa(n) + case teamMenuAll: + radio := off + if a.wall.activeID == "" { + radio = on + } + ln.left = pal.ink(radio) + " " + pal.ink("All") + ln.leftW = ansi.StringWidth(radio) + 3 + 3 + ln.right = strconv.Itoa(len(open)) + case teamMenuClosed: + word := "Closed " + a.teamsDot() + " " + strconv.Itoa(len(a.teamsClosed())) + " " + a.linearMark("▸", ">") + ln.left = strings.Repeat(" ", ansi.StringWidth(off)+3) + pal.dim(word) + ln.leftW = ansi.StringWidth(off) + 3 + ansi.StringWidth(word) + case teamMenuToggle: + word := "+ Add this conversation" + if teamHolds(shown, front) { + word = "− Remove this conversation" + if pal.ascii { + word = "- Remove this conversation" + } + } + ln.left, ln.leftW = pal.ink(word), ansi.StringWidth(word) + case teamMenuManager: + word := a.teamManagerMenuWord(shown, front) + ln.left, ln.leftW = pal.ink(word), ansi.StringWidth(word) + if a.teamsOff() { + ln.left = pal.dim(word) + } + case teamMenuNew: + word := "+ New team" + k.more + ln.left, ln.leftW = pal.ink(word), ansi.StringWidth(word) + case teamMenuSettings: + word := " Team settings" + k.more + ln.left, ln.leftW = pal.ink(word), ansi.StringWidth(word) + } + lines = append(lines, ln) + } + // The inner width fits the widest row with its count a cell from the + // border, and never less than the brief's own drawing. + inner := 24 + for _, ln := range lines { + if ln.row.rule { + continue + } + w := ln.leftW + if ln.right != "" { + w += 2 + len(ln.right) + 1 + } + inner = max(inner, w) + } + const padX = 1 + w := inner + 2 + 2*padX + h := len(lines) + 2 + top := tabStripRow + 1 + if w > width-2 || top+h > height { + return wallCard{} + } + x := min(max(a.wall.chip.from, 1), width-1-w) + var cardLines []wallCardLine + for _, ln := range lines { + if ln.row.rule { + cardLines = append(cardLines, wallCardLine{rule: true}) + continue + } + s := ln.left + if ln.right != "" { + s += strings.Repeat(" ", max(inner-ln.leftW-len(ln.right)-1, 1)) + pal.dim(ln.right) + " " + } + cardLines = append(cardLines, wallCardLine{ + s: wallPopRowPaint(pal, s, inner, lit(ln.row)), + hits: []wallHit{{x0: 0, y0: 0, x1: inner, y1: 1, kind: wallHitPopRow, arg: ln.row.code, id: ln.row.id}}, + }) + } + return wallCardBuild(pal, "Teams", cardLines, x, top, w, padX, 0) +} diff --git a/internal/tui3/teammenu_test.go b/internal/tui3/teammenu_test.go new file mode 100644 index 0000000000..ed4ac0fc57 --- /dev/null +++ b/internal/tui3/teammenu_test.go @@ -0,0 +1,288 @@ +package tui3 + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" +) + +// menuApp is the strip's three conversations with two teams, harbor holding +// the conversation in front and orbit holding one behind it, and harbor shown. +func menuApp(t *testing.T) (a *app, harbor, orbit string) { + t.Helper() + a, _, _ = tabApp(t) + tabs := a.tabList() + front := a.frontTabKey() + var here, behind []chatTab + for _, tab := range tabs { + if tab.key == front { + here = append(here, tab) + } else { + behind = append(behind, tab) + } + } + if len(here) != 1 || len(behind) < 2 { + t.Fatalf("the fixture's strip: %+v", tabs) + } + var err error + if harbor, err = a.teamMake("harbor", []chatTab{here[0], behind[0]}); err != nil { + t.Fatal(err) + } + if orbit, err = a.teamMake("orbit", behind[1:2]); err != nil { + t.Fatal(err) + } + a.teamActivate(harbor) + a.touch() + _ = a.tabsRow(a.width) + return a, harbor, orbit +} + +// menuFrame is the whole frame, plain, and its rows. +func menuFrame(t *testing.T, a *app) (string, []string) { + t.Helper() + frame, _, _ := a.frame() + rows := strings.Split(frame, "\n") + if len(rows) != a.height { + t.Fatalf("the frame has %d rows, want %d", len(rows), a.height) + } + for i, r := range rows { + if w := ansi.StringWidth(r); w > a.width { + t.Fatalf("row %d is %d cells, wider than %d: %q", i, w, a.width, ansi.Strip(r)) + } + } + return ansi.Strip(frame), rows +} + +// menuHit is the switcher's row with code (and id, for a team) on the last +// frame. +func menuHit(t *testing.T, a *app, code int, id string) wallHit { + t.Helper() + for _, hit := range a.teamMenu.hits { + if hit.arg == code && hit.id == id { + return hit + } + } + t.Fatalf("no switcher row %d/%q in %+v", code, id, a.teamMenu.hits) + return wallHit{} +} + +// THE CHIP IS THE SWITCHER, ON THE CHAT AS ON THE WALL. A press opens a menu +// under it with every team, All, and what can be done with the conversation +// in front; its rows lie on their words, never overlap, and the frame keeps its +// size; the keyboard walks it and a choice narrows the strip without leaving +// the conversation in front when it is a member. +func TestTeamMenuIsTheStripsSwitcher(t *testing.T) { + a, harbor, orbit := menuApp(t) + front := a.frontTabKey() + if _, took := a.tabPress(a.wall.chip.from+1, tabStripRow); !took || !a.teamMenu.on { + t.Fatal("the chip did not open the switcher") + } + frame, rows := menuFrame(t, a) + for _, want := range []string{"╭─ Teams ─", "◉ ● harbor", "○ ● orbit", "○ All", "− Remove this conversation", "+ New team…", " Team settings…"} { + if !strings.Contains(frame, want) { + t.Fatalf("the switcher lacks %q\n%s", want, frame) + } + } + card := a.teamMenu.card + if card.y0 != tabStripRow+1 || card.x0 != a.wall.chip.from { + t.Fatalf("the switcher hangs at %+v, the chip is at %+v", card, a.wall.chip) + } + for i, h := range a.teamMenu.hits { + label := strings.TrimSpace(ansi.Strip(ansi.Cut(rows[h.y0], h.x0, h.x1))) + if label == "" || h.x0 < card.x0 || h.x1 > card.x1 { + t.Fatalf("row %d's target is on %q at %+v, outside %+v", i, label, h, card) + } + for _, o := range a.teamMenu.hits[i+1:] { + if h.y0 == o.y0 && h.x0 < o.x1 && o.x0 < h.x1 { + t.Fatalf("two targets overlap: %+v %+v", h, o) + } + } + } + t.Logf("the switcher open over the chat, 160x40:\n%s", strings.Join(strings.Split(frame, "\n")[:12], "\n")) + + // The keyboard is on harbor; down is orbit, enter takes it. orbit does + // not hold the conversation in front, so the switch is to its member. + a.teamMenuKey(tea.KeyPressMsg{Code: tea.KeyDown}) + a.teamMenuKey(tea.KeyPressMsg{Code: tea.KeyEnter}) + if a.teamMenu.on || a.wall.activeID != orbit { + t.Fatalf("enter on orbit: menu %v, active %q", a.teamMenu.on, a.wall.activeID) + } + if o, _ := a.teamByID(orbit); !teamHolds(o, a.frontTabKey()) { + t.Fatal("orbit does not hold the conversation in front, and nothing switched to its member") + } + // Back to harbor by the pointer: harbor holds this one too, so nothing + // switches. + front = a.frontTabKey() + if err := a.teamAdd(harbor, []chatTab{a.teamMenuFront()}); err != nil { + t.Fatal(err) + } + a.openTeamMenu() + _, _ = menuFrame(t, a) + hit := menuHit(t, a, wallPopTeam, harbor) + if cmd := a.teamMenuPress(hit.x0+2, hit.y0); cmd != nil || a.wall.activeID != harbor || a.frontTabKey() != front { + t.Fatalf("choosing harbor switched the conversation in front: active %q", a.wall.activeID) + } + // All widens the strip. + a.openTeamMenu() + _, _ = menuFrame(t, a) + hit = menuHit(t, a, teamMenuAll, "") + a.teamMenuPress(hit.x0+2, hit.y0) + if a.wall.activeID != "" { + t.Fatalf("All left %q shown", a.wall.activeID) + } +} + +// ADD FLIPS TO REMOVE. The row puts the conversation in front into the team +// that is shown and takes it out again, saved, with the menu still up. +func TestTeamMenuAddsAndRemovesTheFrontConversation(t *testing.T) { + a, _, orbit := menuApp(t) + front := a.frontTabKey() + a.teamActivate(orbit) + // orbit does not hold what was in front, so the activation switched; come + // back to it with orbit still shown. + a.wall.activeID = "" + for _, tab := range a.tabList() { + if tab.key == front { + _ = a.tabGo(tab) + } + } + a.wall.activeID = orbit + a.openTeamMenu() + frame, _ := menuFrame(t, a) + if !strings.Contains(frame, "+ Add this conversation") { + t.Fatalf("no Add row:\n%s", frame) + } + hit := menuHit(t, a, teamMenuToggle, "") + a.teamMenuPress(hit.x0+1, hit.y0) + if got := a.teamsOf(a.frontTabKey()); len(got) != 2 || !a.teamMenu.on { + t.Fatalf("after Add the conversation is in %v, menu %v", got, a.teamMenu.on) + } + if frame, _ = menuFrame(t, a); !strings.Contains(frame, "− Remove this conversation") { + t.Fatalf("the row did not flip:\n%s", frame) + } + teamsFlush(t, a) + disk, _ := loadTeams(a.profileDir, nil) + saved := false + for _, tm := range disk { + if tm.ID == orbit && teamHolds(tm, a.frontTabKey()) { + saved = true + } + } + if !saved { + t.Fatal("the Add was not saved") + } + hit = menuHit(t, a, teamMenuToggle, "") + a.teamMenuPress(hit.x0+1, hit.y0) + if got := a.teamsOf(a.frontTabKey()); len(got) != 1 { + t.Fatalf("after Remove the conversation is in %v", got) + } +} + +// A PRESS OFF THE MENU PUTS IT AWAY AND DOES NOTHING ELSE; esc does the same, +// and while it is up no key reaches the box under it. +func TestTeamMenuClosesOnAPressOffItAndOnEsc(t *testing.T) { + a, harbor, _ := menuApp(t) + a.openTeamMenu() + _, _ = menuFrame(t, a) + box := a.input.String() + _, _ = a.Update(tea.KeyPressMsg{Code: 'x', Text: "x"}) + if a.input.String() != box || !a.teamMenu.on { + t.Fatal("a key typed under the switcher") + } + _, _ = a.Update(tea.MouseClickMsg{X: a.width - 2, Y: a.height - 3, Button: tea.MouseLeft}) + if a.teamMenu.on || a.wall.activeID != harbor || a.wall.on { + t.Fatalf("a press off the switcher: menu %v, active %q", a.teamMenu.on, a.wall.activeID) + } + a.openTeamMenu() + _, _ = a.Update(tea.KeyPressMsg{Code: tea.KeyEscape}) + if a.teamMenu.on { + t.Fatal("esc did not close the switcher") + } + // The chip that opened it closes it. + a.openTeamMenu() + _, _ = menuFrame(t, a) + _, _ = a.Update(tea.MouseClickMsg{X: a.wall.chip.from + 1, Y: tabStripRow, Button: tea.MouseLeft}) + if a.teamMenu.on { + t.Fatal("the chip did not close its own switcher") + } +} + +// NEW TEAM AND TEAM SETTINGS OPEN THE WALL WHERE TEAMS ARE EDITED: the card +// with the conversation in front already picked, or the shown team's settings. +func TestTeamMenuOpensTheCardAndTheSettings(t *testing.T) { + a, harbor, _ := menuApp(t) + front := a.frontTabKey() + a.openTeamMenu() + _, _ = menuFrame(t, a) + hit := menuHit(t, a, teamMenuNew, "") + a.teamMenuPress(hit.x0+1, hit.y0) + if !a.wall.on || !a.wall.naming || !a.wall.marked[front] || len(a.wall.marked) != 1 { + t.Fatalf("New team: wall %v naming %v marked %v", a.wall.on, a.wall.naming, a.wall.marked) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + a.closeWall() + + a.openTeamMenu() + _, _ = menuFrame(t, a) + hit = menuHit(t, a, teamMenuSettings, "") + a.teamMenuPress(hit.x0+1, hit.y0) + if !a.tsheet.on || a.tsheet.mode != teamSheetSettings || a.tsheet.team != harbor { + t.Fatalf("Team settings: card %+v", a.tsheet) + } + // And on the wall the chip is the switcher too. + a.tsheet = teamSheet{} + if !a.wall.on { + _ = a.openWall() + } + _, _ = menuFrame(t, a) + if _, took := a.wallPress(a.wall.chip.from+1, tabStripRow); !took || !a.teamMenu.on { + t.Fatal("the chip on the wall did not open the switcher") + } + if frame, _ := menuFrame(t, a); !strings.Contains(frame, "╭─ Teams ─") { + t.Fatalf("the switcher is not drawn over the wall:\n%s", frame) + } +} + +// WITH NO TEAM SHOWN THE CHIP IS A QUIET `teams ▾` while there are teams, and +// is not there at all while there are none. +func TestTeamMenuQuietChipWithNoTeamShown(t *testing.T) { + a, _, _ := tabApp(t) + a.teamsEnsure() + if row := plain(a.tabsRow(a.width)); strings.Contains(row, "▾") { + t.Fatalf("a chip with no teams: %q", row) + } + a, _, _ = menuApp(t) + a.teamActivate("") + a.touch() + row := plain(a.tabsRow(a.width)) + if !strings.Contains(row, " teams ▾ ") || !a.wall.chip.pressable() { + t.Fatalf("no quiet chip: %q", row) + } + if _, took := a.tabPress(a.wall.chip.from+1, tabStripRow); !took || !a.teamMenu.on { + t.Fatal("the quiet chip did not open the switcher") + } + frame, _ := menuFrame(t, a) + if !strings.Contains(frame, "◉ All") || strings.Contains(frame, "Add this conversation") || strings.Contains(frame, "Team settings") { + t.Fatalf("the switcher with no team shown:\n%s", frame) + } + a.pal.ascii = true + a.touch() + frame, _ = menuFrame(t, a) + if !strings.Contains(frame, "* All") || strings.ContainsAny(frame, "◉○") { + t.Fatalf("the ASCII switcher:\n%s", frame) + } +} + +// TestTeamMenuPrintsFrame prints the strip with the switcher open, on a +// 120-column chat, for a person to look at. +func TestTeamMenuPrintsFrame(t *testing.T) { + a, _, _ := menuApp(t) + a.width, a.height = 120, 30 + a.touch() + _ = a.tabsRow(a.width) + a.openTeamMenu() + frame, _ := menuFrame(t, a) + t.Logf("120x30, the chat with the team switcher open:\n%s", strings.Join(strings.Split(frame, "\n")[:14], "\n")) +} diff --git a/internal/tui3/teammove.go b/internal/tui3/teammove.go new file mode 100644 index 0000000000..22f967322b --- /dev/null +++ b/internal/tui3/teammove.go @@ -0,0 +1,817 @@ +package tui3 + +import ( + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── MOVE INTO…: PUTTING A TEAM INSIDE ANOTHER (rulings c-12, c-13) ────────── +// +// A team is moved by choosing where it goes, never by indenting it: `m` on a +// team row of the teams page's rail (or on the teams picked with `space`), and +// `Inside: harbor ▾` on the team's card, open the same picker: +// +// ╭─ Move api into ───────────────────────────────╮ +// │ Filter ha▏ │ +// │ ──────────────────────────────────────────── │ +// │ Top level │ +// │ ● harbor │ +// │ ● dock (dim: past the depth limit)│ +// │ ──────────────────────────────────────────── │ +// │ dock is 2 levels deep · limit 2 · Settings │ +// ╰───────────────────────────────────────────────╯ +// +// EVERY TEAM IS A ROW, AND A ROW THAT CANNOT TAKE THE MOVE IS DIMMED WITH ITS +// REASON, not hidden: the team itself, a team under it, a closed team, one too +// deep for the depth limit, the place it already is. Hiding them would leave a +// person looking for harbor and not finding it; a dim row with its reason in +// the foot says why at the moment they look. The reasons are the store's +// ([teamstore.File.MoveCheck]); the words are here. +// +// TYPING FILTERS, THE TREE STAYS A TREE. The picker has one box and every +// printable key goes into it, so the arrows walk and nothing else does; a +// filtered row keeps its indent, so `api` under two teams called api is still +// told apart by where it stands. +// +// A MOVE THAT CHANGES WHO DECIDES ASKS FIRST, ONE LINE ([app.teamMoveAsk]). +// When the move would give the teams' conversations another manager to report +// to, put their spend in another capped pool, or send their conflicts to +// another manager, one line says so with `Move` and `Cancel`; every other move +// is made at once. Either way the move is offered back with `Undo` for the +// same six seconds a close is, because a move made by a slip of the pointer is +// still a slip. +// +// THE WRITE IS AN ORDINARY EDIT ([app.teamEdit]), made twice and written off +// the loop through the teams seam, so it reaches the session's own file over +// --host too. Nothing here reads a disk or a wire, and the frame draws from +// what the window holds. + +// Where a move was asked from, which is where its question and its Undo are +// drawn: the teams page's pane, or the team's card. +const ( + teamMoveFromPage = iota + teamMoveFromCard +) + +// teamMoveTop is the picker's `Top level` row, and a drop on the empty rail +// under the tree. +const teamMoveTop = "\x00top" + +// teamMove is the picker, a move waiting on the person's word, and the last +// move for Undo. +type teamMove struct { + on bool + // ids are the teams being moved, from is where it was asked. + ids []string + from int + // filter is the box; cursor the row the keyboard is on and hot the one + // under the pointer (-1 none), both by the row's parent id, so a filter + // that moved the rows keeps them on the same team. + filter editor + cursor, hot string + // top is the first row drawn when the rows are more than the card holds. + top int + // rect and hits are where the last frame drew it, in frame cells. + rect wallRect + hits []wallHit + // pend is a move whose consequence line is up; undo the last move made. + pend teamMovePend + undo teamMoveUndo +} + +// teamMovePend is a move waiting on `Move` or `Cancel`. +type teamMovePend struct { + ids []string + parent string + words string + from int +} + +// teamMoveUndo is the last move, while Undo is offered: every moved team's +// parent before it, and every carried conversation's home team before it. +type teamMoveUndo struct { + back map[string]string + homes map[string]string + word string + from int + at time.Time +} + +// teamMoveRow is one row of the picker: a parent (teamMoveTop for the top +// level), how deep it is drawn, and whether it can take the move and why not. +type teamMoveRow struct { + parent string + depth int + name string + t team + ok bool + why string +} + +// ── WHAT A MOVE IS CALLED ─────────────────────────────────────────────────── + +// teamMoveSubject is what is being moved, as a sentence names it: the team's +// name, or `3 teams`. +func (a *app) teamMoveSubject(ids []string) string { + roots := a.teamTree().MoveRoots(ids) + if len(roots) == 1 { + if t, ok := a.teamByID(roots[0]); ok { + return t.Name + } + } + return itoa(len(roots)) + " teams" +} + +// teamNameOf is team id's name as a sentence says it: `All teams` for the root, +// "" for none. +func (a *app) teamNameOf(id string) string { + t, ok := a.teamByID(id) + if !ok { + return "" + } + if t.Root { + return teamstore.RootName + } + return t.Name +} + +// teamMoveWhy is a block as the hint line says it. +// +// harbor is 3 levels deep · limit 3 · Settings +func (a *app) teamMoveWhy(b teamstore.MoveBlock, ids []string, target string) string { + subject := a.teamMoveSubject(ids) + dot := " " + a.teamsDot() + " " + switch b.Kind { + case teamstore.MoveBlockSelf: + return "a team cannot go inside itself" + case teamstore.MoveBlockInside: + return a.teamNameOf(target) + " is inside " + b.Name + case teamstore.MoveBlockClosed: + return b.Name + " is closed" + case teamstore.MoveBlockHere: + if b.Name == "" || target == teamMoveTop { + return subject + " is at the top level already" + } + return subject + " is in " + b.Name + " already" + case teamstore.MoveBlockRoot: + return teamstore.RootName + " holds every team and does not move" + case teamstore.MoveBlockDepth: + levels := func(n int) string { + if n == 1 { + return "1 level" + } + return itoa(n) + " levels" + } + from := "Settings" + switch b.LimitFrom.Kind { + case teamstore.OriginTeam, teamstore.OriginAncestor: + from = "set on " + b.LimitFrom.Name + } + words := b.Name + " is " + levels(b.Depth) + " deep" + dot + "limit " + itoa(b.Limit) + dot + from + if b.Need > 1 { + words = subject + " takes " + levels(b.Need) + dot + words + } + return words + } + return "that team is gone" +} + +// teamMoveParent is the parent a row or a drop names, as the store takes it: +// "" for the top level. +func teamMoveParent(parent string) string { + if parent == teamMoveTop { + return "" + } + return parent +} + +// teamMoveCheck is whether ids may go into parent (a team id or +// [teamMoveTop]) and, when not, the reason in words. Frame-safe: memory only. +func (a *app) teamMoveCheck(ids []string, parent string) (bool, string) { + b, ok := a.teamTree().MoveCheck(ids, teamMoveParent(parent), a.tp.defaults) + if ok { + return true, "" + } + return false, a.teamMoveWhy(b, ids, parent) +} + +// teamMoveDoing is the sentence for a move that can be made: `Move api into +// harbor`, `Move api to the top level`. +func (a *app) teamMoveDoing(ids []string, parent string) string { + subject := a.teamMoveSubject(ids) + if parent == teamMoveTop || parent == "" { + return "Move " + subject + " to the top level" + } + return "Move " + subject + " into " + a.teamNameOf(parent) +} + +// ── THE PICKER ────────────────────────────────────────────────────────────── + +// teamMoveOpen puts the picker up for ids, asked from where. +func (a *app) teamMoveOpen(ids []string, from int) tea.Cmd { + a.teamsEnsure() + if a.teamsOff() { + a.tp.msg = teamHostedWord + a.touch() + return nil + } + var keep []string + for _, id := range ids { + if t, ok := a.teamByID(id); ok && !t.Root && !t.Closed() { + keep = append(keep, id) + } + } + if len(keep) == 0 { + return nil + } + a.tmove.on, a.tmove.ids, a.tmove.from = true, keep, from + a.tmove.filter.reset() + a.tmove.hot, a.tmove.top = "", 0 + a.tmove.pend = teamMovePend{} + // The keyboard starts on the first row the teams can go to. + a.tmove.cursor = "" + for _, r := range a.teamMoveRows() { + if r.ok { + a.tmove.cursor = r.parent + break + } + } + a.touch() + if !a.tp.defaultsOK { + return a.teamsRead(false) + } + return nil +} + +// teamMoveShut puts the picker away. +func (a *app) teamMoveShut() { + a.tmove.on, a.tmove.hits, a.tmove.rect = false, nil, wallRect{} + a.touch() +} + +// teamMoveRows is the picker's rows: `Top level`, then every open team but the +// root in tree order, each with whether it can take the move; with a filter, +// only the rows whose name holds it. Frame-safe: memory only. +func (a *app) teamMoveRows() []teamMoveRow { + ids := a.tmove.ids + want := strings.ToLower(strings.TrimSpace(a.tmove.filter.String())) + var out []teamMoveRow + add := func(parent, name string, depth int, t team) { + if want != "" && !strings.Contains(strings.ToLower(name), want) { + return + } + ok, why := a.teamMoveCheck(ids, parent) + out = append(out, teamMoveRow{parent: parent, depth: depth, name: name, t: t, ok: ok, why: why}) + } + add(teamMoveTop, "Top level", 0, team{}) + for _, r := range a.teamsOpenTree() { + t, _ := a.teamByID(r.id) + add(t.ID, t.Name, r.depth+1, t) + } + return out +} + +// teamMoveKey is a key while the picker is up: it has the whole keyboard. +func (a *app) teamMoveKey(msg tea.KeyPressMsg) tea.Cmd { + rows := a.teamMoveRows() + at := -1 + for i, r := range rows { + if r.parent == a.tmove.cursor { + at = i + } + } + a.touch() + switch msg.String() { + case "esc": + a.teamMoveShut() + return nil + case "up": + if len(rows) > 0 { + a.tmove.cursor = rows[max(at-1, 0)].parent + } + return nil + case "down": + if len(rows) > 0 { + a.tmove.cursor = rows[min(at+1, len(rows)-1)].parent + } + return nil + case "enter": + if at >= 0 { + return a.teamMoveChoose(rows[at]) + } + return nil + case "backspace": + a.tmove.filter.deleteBackward() + default: + text := msg.Key().Text + if text == "" { + return nil + } + a.tmove.filter.insert(text) + } + // The filter moved the rows: the cursor goes to the first that can take + // the move, or the first at all. + a.tmove.top = 0 + rows = a.teamMoveRows() + a.tmove.cursor = "" + for _, r := range rows { + if r.ok { + a.tmove.cursor = r.parent + break + } + } + if a.tmove.cursor == "" && len(rows) > 0 { + a.tmove.cursor = rows[0].parent + } + return nil +} + +// teamMoveChoose is a row chosen: a row that cannot take the move says why and +// stays up; one that can closes the picker and asks, or moves. +func (a *app) teamMoveChoose(r teamMoveRow) tea.Cmd { + a.tmove.cursor = r.parent + if !r.ok { + a.touch() + return nil + } + ids, from := a.tmove.ids, a.tmove.from + a.teamMoveShut() + return a.teamMoveAsk(ids, r.parent, from) +} + +// teamMoveHitAt is the picker's row under the pointer. +func (a *app) teamMoveHitAt(x, y int) (wallHit, bool) { + for _, hit := range a.tmove.hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit, true + } + } + return wallHit{}, false +} + +// teamMovePress is a left press while the picker is up: a row is chosen, the +// card between rows does nothing, and off the card the picker goes away. +func (a *app) teamMovePress(x, y int) tea.Cmd { + if hit, ok := a.teamMoveHitAt(x, y); ok { + for _, r := range a.teamMoveRows() { + if r.parent == hit.id { + return a.teamMoveChoose(r) + } + } + return nil + } + if !a.tmove.rect.holds(x, y) { + a.teamMoveShut() + } + return nil +} + +// teamMoveMotion lights the row under the pointer. +func (a *app) teamMoveMotion(x, y int) { + hot := "" + if hit, ok := a.teamMoveHitAt(x, y); ok { + hot = hit.id + } + if hot != a.tmove.hot { + a.tmove.hot = hot + a.touch() + } +} + +// teamMoveHint is what the hint line says while the picker is up: the row +// under the pointer, else the cursor's, with what enter does or why it cannot. +func (a *app) teamMoveHint() string { + r, ok := a.teamMoveFocus() + if !ok { + return "type to filter · esc cancel" + } + if !r.ok { + return r.why + hintSegment + "esc cancel" + } + return a.teamMoveDoing(a.tmove.ids, r.parent) + hintSegment + "enter" + hintSegment + "esc cancel" +} + +// teamMoveFocus is the row the hint speaks for: under the pointer, else the +// cursor's. +func (a *app) teamMoveFocus() (teamMoveRow, bool) { + rows := a.teamMoveRows() + for _, want := range []string{a.tmove.hot, a.tmove.cursor} { + if want == "" { + continue + } + for _, r := range rows { + if r.parent == want { + return r, true + } + } + } + return teamMoveRow{}, false +} + +// teamMoveOver lays the picker over a finished frame. +func (a *app) teamMoveOver(frame string) string { + if !a.tmove.on { + return frame + } + width, height := a.width, a.height + card := a.teamMoveCard(width, height) + a.tmove.hits = card.hits + if len(card.rows) == 0 { + a.tmove.rect = wallRect{} + return frame + } + a.tmove.rect = wallRect{card.x, card.y, card.x + card.w, card.y + len(card.rows)} + rows := strings.Split(frame, "\n") + for len(rows) < height { + rows = append(rows, "") + } + for dy, cr := range card.rows { + if y := card.y + dy; y >= 0 && y < len(rows) { + rows[y] = wallSplice(rows[y], cr, card.x, width) + } + } + return strings.Join(rows[:height], "\n") +} + +// teamMoveCard is the picker as a card, centred, a third of the way down. +func (a *app) teamMoveCard(width, height int) wallCard { + pal := a.pal + inner := min(max(width-12, 30), 52) + rows := a.teamMoveRows() + // The rows the card holds: the frame less the border, the padding, the + // filter, two rules and the foot. + room := max(height-2-2*wallCardPadY-5, 3) + at := 0 + for i, r := range rows { + if r.parent == a.tmove.cursor { + at = i + } + } + top := min(a.tmove.top, max(len(rows)-room, 0)) + if at < top { + top = at + } + if at >= top+room { + top = at - room + 1 + } + a.tmove.top = top + var lines []wallCardLine + box := a.tmove.filter.String() + field := pal.ink(box) + pal.ink(a.linearMark("▏", "|")) + if box == "" { + field = pal.ink(a.linearMark("▏", "|")) + pal.dim("type to filter") + } + lines = append(lines, wallCardLine{s: pal.dim(teamsPad("Filter", 10)) + field}, wallCardLine{rule: true}) + if len(rows) == 0 { + lines = append(lines, wallCardLine{s: pal.dim("no team is called that")}) + } + for _, r := range rows[top:min(top+room, len(rows))] { + text := strings.Repeat(" ", r.depth) + if r.parent == teamMoveTop { + text += r.name + } else { + name := r.name + if ansi.StringWidth(name) > teamNameCells { + name = ansi.Truncate(name, teamNameCells, a.linearMark("…", "~")) + } + text += a.tabTeamDot(r.t) + " " + name + } + if r.ok { + text = pal.ink(text) + } else { + text = pal.dim(ansi.Strip(text)) + } + lit := r.parent == a.tmove.cursor || r.parent == a.tmove.hot + lines = append(lines, wallCardLine{ + s: wallPopRowPaint(pal, text, inner, lit), + hits: []wallHit{{x0: 0, x1: inner, y1: 1, kind: wallHitPopRow, id: r.parent}}, + }) + } + lines = append(lines, wallCardLine{rule: true}) + foot := "esc cancel" + if r, ok := a.teamMoveFocus(); ok { + if r.ok { + foot = pal.muted(fit(a.teamMoveDoing(a.tmove.ids, r.parent), inner-8)) + pal.dim(" enter") + } else { + foot = pal.muted(fit(r.why, inner)) + } + } else { + foot = pal.dim(foot) + } + lines = append(lines, wallCardLine{s: foot}) + title := "Move " + a.teamMoveSubject(a.tmove.ids) + " into" + w := inner + 2 + 2*wallCardPadX + h := len(lines) + 2 + 2*wallCardPadY + if w > width-2 || h > height { + return wallCard{} + } + x := a.teamsCardX(width, w) + y := max((height-h)/3, 1) + return wallCardBuild(pal, title, lines, x, y, w, wallCardPadX, wallCardPadY) +} + +// ── ASKING, MOVING AND TAKING IT BACK ─────────────────────────────────────── + +// teamMoveAsk moves ids into parent (a team id or [teamMoveTop]): at once +// when nothing a person decides on changes, and otherwise after the one line. +func (a *app) teamMoveAsk(ids []string, parent string, from int) tea.Cmd { + if ok, why := a.teamMoveCheck(ids, parent); !ok { + a.tp.msg = why + a.touch() + return nil + } + words := a.teamMoveEffectWords(ids, parent) + if words == "" { + return a.teamMoveApply(ids, parent, from) + } + a.tmove.pend = teamMovePend{ids: ids, parent: parent, words: words, from: from} + // The keyboard goes to the question's first answer, where `enter` moves. + if from == teamMoveFromPage { + a.tp.focus, a.tp.cur = true, teamsRef{act: teamsActMoveYes} + } else { + a.tsheet.cursor = tsMoveYes + } + a.tp.top = teamsTopCache{} + a.touch() + return nil +} + +// teamMoveEffectWords is the one consequence line for a move, "" when it +// changes nothing a person is asked about. +// +// api will report to harbor's manager · its $3/day becomes part of harbor's $10 pool +func (a *app) teamMoveEffectWords(ids []string, parent string) string { + tree := a.teamTree() + e, err := tree.MoveEffects(ids, teamMoveParent(parent), a.tp.defaults) + if err != nil || !e.Changes() { + return "" + } + subject := a.teamMoveSubject(ids) + manager := func(team string) string { + return a.teamNameOf(team) + "'s manager" + } + var parts []string + if len(e.Reports) > 0 { + // Said once for the whole move: where the first changed line now runs. + r := e.Reports[0] + switch { + case r.Has: + parts = append(parts, subject+" will report to "+manager(r.After.Team)) + case r.Had: + parts = append(parts, subject+" will stop reporting to "+manager(r.Before.Team)) + } + } + if len(e.Pools) > 0 { + p := e.Pools[0] + its := "its spend" + if t, ok := a.teamByID(p.Team); ok && t.Settings.CapUSDDay != nil && *t.Settings.CapUSDDay > 0 { + its = "its " + teamsMoney(*t.Settings.CapUSDDay) + "/day" + } + switch { + case p.After != "" && its == "its spend": + parts = append(parts, "its spend counts toward "+a.teamNameOf(p.After)+"'s "+teamsMoney(p.AfterCap)+" pool") + case p.After != "": + parts = append(parts, its+" becomes part of "+a.teamNameOf(p.After)+"'s "+teamsMoney(p.AfterCap)+" pool") + default: + parts = append(parts, "its spend leaves "+a.teamNameOf(p.Before)+"'s "+teamsMoney(p.BeforeCap)+" pool") + } + } + // Conflicts are said only when they go somewhere the report line has not + // already named: a team that will report to harbor's manager and take its + // conflicts there too is one fact, not two. + if len(e.Judges) > 0 { + j := e.Judges[0] + named := len(e.Reports) > 0 && e.Reports[0].Has && e.Reports[0].After.Team == j.After + if !named { + who := "you" + if j.After != "" { + who = manager(j.After) + } + parts = append(parts, "conflicts in "+a.teamNameOf(j.Team)+" go to "+who) + } + } + return strings.Join(parts, " "+a.teamsDot()+" ") +} + +// teamMoveApply makes the move, as the person's edit, and offers it back. +func (a *app) teamMoveApply(ids []string, parent string, from int) tea.Cmd { + tree := a.teamTree() + roots := tree.MoveRoots(ids) + back := map[string]string{} + homes := map[string]string{} + for _, id := range roots { + t, ok := a.teamByID(id) + if !ok { + continue + } + back[id] = t.Parent + for _, u := range append([]team{t}, tree.Descendants(id)...) { + for _, m := range u.Members { + if _, seen := homes[m.Key]; seen { + continue + } + homes[m.Key] = "" + if r, ok := tree.Home(m.Key); ok { + homes[m.Key] = r.Via + } + } + } + } + target := teamMoveParent(parent) + word := a.teamMoveDone(roots, parent) + // The notices are taken from the tree before the edit and the tree after + // it. The edit runs twice (teams.go), so the append is not inside it: it + // would be written twice, and the first time on the loop. One command + // writes them, through the store, after the move has been accepted. + before := &teamstore.File{Teams: teamsClone(a.wall.teams)} + if err := a.teamEdit(func(f *teamstore.File) error { return f.Move(roots, target) }); err != nil { + a.tp.msg = "not moved: " + err.Error() + a.touch() + return nil + } + a.tmove.pend = teamMovePend{} + a.tmove.undo = teamMoveUndo{back: back, homes: homes, word: word, from: from, at: a.now()} + a.tp.msg = "" + a.tp.top = teamsTopCache{} + if a.tp.cur.act == teamsActMoveYes || a.tp.cur.act == teamsActMoveNo { + a.tp.cur = teamsRef{act: teamsActUndo} + } + a.touch() + return a.teamMoveTraffic(teamstore.MoveNotices(before, a.teamTree(), roots)) +} + +// teamMoveTraffic appends the move's Traffic lines through the seam, off the +// loop. A seam with no Traffic door tells nothing. Nothing here runs on a frame. +func (a *app) teamMoveTraffic(notes []teamstore.MoveNotice) tea.Cmd { + var cmds []tea.Cmd + for _, n := range notes { + cmds = append(cmds, a.teamsTell(n.Team, n.Entry)) + } + return tea.Batch(cmds...) +} + +// teamMoveDone is what the Undo row says of a move made: `api is in harbor +// now`, `api is at the top level now`. +func (a *app) teamMoveDone(ids []string, parent string) string { + subject := a.teamMoveSubject(ids) + if parent == teamMoveTop || parent == "" { + return subject + " is at the top level now" + } + return subject + " is in " + a.teamNameOf(parent) + " now" +} + +// teamMoveCancel drops the move waiting on the person. +func (a *app) teamMoveCancel() { + a.tmove.pend = teamMovePend{} + if a.tp.cur.act == teamsActMoveYes || a.tp.cur.act == teamsActMoveNo { + a.teamsCursorHome() + } + if a.tsheet.cursor == tsMoveYes || a.tsheet.cursor == tsMoveNo { + a.tsheet.cursor = tsInside + } + a.tp.top = teamsTopCache{} + a.touch() +} + +// teamMoveConfirm is `Move` on the consequence line. +func (a *app) teamMoveConfirm() tea.Cmd { + p := a.tmove.pend + if len(p.ids) == 0 { + return nil + } + return a.teamMoveApply(p.ids, p.parent, p.from) +} + +// teamMoveUndoing reports whether Undo is offered for the last move. +func (a *app) teamMoveUndoing() bool { + u := a.tmove.undo + return len(u.back) > 0 && a.now().Sub(u.at) < teamsUndoFor +} + +// teamMoveUndo puts the last move back: every moved team under its parent +// before, and every carried conversation reporting where it did. +func (a *app) teamMoveUndo() tea.Cmd { + if !a.teamMoveUndoing() { + return nil + } + u := a.tmove.undo + a.tmove.undo = teamMoveUndo{} + err := a.teamEdit(func(f *teamstore.File) error { + for id, parent := range u.back { + if _, ok := f.Team(id); !ok { + continue + } + if err := f.SetParent(id, parent); err != nil { + return err + } + } + // A home is a flag the store's tidy may have set on the move; it is put + // back where it was when that membership can still be one, and a + // conversation that had none is left to the rule. + for key, via := range u.homes { + if via != "" { + _ = f.SetHome(key, via) + } + } + return nil + }) + if err != nil { + a.tp.msg = "not moved back: " + err.Error() + } else { + a.tp.msg = "moved back" + } + a.tp.top = teamsTopCache{} + if a.tp.cur.act == teamsActUndo { + a.teamsCursorHome() + } + a.touch() + return nil +} + +// teamMoveSig is everything about a move the teams page's head is drawn from, +// for its cache: "" while nothing is asked or offered. +func (a *app) teamMoveSig() string { + if p := a.tmove.pend; len(p.ids) > 0 && p.from == teamMoveFromPage { + return "ask:" + p.parent + ":" + p.words + } + if a.teamMoveUndoing() && a.tmove.undo.from == teamMoveFromPage { + return "undo:" + a.tmove.undo.word + } + return "" +} + +// teamsMoveRows is the pane's row for a move: the consequence line with `Move` +// and `Cancel` while one waits, or the move just made with `Undo`. The line +// wraps under itself rather than being cut, because it is the thing being +// decided. +func (a *app) teamsMoveRows(d *teamsDraw, width, y int) []string { + pal := a.pal + if p := a.tmove.pend; len(p.ids) > 0 && p.from == teamMoveFromPage { + yes, no := "Move", "Cancel" + bw := ansi.StringWidth(yes) + ansi.StringWidth(no) + 6 + said := wrap(p.words, max(width-2, 12)) + var out []string + for i, l := range said { + line := " " + pal.ink(l) + if i < len(said)-1 { + out = append(out, line) + continue + } + x := ansi.StringWidth(line) + 2 + if x+bw > width { + out = append(out, line) + line, x = " ", 1 + } else { + line += " " + } + s1, w1 := d.button(yes, teamsTarget{act: teamsActMoveYes, x0: x, y: y + len(out), + hint: a.teamMoveDoing(p.ids, p.parent) + hintSegment + "enter"}, pal.accent) + s2, _ := d.button(no, teamsTarget{act: teamsActMoveNo, x0: x + w1 + 1, y: y + len(out), + hint: "Leave it where it is" + hintSegment + "esc"}, pal.ink) + out = append(out, line+s1+" "+s2) + } + return out + } + if a.teamMoveUndoing() && a.tmove.undo.from == teamMoveFromPage { + word := " " + pal.dim(a.tmove.undo.word) + " " + s, _ := d.button("Undo", teamsTarget{act: teamsActUndo, x0: ansi.StringWidth(word), y: y, + hint: "Put it back where it was" + hintSegment + "u"}, pal.ink) + return []string{word + s} + } + return nil +} + +// teamsCanNest reports whether a new team may be made inside parent, and when +// not, why, in the picker's words. With the defaults not read yet the limit is +// not known, and the answer is yes: the store's own tidy keeps the tree whole. +func (a *app) teamsCanNest(parent string) (bool, string) { + t, ok := a.teamByID(parent) + if !ok { + return false, "that team is gone" + } + if t.Closed() { + return false, t.Name + " is closed" + } + tree := a.teamTree() + e := tree.Effective(parent, a.tp.defaults) + if e.DepthLimit <= 0 || tree.Depth(parent)+1 <= e.DepthLimit { + return true, "" + } + return false, a.teamMoveWhy(teamstore.MoveBlock{Kind: teamstore.MoveBlockDepth, Team: t.ID, Name: t.Name, + Depth: tree.Depth(parent), Need: 1, Limit: e.DepthLimit, LimitFrom: e.DepthFrom}, nil, parent) +} + +// teamsMoney is a cap as a sentence says it: `$3` for whole dollars, `$2.50` +// otherwise. A cap is a round figure a person chose, and `$3.00/day` reads as +// a bill. +func teamsMoney(usd float64) string { + if usd >= 1 && usd == float64(int64(usd)) { + return "$" + itoa(int(usd)) + } + return dollars(usd) +} diff --git a/internal/tui3/teamname_test.go b/internal/tui3/teamname_test.go new file mode 100644 index 0000000000..22d7e40571 --- /dev/null +++ b/internal/tui3/teamname_test.go @@ -0,0 +1,202 @@ +package tui3 + +import ( + "context" + "errors" + "strings" + "sync" + "testing" + "time" + + tea "charm.land/bubbletea/v2" +) + +// namingAgent is an agent that can suggest a team's name: the answer it is +// loaded with, and the titles it was asked about. +type namingAgent struct { + Agent + mu sync.Mutex + name string + err error + calls int + titles []string +} + +func (n *namingAgent) NameTeam(_ context.Context, titles []string) (string, error) { + n.mu.Lock() + defer n.mu.Unlock() + n.calls++ + n.titles = append([]string(nil), titles...) + return n.name, n.err +} + +// namerDoors runs what cmd asks for and folds every door's answer back in, +// leaving the five-second wait unrun: it would only end a wait these tests +// end themselves. +func namerDoors(t *testing.T, a *app, cmd tea.Cmd) { + t.Helper() + if cmd == nil { + return + } + msgs := make(chan tea.Msg, 8) + var run func(tea.Cmd) + run = func(c tea.Cmd) { + go func() { + defer func() { _ = recover() }() + msg := c() + if batch, ok := msg.(tea.BatchMsg); ok { + for _, inner := range batch { + if inner != nil { + run(inner) + } + } + return + } + msgs <- msg + }() + } + run(cmd) + deadline := time.After(time.Second) + for { + select { + case msg := <-msgs: + if door, ok := msg.(doorMsg); ok { + _ = a.doorSaid(door) + return + } + case <-deadline: + t.Fatal("the name was never asked for") + } + } +} + +// namingApp is the strip's three conversations on the wall with an agent that +// names, and the two picked that sit in different folders. +func namingApp(t *testing.T) (*app, *namingAgent, []wallTile) { + t.Helper() + a, _, _ := tabApp(t) + namer := &namingAgent{Agent: a.agent} + a.agent = namer + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + var apart []int + folders := map[string]bool{} + for i, tile := range tiles { + if !folders[tile.tab.where] { + folders[tile.tab.where] = true + apart = append(apart, i) + } + } + if len(apart) < 2 { + t.Fatalf("the fixture's conversations share one folder: %+v", tiles) + } + for _, i := range apart[:2] { + a.wallToggle(tiles, i) + } + return a, namer, tiles +} + +// A TEAM IS NAMED ONCE, FROM WHAT ITS CONVERSATIONS ARE. The pleasant word is +// there at once, `naming…` beside it; the model's name replaces it when it +// comes, and nothing asks again. +func TestTeamNameSuggestionReplacesTheWord(t *testing.T) { + a, namer, tiles := namingApp(t) + namer.name = "Parser Port" + cmd := a.wallStartNaming(tiles) + curated := a.wall.name + if curated == "" || !a.wall.nameAsking || cmd == nil { + t.Fatalf("the card opened with %q, asking=%v", curated, a.wall.nameAsking) + } + if frame := wallPlainFrame(a.wallFrame(a.width, a.height)); !strings.Contains(frame, curated+"▌ naming…") { + t.Fatalf("the card does not say it is naming:\n%s", frame) + } + namerDoors(t, a, cmd) + if a.wall.name != "Parser Port" || a.wall.nameAsking || !a.wall.nameFresh { + t.Fatalf("after the answer: name %q asking %v", a.wall.name, a.wall.nameAsking) + } + if namer.calls != 1 || len(namer.titles) != 2 { + t.Fatalf("asked %d times about %q", namer.calls, namer.titles) + } + if frame := wallPlainFrame(a.wallFrame(a.width, a.height)); strings.Contains(frame, "naming…") { + t.Fatal("the card still says naming") + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEnter}) + if names := a.teamNames(); len(names) != 1 || names[0] != "Parser Port" { + t.Fatalf("made %v", names) + } + if namer.calls != 1 { + t.Fatalf("the name was asked for again: %d calls", namer.calls) + } +} + +// TYPING WINS. A name the person started is theirs, and the suggestion that +// arrives after it is dropped. +func TestTeamNameTypingWinsOverTheSuggestion(t *testing.T) { + a, namer, tiles := namingApp(t) + namer.name = "parser port" + cmd := a.wallStartNaming(tiles) + a.wallKey(tea.KeyPressMsg{Code: 'q', Text: "q"}) + namerDoors(t, a, cmd) + if a.wall.name != "q" { + t.Fatalf("the suggestion overwrote what was typed: %q", a.wall.name) + } + if frame := wallPlainFrame(a.wallFrame(a.width, a.height)); strings.Contains(frame, "naming…") { + t.Fatal("the card says naming after the person typed") + } +} + +// A FAILURE OR A WAIT PAST FIVE SECONDS KEEPS THE WORD, and an answer that +// comes after the wait is not used. +func TestTeamNameFailureOrTimeoutKeepsTheWord(t *testing.T) { + a, namer, tiles := namingApp(t) + namer.err = errors.New("no provider answered") + cmd := a.wallStartNaming(tiles) + curated := a.wall.name + namerDoors(t, a, cmd) + if a.wall.name != curated || a.wall.nameAsking { + t.Fatalf("a failure changed the word to %q (asking %v)", a.wall.name, a.wall.nameAsking) + } + + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + namer.err, namer.name = nil, "late name" + cmd = a.wallStartNaming(tiles) + curated = a.wall.name + _, _ = a.Update(wallNameTimeMsg{gen: a.wall.nameGen}) + if a.wall.nameAsking { + t.Fatal("the wait did not end") + } + namerDoors(t, a, cmd) + if a.wall.name != curated { + t.Fatalf("an answer after the wait replaced the word: %q", a.wall.name) + } +} + +// A SHARED FOLDER IS THE NAME, AND NOTHING IS ASKED. +func TestTeamNameSharedFolderAsksNothing(t *testing.T) { + a, _, _ := tabApp(t) + namer := &namingAgent{Agent: a.agent, name: "unused"} + a.agent = namer + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + var where string + picked := 0 + for i, tile := range tiles { + if tile.tab.where == "/tmp/lab" { + a.wallToggle(tiles, i) + where = tile.tab.where + picked++ + } + } + if picked < 2 { + t.Fatalf("the fixture has %d conversations in one folder", picked) + } + cmd := a.wallStartNaming(tiles) + if cmd != nil || a.wall.nameAsking || namer.calls != 0 { + t.Fatalf("a shared folder asked for a name: asking %v, %d calls", a.wall.nameAsking, namer.calls) + } + if a.wall.name != "lab" { + t.Fatalf("the card offers %q for %s", a.wall.name, where) + } +} diff --git a/internal/tui3/teamnest_test.go b/internal/tui3/teamnest_test.go new file mode 100644 index 0000000000..e65a4dfc4e --- /dev/null +++ b/internal/tui3/teamnest_test.go @@ -0,0 +1,569 @@ +package tui3 + +import ( + "os" + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/config" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── NESTING ON THE TEAMS PAGE (rulings c-12, c-13) ────────────────────────── + +// nestLab is the teams page with three teams: harbor at the top with orbit +// inside it, and dock at the top holding one conversation this window does not +// have open. The depth limit is two, from Settings, so orbit (two deep) can +// take nothing more. dock is selected. +func nestLab(t *testing.T) (a *app, harbor, orbit, dock string) { + t.Helper() + a, harbor, orbit = teamsPlaceLabIDs(t) + dock = newTeamID() + if err := a.teamEdit(func(f *teamstore.File) error { + f.Teams = append(f.Teams, teamstore.Team{ID: dock, Name: "dock", Members: []teamstore.Member{ + {Key: a.convKey("/tmp/lab/crane.jsonl"), File: "/tmp/lab/crane.jsonl", Where: "/tmp/lab", Word: "crane work", Handle: "crane"}}}) + return nil + }); err != nil { + t.Fatal(err) + } + // The limit is the profile's own `teams.depth_limit`, so every read the + // page makes through the seam answers the same two. + if err := os.WriteFile(config.BudgetConfigPath(a.profileDir), []byte(`{"teams.depth_limit": 2}`), 0o600); err != nil { + t.Fatal(err) + } + a.tp.defaults, a.tp.defaultsOK = teamstore.DefaultsAt(a.profileDir), true + drive(t, a, runCmd(a.teamsSelect(dock))...) + a.frame() + return a, harbor, orbit, dock +} + +// nestRow is the frame row that holds want, -1 for none. +// +// The head is skipped: the strip of chats is on every page, and its team chip +// reads `● harbor ▾` over the rail's own `● harbor`. +func nestRow(a *app, want string) int { + for y, l := range strings.Split(teamsFrameText(a), "\n") { + if y >= placeHeadRows && strings.Contains(l, want) { + return y + } + } + return -1 +} + +// railPoint is a cell on team id's rail row, two cells in. +func railPoint(t *testing.T, a *app, id string) (int, int) { + t.Helper() + tg := teamsTargetOf(t, a, teamsActSelect, id) + return tg.x0 + 2, tg.y +} + +// press, drag and release are the pointer's three moves with the left button. +func nestPress(x, y int) tea.MouseClickMsg { + return tea.MouseClickMsg{X: x, Y: y, Button: tea.MouseLeft} +} +func dragTo(x, y int) tea.MouseMotionMsg { + return tea.MouseMotionMsg{X: x, Y: y, Button: tea.MouseLeft} +} +func release(x, y int) tea.MouseReleaseMsg { + return tea.MouseReleaseMsg{X: x, Y: y, Button: tea.MouseLeft} +} + +// parentOf is team id's parent as the window holds it. +func parentOf(a *app, id string) string { + t, _ := a.teamByID(id) + return t.Parent +} + +// THE PICKER LISTS EVERY TEAM AND DIMS THE ONES THAT CANNOT TAKE THE MOVE with +// the reason in its foot and the hint: the team itself, a team under it, and a +// team too deep for the limit (`orbit is 2 levels deep · limit 2 · Settings`). +// Typing filters, and the tree keeps its indent. +func TestMoveIntoPickerDimsInvalidTargetsWithTheReason(t *testing.T) { + a, harbor, orbit, dock := nestLab(t) + drive(t, a, key("m")) + if !a.tmove.on || len(a.tmove.ids) != 1 || a.tmove.ids[0] != dock { + t.Fatalf("m did not open the picker for dock: %+v", a.tmove) + } + rows := a.teamMoveRows() + want := map[string]string{ + teamMoveTop: "dock is at the top level already", + harbor: "", + orbit: "orbit is 2 levels deep · limit 2 · Settings", + dock: "a team cannot go inside itself", + } + if len(rows) != 4 { + t.Fatalf("the picker has %d rows, want 4: %+v", len(rows), rows) + } + for _, r := range rows { + why, ok := want[r.parent] + if !ok { + t.Fatalf("an unexpected row %q", r.name) + } + if r.ok != (why == "") || r.why != why { + t.Fatalf("row %s: ok %v why %q, want why %q", r.name, r.ok, r.why, why) + } + } + // The keyboard starts on the first row that can take the move. + if a.tmove.cursor != harbor { + t.Fatalf("the cursor starts on %q", a.tmove.cursor) + } + drive(t, a, key("down")) + text := teamsFrameText(a) + if !strings.Contains(text, "Move dock into") || !strings.Contains(text, "orbit is 2 levels deep · limit 2 · Settings") { + t.Fatalf("the dimmed row's reason is not in the picker's foot:\n%s", text) + } + if hint := a.teamMoveHint(); !strings.Contains(hint, "limit 2") { + t.Fatalf("the hint line does not say why: %q", hint) + } + // enter on a dimmed row moves nothing and keeps the picker up. + drive(t, a, key("enter")) + if !a.tmove.on || parentOf(a, dock) != "" { + t.Fatal("enter on a blocked row moved the team or closed the picker") + } + // The indent survives: orbit stands deeper than harbor. + hy, oy := nestRow(a, "● harbor"), nestRow(a, "● orbit") + lines := strings.Split(teamsFrameText(a), "\n") + if hy < 0 || oy < 0 || strings.Index(lines[oy], "●") <= strings.Index(lines[hy], "●") { + t.Fatalf("the picker's tree lost its indent:\n%s", text) + } + // Typing filters. + drive(t, a, key("o"), key("r"), key("b")) + if rows := a.teamMoveRows(); len(rows) != 1 || rows[0].parent != orbit { + t.Fatalf("the filter `orb` left %+v", rows) + } + drive(t, a, key("esc")) + if a.tmove.on { + t.Fatal("esc did not close the picker") + } +} + +// A MOVE THAT CHANGES NOTHING A PERSON DECIDES ON IS MADE AT ONCE, and Undo +// puts it back. +func TestMoveIntoAQuietTeamIsInstantWithUndo(t *testing.T) { + a, harbor, _, dock := nestLab(t) + drive(t, a, key("m"), key("enter")) + if a.tmove.on || parentOf(a, dock) != harbor { + t.Fatalf("dock is under %q, the picker on %v", parentOf(a, dock), a.tmove.on) + } + if len(a.tmove.pend.ids) > 0 { + t.Fatal("a quiet move asked first") + } + text := teamsFrameText(a) + if !strings.Contains(text, "dock is in harbor now") || !strings.Contains(text, "Undo") { + t.Fatalf("the move offers no Undo:\n%s", text) + } + drive(t, a, key("u")) + if parentOf(a, dock) != "" { + t.Fatalf("Undo left dock under %q", parentOf(a, dock)) + } +} + +// A MOVE THAT CHANGES WHO DECIDES ASKS ONE LINE FIRST: with harbor managed and +// capped, dock into harbor says whose manager and whose pool, with Move and +// Cancel. Cancel leaves it; Move moves it; Undo is offered after it too. +func TestMoveConsequenceLineOnlyWhenSomethingChanges(t *testing.T) { + a, harbor, _, dock := nestLab(t) + ten := 10.0 + three := 3.0 + if err := a.teamEdit(func(f *teamstore.File) error { + if err := f.AddMember(harbor, teamstore.Member{Key: "boss-key", Handle: "boss", Word: "the boss"}); err != nil { + return err + } + if err := f.SetManager(harbor, "boss-key"); err != nil { + return err + } + if err := f.SetSettings(dock, func(s *teamstore.Settings) { s.CapUSDDay = &three }); err != nil { + return err + } + return f.SetSettings(harbor, func(s *teamstore.Settings) { s.CapUSDDay = &ten }) + }); err != nil { + t.Fatal(err) + } + drive(t, a, runCmd(a.teamMoveAsk([]string{dock}, harbor, teamMoveFromPage))...) + p := a.tmove.pend + if len(p.ids) == 0 { + t.Fatal("a move under a manager and a cap did not ask") + } + for _, want := range []string{"dock will report to harbor's manager", "its $3/day becomes part of harbor's $10 pool"} { + if !strings.Contains(p.words, want) { + t.Fatalf("the line %q lacks %q", p.words, want) + } + } + if parentOf(a, dock) != "" { + t.Fatal("the move was made before the person said Move") + } + text := teamsFrameText(a) + if !strings.Contains(text, "report to harbor's manager") || !strings.Contains(text, "Move") || !strings.Contains(text, "Cancel") { + t.Fatalf("the consequence line is not on the pane:\n%s", text) + } + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActMoveNo, "")))...) + if parentOf(a, dock) != "" || len(a.tmove.pend.ids) > 0 { + t.Fatal("Cancel moved the team or left the line up") + } + drive(t, a, runCmd(a.teamMoveAsk([]string{dock}, harbor, teamMoveFromPage))...) + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActMoveYes, "")))...) + if parentOf(a, dock) != harbor { + t.Fatal("Move did not move the team") + } + if !a.teamMoveUndoing() || !strings.Contains(teamsFrameText(a), "Undo") { + t.Fatal("a confirmed move offers no Undo") + } + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActUndo, "")))...) + if parentOf(a, dock) != "" { + t.Fatal("Undo did not put the confirmed move back") + } +} + +// A DRAG STARTS ONLY AFTER TWO CELLS OF HELD MOVEMENT: a one-cell wobble and a +// release is a click that selects; two cells onto harbor is a drag that says +// `Drop to move dock into harbor`, grounds harbor, and moves it on release. +func TestDragStartsAfterTwoCellsAndDropsOnAValidTeam(t *testing.T) { + a, harbor, _, dock := nestLab(t) + dx, dy := railPoint(t, a, dock) + drive(t, a, nestPress(dx, dy), dragTo(dx+1, dy)) + if a.tdrag.on { + t.Fatal("a one-cell wobble started a drag") + } + drive(t, a, release(dx+1, dy)) + if a.tdrag.press || parentOf(a, dock) != "" || a.tp.sel != dock { + t.Fatalf("a click moved the team or did not select it (sel %q)", a.tp.sel) + } + hx, hy := railPoint(t, a, harbor) + drive(t, a, nestPress(dx, dy), dragTo(dx, dy-1), dragTo(hx, hy)) + if !a.tdrag.on { + t.Fatal("two cells of held movement did not start a drag") + } + if hint := a.teamDragHint(); !strings.HasPrefix(hint, "Drop to move dock into harbor") { + t.Fatalf("the drag's hint: %q", hint) + } + if !a.teamDropLit(harbor) { + t.Fatal("harbor is not grounded as the drop") + } + drive(t, a, release(hx, hy)) + if parentOf(a, dock) != harbor || a.tdrag.press { + t.Fatalf("the drop left dock under %q", parentOf(a, dock)) + } +} + +// ONLY A VALID TARGET TAKES A DROP: orbit is past the depth limit, so it is not +// grounded, the hint says why, and a release there moves nothing. The empty rail +// under the tree is the top level, and esc drops a drag with nothing moved. +func TestDragDropsOnlyOnValidTargetsAndEscCancels(t *testing.T) { + a, harbor, orbit, dock := nestLab(t) + dx, dy := railPoint(t, a, dock) + ox, oy := railPoint(t, a, orbit) + drive(t, a, nestPress(dx, dy), dragTo(dx+4, dy+3), dragTo(ox, oy)) + if a.teamDropLit(orbit) || !strings.Contains(a.teamDragHint(), "orbit is 2 levels deep") { + t.Fatalf("a blocked target is grounded or unexplained: %q", a.teamDragHint()) + } + drive(t, a, release(ox, oy)) + if parentOf(a, dock) != "" { + t.Fatal("a drop on a blocked target moved the team") + } + // orbit to the top level, by the empty rail under the tree. + below := -1 + for _, tg := range a.tp.targets { + if tg.act == teamsActNewTeam { + below = tg.y - 1 + } + } + drive(t, a, nestPress(ox, oy), dragTo(ox, oy+2), dragTo(3, below)) + if !a.teamDropLit(teamMoveTop) || !strings.Contains(teamsFrameText(a), "Top level") { + t.Fatalf("the empty rail is not the top level: %q\n%s", a.teamDragHint(), teamsFrameText(a)) + } + drive(t, a, release(3, below)) + if parentOf(a, orbit) != "" { + t.Fatalf("orbit is still under %q", parentOf(a, orbit)) + } + // esc drops a drag and nothing happens. + hx, hy := railPoint(t, a, harbor) + drive(t, a, nestPress(dx, dy), dragTo(hx, hy+3), dragTo(hx, hy)) + drive(t, a, key("esc")) + if a.tdrag.press || a.tdrag.on { + t.Fatal("esc did not drop the drag") + } + drive(t, a, release(hx, hy)) + if parentOf(a, dock) != "" { + t.Fatal("a drag esc cancelled still moved the team") + } +} + +// DRAGGING A MEMBER ONTO A TEAM ADDS IT, AND NEVER TAKES IT OUT of the team it +// came from: @crane dragged from dock's members card onto harbor is in both. +func TestDraggingAMemberRowOntoATeamAddsIt(t *testing.T) { + a, harbor, _, dock := nestLab(t) + drive(t, a, key(teamCrewLetter)) + if !a.tcrew.on { + t.Fatal("p did not open the members card") + } + text := teamsFrameText(a) + if !strings.Contains(text, "@crane") || !strings.Contains(text, "Resume") || strings.Contains(text, "not open") { + t.Fatalf("the members card:\n%s", text) + } + var row wallHit + for _, h := range a.tcrew.hits { + if h.kind == crewHitRow && h.arg == 0 { + row = h + } + } + if row.x1 == 0 { + t.Fatalf("no row on the members card:\n%s", text) + } + hx, hy := railPoint(t, a, harbor) + drive(t, a, nestPress(row.x0+2, row.y0), dragTo(row.x0+5, row.y0+1), dragTo(hx, hy)) + if hint := a.teamDragHint(); !strings.HasPrefix(hint, "Add @crane to harbor") { + t.Fatalf("the member drag's hint: %q", hint) + } + drive(t, a, release(hx, hy)) + key := a.convKey("/tmp/lab/crane.jsonl") + h, _ := a.teamByID(harbor) + d, _ := a.teamByID(dock) + if !h.Holds(key) || !d.Holds(key) { + t.Fatalf("the drop moved rather than added: harbor %v dock %v", h.Holds(key), d.Holds(key)) + } +} + +// SPACE PICKS TEAMS ON THE RAIL, AND ONE MOVE INTO… MOVES THEM ALL. +func TestMultiSelectedTeamsMoveTogether(t *testing.T) { + a, harbor, _, dock := nestLab(t) + pier := newTeamID() + if err := a.teamEdit(func(f *teamstore.File) error { + f.Teams = append(f.Teams, teamstore.Team{ID: pier, Name: "pier"}) + return nil + }); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(config.BudgetConfigPath(a.profileDir), []byte(`{"teams.depth_limit": 4}`), 0o600); err != nil { + t.Fatal(err) + } + a.tp.defaults = teamstore.DefaultsAt(a.profileDir) + a.frame() + for _, id := range []string{dock, harbor} { + a.tp.focus, a.tp.cur = true, teamsRef{act: teamsActSelect, id: id} + drive(t, a, key(" ")) + } + if got := a.teamsPickedIDs(); len(got) != 2 { + t.Fatalf("picked %v", got) + } + if !strings.Contains(teamsFrameText(a), wallGlyphsFor(false).marked) { + t.Fatal("the rail does not mark the picked teams") + } + drive(t, a, key("m")) + if !strings.Contains(teamsFrameText(a), "Move 2 teams into") { + t.Fatalf("the picker is not for both:\n%s", teamsFrameText(a)) + } + for _, r := range a.teamMoveRows() { + if r.parent == pier { + drive(t, a, runCmd(a.teamMoveChoose(r))...) + } + } + if parentOf(a, dock) != pier || parentOf(a, harbor) != pier { + t.Fatalf("dock under %q, harbor under %q", parentOf(a, dock), parentOf(a, harbor)) + } +} + +// `+ NEW TEAM` WITH A TEAM CHOSEN READS `+ New team in harbor` and makes the +// team inside it; a team at the depth limit dims it and says why. +func TestNewTeamInTheChosenTeam(t *testing.T) { + a, harbor, orbit, _ := nestLab(t) + drive(t, a, runCmd(a.teamsSelect(harbor))...) + if !strings.Contains(teamsFrameText(a), "+ New team in harbor") { + t.Fatalf("the rail does not offer a team inside harbor:\n%s", teamsFrameText(a)) + } + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActNewTeam, harbor)))...) + if !a.wall.on || !a.wall.naming || a.wall.nameParent != harbor { + t.Fatalf("the new-team card is not for a team in harbor: on %v naming %v parent %q", a.wall.on, a.wall.naming, a.wall.nameParent) + } + if !strings.Contains(teamsFrameText(a), "New team in harbor") { + t.Fatalf("the card does not say where the team goes:\n%s", teamsFrameText(a)) + } + a.wall.name = "slip" + drive(t, a, runCmd(a.wallMakeTeam(a.wallShown(a.now())))...) + var made team + for _, u := range a.wall.teams { + if u.Name == "slip" { + made = u + } + } + if made.Parent != harbor { + t.Fatalf("the new team is under %q, want harbor", made.Parent) + } + a.closeWall() + drive(t, a, key("alt+2")) + drive(t, a, runCmd(a.teamsSelect(orbit))...) + tg := teamsTargetOf(t, a, teamsActNewTeam, orbit) + if !strings.Contains(tg.hint, "limit 2") { + t.Fatalf("a team at the limit does not say why: %q", tg.hint) + } + drive(t, a, runCmd(a.teamsDo(tg))...) + if a.wall.naming { + t.Fatal("a team at the limit opened the new-team card") + } +} + +// THE TEAM'S CARD HAS `Inside: … ▾`, which opens the same picker, and the move +// it makes is offered back on the card. +func TestTheCardsInsideFieldMovesTheTeam(t *testing.T) { + a, harbor, _, dock := nestLab(t) + drive(t, a, runCmd(a.teamSheetOpen(dock, teamSheetSettings))...) + if text := teamsFrameText(a); !strings.Contains(text, "Inside") || !strings.Contains(text, "Top level ▾") { + t.Fatalf("the card has no Inside field:\n%s", text) + } + drive(t, a, runCmd(a.teamSheetDo(tsInside))...) + if !a.tmove.on || a.tmove.from != teamMoveFromCard { + t.Fatal("Inside did not open the picker") + } + drive(t, a, key("enter")) + if parentOf(a, dock) != harbor { + t.Fatalf("dock is under %q", parentOf(a, dock)) + } + text := teamsFrameText(a) + if !strings.Contains(text, "harbor ▾") || !strings.Contains(text, "Undo") { + t.Fatalf("the card does not show the move and its Undo:\n%s", text) + } + drive(t, a, key("u")) + if parentOf(a, dock) != "" { + t.Fatal("u on the card did not undo the move") + } +} + +// THE SWITCHER IS THE TREE, INDENTED; THE WALL'S TEAMS ROW STAYS FLAT and says +// `harbor › orbit` for the team inside harbor. +func TestSwitcherIsTheTreeAndTheWallSaysParentAndChild(t *testing.T) { + a, harbor, orbit, _ := nestLab(t) + a.leavePlace() + a.openTeamMenu() + frame, _, _ := a.frame() + lines := strings.Split(plain(frame), "\n") + hy, oy := -1, -1 + // The switcher's rows, not the strip's chip above it: a radio leads each. + for y, l := range lines { + if hy < 0 && strings.Contains(l, "◉ ● harbor") { + hy = y + } + if oy < 0 && strings.Contains(l, "● orbit") && strings.Contains(l, "○") { + oy = y + } + } + if hy < 0 || oy != hy+1 || strings.Index(lines[oy], "●") <= strings.Index(lines[hy], "●") { + t.Fatalf("the switcher does not indent orbit under harbor:\n%s", plain(frame)) + } + a.closeTeamMenu() + o, _ := a.teamByID(orbit) + if got := a.wallTeamLabel(o); got != "harbor › orbit" { + t.Fatalf("the wall calls orbit %q", got) + } + h, _ := a.teamByID(harbor) + if got := a.wallTeamLabel(h); got != "harbor" { + t.Fatalf("the wall calls harbor %q", got) + } + a.width = 160 + drive(t, a, runCmd(a.openWall())...) + if !strings.Contains(teamsFrameText(a), "harbor › orbit") { + t.Fatalf("the wall's Teams row does not say harbor › orbit:\n%s", teamsFrameText(a)) + } +} + +// THE HEADER IS ONE LINE AT EVERY WIDTH: the name always, the buttons unless +// nothing else fits, a working member as a chip, everyone else one idle word, +// and narrow, the idle word goes before the chip. +func TestTheTeamHeaderIsOneLineAndDropsInOrder(t *testing.T) { + for _, width := range []int{80, 110, 160} { + t.Run(itoa(width), func(t *testing.T) { + a, harbor, _ := teamsPlaceLabIDs(t) + a.width = width + a.state = stateWorking + drive(t, a, runCmd(a.teamsSelect(harbor))...) + text := teamsFrameText(a) + y := nestRow(a, "Settings") + if y < 0 { + t.Fatalf("no header at %d:\n%s", width, text) + } + line := strings.Split(text, "\n")[y] + if !strings.Contains(line, "harbor") { + t.Fatalf("the header lost the team's name at %d: %q", width, line) + } + chip := strings.Contains(line, "working") + idle := strings.Contains(line, "idle") + if idle && !chip { + t.Fatalf("the idle word stayed while the working chip went at %d: %q", width, line) + } + if width >= 110 && (!chip || !idle) { + t.Fatalf("at %d the header should have room for the chip and the idle word: %q", width, line) + } + next := strings.Split(text, "\n")[y+1] + if strings.Contains(next, "idle") || strings.Contains(next, "not open") { + t.Fatalf("the members spilled onto a second row at %d: %q", width, next) + } + }) + } +} + +// A RULING AND A SUB-TEAM START READ AS WHAT THEY ARE on the threaded +// Traffic rail (DESIGN.md 8.10). +func TestTrafficSaysRulingsAndSubTeamStarts(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + h, _ := a.teamByID(harbor) + lay := func(e teamstore.Entry) (string, string) { + // A ruling is a row of work and a start is chatter, a line under + // General: each is laid the way the manager's Traffic lays it. + s := &sideSheet{a: a, t: h, width: 90, hotDoor: -1} + th := teamstore.Thread{Root: e, Latest: e.ID} + if sideChatter(th) { + s.reply(e) + } else { + s.work(th, e) + } + var rows, hints []string + for _, l := range s.lines { + rows = append(rows, plain(l.text)) + if l.side != nil { + hints = append(hints, l.side.hint) + for _, d := range l.side.doors { + hints = append(hints, d.hint) + } + } + } + return strings.Join(rows, "\n"), strings.Join(hints, "\n") + } + ruling := teamstore.Entry{ID: "000000000007", Kind: teamstore.KindDirective, From: teamstore.FromManager, To: "web", Packet: "p9", + Text: "ruling on the conflict p9, by ◆ @boss (manager of \"harbor\"): JSON: the form stays"} + got, hint := lay(ruling) + if !strings.Contains(got, "ruling") || strings.Contains(got, " do") || !strings.Contains(got, "JSON: the form stays") { + t.Fatalf("the ruling rows: %q", got) + } + if !strings.Contains(hint, "p9") { + t.Fatalf("the ruling's hint does not name its packet: %q", hint) + } + start := teamstore.Entry{ID: "000000000008", Kind: teamstore.KindStart, From: teamstore.FromManager, To: "api", Team: orbit, Text: "run it"} + if got, _ := lay(start); !strings.Contains(got, "started @api to run orbit") { + t.Fatalf("the sub-team start rows: %q", got) + } +} + +// THE MOVE ACTION WRITES TRAFFIC. dock (member @crane) into harbor is one +// line on the team that moved and one on the team it joined, each once. +func TestMoveIntoWritesTraffic(t *testing.T) { + a, harbor, _, dock := nestLab(t) + if log, _ := teamstore.ReadTraffic(a.profileDir, dock, "", 0); len(log) != 0 { + t.Fatalf("traffic before the move: %+v", log) + } + drive(t, a, key("m"), key("enter")) + if parentOf(a, dock) != harbor { + t.Fatalf("dock is under %q", parentOf(a, dock)) + } + one := func(team, text string) { + t.Helper() + log, err := teamstore.ReadTraffic(a.profileDir, team, "", 0) + if err != nil { + t.Fatal(err) + } + if len(log) != 1 || log[0].Kind != teamstore.KindEvent || log[0].Text != text { + t.Fatalf("%s traffic: %+v, want one %q", team, log, text) + } + } + one(dock, "@crane moved to harbor") + one(harbor, "@crane joined from the top") +} diff --git a/internal/tui3/teamorganize.go b/internal/tui3/teamorganize.go new file mode 100644 index 0000000000..5d002a8612 --- /dev/null +++ b/internal/tui3/teamorganize.go @@ -0,0 +1,1126 @@ +package tui3 + +import ( + "context" + "path/filepath" + "strconv" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── ORGANIZE: TEAMS SUGGESTED FOR THE CONVERSATIONS, NEVER APPLIED ALONE ──── +// +// On the wall's All view the Teams row ends in ` ✦ Organize `. A press (or o) +// puts up a card of suggested teams, each ticked, and nothing changes until +// Apply; Undo, on the Teams row for a few seconds after, puts the list back +// exactly as it was. +// +// THE SUGGESTIONS COME FROM TWO PASSES. The folder pass is free and exact: +// conversations that share a project folder, two or more, are a team named +// after it, or additions to a team that already has its name. The model pass +// is one call on the naming role ([session.Agent.ProposeTeams]) for what a +// folder cannot see. The two are merged with the folder pass winning, and when +// the model is absent or fails the folder pass is shown alone and says so. +// +// IT ONLY EVER ADDS. A suggestion is a new team or conversations added to one +// that exists; nothing here removes a member or renames a team, so pressing it +// again is safe and nothing runs until a person presses it. +// +// The painter half is pure, as the rest of the wall's is: the card and the +// button are drawn from [wallView.org] and never read the app. + +// orgProp is one suggestion: a new team when team is "", else conversations +// added to the team with that id. +type orgProp struct { + team string + // name is the new team's name, or the existing team's, for drawing; hue is + // the colour the new team will get, or the existing team's own. + name string + hue teamHueSpec + // keys are the conversations it adds, and names their titles in order. + keys []string + names []string + // reason is the model's few words on why, "" for the folder pass; folder + // says the folder pass made it. + reason string + folder bool + take bool + // closes is the teams a `Close N quiet teams` suggestion closes (ruling + // c-9): open teams with no activity for [teamstore.QuietAfter] and nothing + // waiting. It is the one suggestion that is not about membership, and its + // team is [orgCloseRow]. + closes []string +} + +// orgCloseRow is the team field of the close-quiet suggestion: no team's id, +// so Apply's membership pass passes over it. +const orgCloseRow = "\x00close" + +// wallOrganize is Organize's whole state, and the painter's input once the +// frame has filled in loose and clean. +type wallOrganize struct { + // on says the card is up and thinking that the model is still being asked. + on, thinking bool + // gen counts the asks, so an answer to one the card has moved past is + // dropped. + gen int + // props are the suggestions in the card's order, new teams first; cursor + // is the row the keyboard is on, and top the first line the card showed + // when it had to scroll. + props []orgProp + cursor int + top int + // folderOnly says the model pass did not answer and only the folder pass + // is shown; cost is what the ask cost, spelled, "" when none was made. + folderOnly bool + cost string + // undo is the team list as it was before the last Apply, and doneAt, made + // and added what the Teams row says while Undo is offered. + undo []team + doneAt time.Time + // undoMade and undoJoins are what the last Apply did, the teams it made by + // id and the members it added, so Undo can take exactly those back. + undoMade []string + undoJoins []orgJoin + undoClosed []string + made int + added int + closed int + // quiet is the open teams the last off-loop read found quiet, and quietGen + // the ask it answered. + quiet []string + quietGen int + // cleanSig is the state of the conversations and teams when the last run + // found nothing to suggest, and cleanSet says there is one. + cleanSig uint64 + cleanSet bool + // loose and clean are the frame's: how many shown conversations are in no + // team, and whether nothing has changed since a run found nothing. + loose int + clean bool +} + +// wallOrganizedFor is how long the Teams row offers Undo after an Apply. +const wallOrganizedFor = 6 * time.Second + +// wallOrganizeLoose is how many conversations in no team the button counts +// from: under it the count is noise. +const wallOrganizeLoose = 5 + +// organizeWait bounds the model pass. Past it the folder pass is shown alone. +const organizeWait = 10 * time.Second + +// organizeAnswerTokens is what a proposal's answer is taken to cost in +// tokens, for the estimate: a few short JSON rows. +const organizeAnswerTokens = 250 + +// teamProposer is the door the model pass comes through, asserted as +// [teamNamer] is, so an agent without it is simply not asked. +type teamProposer interface { + ProposeTeams(ctx context.Context, in session.TeamProposalInput) (session.TeamProposal, error) +} + +// orgConv is one conversation as Organize reads it. +type orgConv struct { + key, title, where string +} + +// orgConvOf is tab as an orgConv, and false for what is no conversation to +// organize: the start and work pages, a tab with no key, and one with no name +// yet, which a person could not recognise in a suggestion. +func orgConvOf(tab chatTab) (orgConv, bool) { + if tab.start || tab.work || tab.key == "" { + return orgConv{}, false + } + title := strings.TrimSpace(tab.full) + if title == "" { + title = strings.TrimSpace(tab.word) + } + if title == "" { + return orgConv{}, false + } + return orgConv{key: tab.key, title: title, where: tab.where}, true +} + +// orgConvs is every open conversation Organize can suggest a team for, in the +// strip's order. A filter does not narrow it: organizing is about all of them. +func (a *app) orgConvs() []orgConv { + var out []orgConv + for _, tab := range a.tabList() { + if c, ok := orgConvOf(tab); ok { + out = append(out, c) + } + } + return out +} + +// folderTeamName is the team name a folder gives: its last element, +// lowercased and cut to [teamNameCells], "" for a root. +func folderTeamName(where string) string { + base := filepath.Base(filepath.Clean(where)) + if base == "/" || base == "." || base == "" { + return "" + } + return ansi.Truncate(strings.ToLower(base), teamNameCells, "") +} + +// teamNamed is the index of the team called name, compared without case, -1 +// for none. +func teamNamed(teams []team, name string) int { + for i, t := range teams { + if strings.EqualFold(strings.TrimSpace(t.Name), strings.TrimSpace(name)) { + return i + } + } + return -1 +} + +// organizeFolders is the folder pass: every folder two or more conversations +// share becomes a new team named after it, unless one team already holds them +// all, and unless a team already has the folder's name, when the ones it is +// missing are suggested for it instead. Two folders of one name are one team. +// It is pure and exact, so the same conversations always give the same rows. +func organizeFolders(convs []orgConv, teams []team) []orgProp { + groups := map[string][]string{} + var order []string + for _, c := range convs { + if strings.TrimSpace(c.where) == "" { + continue + } + w := filepath.Clean(c.where) + if _, ok := groups[w]; !ok { + order = append(order, w) + } + if !orgHas(groups[w], c.key) { + groups[w] = append(groups[w], c.key) + } + } + var out []orgProp + for _, w := range order { + keys := groups[w] + name := folderTeamName(w) + if len(keys) < 2 || name == "" || teamsHoldAll(teams, keys) { + continue + } + if i := teamNamed(teams, name); i >= 0 { + var missing []string + for _, k := range keys { + if !teamHolds(teams[i], k) { + missing = append(missing, k) + } + } + out = orgMergeInto(out, orgProp{team: teams[i].ID, name: teams[i].Name, hue: teams[i].HueSpec(), keys: missing, folder: true}) + continue + } + out = orgMergeInto(out, orgProp{name: name, keys: keys, folder: true}) + } + return out +} + +// teamsHoldAll reports whether one team holds every one of keys. +func teamsHoldAll(teams []team, keys []string) bool { + for _, t := range teams { + all := true + for _, k := range keys { + if !teamHolds(t, k) { + all = false + break + } + } + if all { + return true + } + } + return false +} + +// orgMergeInto adds p to props, folding it into a row that is the same +// suggestion already: the same existing team, or a new team of the same name. +// The row already there keeps its reason and its place. +func orgMergeInto(props []orgProp, p orgProp) []orgProp { + if len(p.keys) == 0 { + return props + } + for i, q := range props { + same := p.team != "" && q.team == p.team || + p.team == "" && q.team == "" && strings.EqualFold(q.name, p.name) + if !same { + continue + } + for _, k := range p.keys { + if !orgHas(props[i].keys, k) { + props[i].keys = append(props[i].keys, k) + } + } + return props + } + return append(props, p) +} + +func orgHas(keys []string, key string) bool { + for _, k := range keys { + if k == key { + return true + } + } + return false +} + +// organizeFromModel is the model's answer as rows. The answer was validated +// by the session; what is checked again here is what may have moved while it +// was asked: a team that is gone, and a member a team now holds. +func organizeFromModel(res session.TeamProposal, teams []team) []orgProp { + var out []orgProp + for _, n := range res.New { + if i := teamNamed(teams, n.Name); i >= 0 { + out = append(out, orgProp{team: teams[i].ID, name: teams[i].Name, hue: teams[i].HueSpec(), keys: orgMissing(teams[i], n.Members)}) + continue + } + out = append(out, orgProp{name: n.Name, keys: n.Members, reason: n.Reason}) + } + for _, add := range res.Additions { + i := teamIndex(teams, add.TeamID) + if i < 0 { + continue + } + out = append(out, orgProp{team: teams[i].ID, name: teams[i].Name, hue: teams[i].HueSpec(), keys: orgMissing(teams[i], add.Members)}) + } + return out +} + +// orgMissing is keys less the ones t already holds. +func orgMissing(t team, keys []string) []string { + var out []string + for _, k := range keys { + if !teamHolds(t, k) && !orgHas(out, k) { + out = append(out, k) + } + } + return out +} + +// organizeMerge is the two passes as one list, new teams first. The folder +// pass wins: a model team with a folder team's name, or with exactly its +// members, is dropped, and a model addition to a team the folder pass already +// adds to only brings the members that row lacks. +func organizeMerge(folder, model []orgProp) []orgProp { + props := append([]orgProp(nil), folder...) + for _, p := range model { + if p.team == "" { + dup := false + for _, q := range folder { + if q.team == "" && (strings.EqualFold(q.name, p.name) || orgSameKeys(q.keys, p.keys)) { + dup = true + break + } + } + if dup { + continue + } + } + props = orgMergeInto(props, p) + } + var out []orgProp + for _, p := range props { + if p.team == "" && len(p.keys) >= 2 { + out = append(out, p) + } + } + for _, p := range props { + if p.team != "" && len(p.keys) > 0 { + out = append(out, p) + } + } + return out +} + +func orgSameKeys(a, b []string) bool { + if len(a) != len(b) { + return false + } + for _, k := range a { + if !orgHas(b, k) { + return false + } + } + return true +} + +// organizeSig is the state Organize reads, as one number that any change to +// it moves: which conversations are open and which team holds which. It is a +// sum of per-item hashes, so the order things are listed in does not count, +// and it allocates nothing, so a frame may take it. +func organizeSig(keys []string, teams []team) uint64 { + var sum uint64 + for _, k := range keys { + sum += orgHash(k, "", 1) + } + for _, t := range teams { + sum += orgHash(t.ID, "", 2) + for _, m := range t.Members { + sum += orgHash(t.ID, m.Key, 3) + } + } + return sum +} + +// orgHash is FNV-1a over a, a separator of kind, and b. +func orgHash(a, b string, kind byte) uint64 { + h := uint64(14695981039346656037) + step := func(c byte) { + h ^= uint64(c) + h *= 1099511628211 + } + for i := 0; i < len(a); i++ { + step(a[i]) + } + step(0) + step(kind) + for i := 0; i < len(b); i++ { + step(b[i]) + } + return h +} + +// ── WIRED ─────────────────────────────────────────────────────────────────── + +// wallOrganizeOpen is the button and o: the card up, the folder pass drawn at +// once when there is no model to ask, and otherwise one ask off the loop with +// `thinking…` in the card until it answers. It does nothing while a team is +// shown, where the button is not drawn. +func (a *app) wallOrganizeOpen() tea.Cmd { + if a.wall.activeID != "" { + return nil + } + a.teamsEnsure() + o := &a.wall.org + o.gen++ + o.on, o.thinking, o.props, o.cursor, o.top, o.folderOnly, o.cost = true, false, nil, 0, 0, false, "" + a.wall.pop, a.wall.help, a.wall.naming, a.wall.filterOn = wallPop{}, false, false, false + a.wall.hover = wallHitRef{} + a.wall.stirred = true + a.touch() + quietAsk := a.wallOrganizeQuietAsk(o.gen) + convs := a.orgConvs() + var proposer teamProposer + if a.agent != nil { + proposer, _ = a.agent.(teamProposer) + } + if proposer == nil || len(convs) < 2 { + a.wallOrganizeShow(nil, proposer == nil && len(convs) >= 2, "") + if quietAsk == nil { + return nil + } + gen := o.gen + return a.besideLine(func() func(here bool) tea.Cmd { + ids := quietAsk() + return func(bool) tea.Cmd { + a.wallOrganizeQuietTake(gen, ids) + return nil + } + }) + } + in := session.TeamProposalInput{} + for _, c := range convs { + in.Conversations = append(in.Conversations, session.TeamProposalConversation{Key: c.key, Title: c.title, Folder: filepath.Base(filepath.Clean(c.where))}) + } + for _, t := range a.wall.teams { + pt := session.TeamProposalTeam{ID: t.ID, Name: t.Name} + for _, m := range t.Members { + pt.Members = append(pt.Members, m.Key) + } + in.Teams = append(in.Teams, pt) + } + gen := o.gen + o.thinking = true + return a.besideLine(func() func(here bool) tea.Cmd { + var quiet []string + if quietAsk != nil { + quiet = quietAsk() + } + ctx, cancel := context.WithTimeout(context.Background(), organizeWait) + defer cancel() + res, err := proposer.ProposeTeams(ctx, in) + return func(bool) tea.Cmd { + a.wallOrganizeQuietTake(gen, quiet) + a.wallOrganized(gen, res, err) + return nil + } + }) +} + +// wallOrganizeQuietAsk is the question, to be asked off the loop in the same +// read as the model's, of which open teams have been quiet for +// [teamstore.QuietAfter] with nothing waiting, for the card's `Close N quiet +// teams`. It reads this machine's profile, so over --host it is nil: the +// engine has no door for it yet, and the card simply does not offer it. +func (a *app) wallOrganizeQuietAsk(gen int) func() []string { + o := &a.wall.org + o.quiet, o.quietGen = nil, gen + if a.hosted() || a.teamsOff() { + return nil + } + dir, now := a.profileDir, a.now() + tree := &teamstore.File{Teams: teamsClone(a.wall.teams)} + return func() []string { + ids, err := teamstore.Quiet(dir, tree, now, teamstore.QuietAfter) + if err != nil { + return nil + } + return ids + } +} + +// wallOrganizeQuietTake folds the quiet teams in: kept for the card, and put +// on it at once when the card is already showing its suggestions. +func (a *app) wallOrganizeQuietTake(gen int, ids []string) { + o := &a.wall.org + if gen != o.quietGen || !o.on { + return + } + o.quiet = ids + if !o.thinking { + o.props = a.orgWithQuiet(o.props) + a.touch() + } +} + +// orgWithQuiet is props with the close-quiet suggestion last, when any team +// is quiet and the suggestion is not there yet. +func (a *app) orgWithQuiet(props []orgProp) []orgProp { + o := &a.wall.org + if len(o.quiet) == 0 { + return props + } + for _, p := range props { + if p.team == orgCloseRow { + return props + } + } + p := orgProp{team: orgCloseRow, take: true, reason: "Nothing has happened in these for a week; Undo takes it back"} + for _, id := range o.quiet { + if t, ok := a.teamByID(id); ok && !t.Closed() && !t.Root { + p.closes = append(p.closes, id) + p.names = append(p.names, t.Name) + } + } + if len(p.closes) == 0 { + return props + } + p.name = "Close " + strconv.Itoa(len(p.closes)) + " quiet team" + if len(p.closes) != 1 { + p.name += "s" + } + return append(props, p) +} + +// wallOrganized takes answer gen into the card, if it is still the one being +// waited for and the card is still up. A failure shows the folder pass alone. +func (a *app) wallOrganized(gen int, res session.TeamProposal, err error) { + o := &a.wall.org + if gen != o.gen || !o.on || !o.thinking { + return + } + a.touch() + if err != nil { + a.wallOrganizeShow(nil, true, "") + return + } + cost := a.organizeCost(res.Model, res.PromptChars) + a.wallOrganizeShow(organizeFromModel(res, a.wall.teams), false, cost) +} + +// wallOrganizeShow puts the merged suggestions in the card: the folder pass, +// read now, with model's rows merged in. Each is ticked, each new team is +// given a colour distinct from every team's and each other's, and each row +// learns its members' titles. A run that suggests nothing remembers the state +// it looked at, so the button can say Organized until something changes. +func (a *app) wallOrganizeShow(model []orgProp, folderOnly bool, cost string) { + o := &a.wall.org + convs := a.orgConvs() + props := organizeMerge(organizeFolders(convs, a.wall.teams), model) + titles := make(map[string]string, len(convs)) + keys := make([]string, 0, len(convs)) + for _, c := range convs { + titles[c.key] = c.title + keys = append(keys, c.key) + } + used := a.teamHues("") + reserved := teamReservedHues(a.pal) + for i := range props { + p := &props[i] + p.take = true + kept := p.keys[:0] + for _, k := range p.keys { + if t, ok := titles[k]; ok { + kept = append(kept, k) + p.names = append(p.names, t) + } + } + p.keys = kept + if p.team == "" { + p.hue = nextTeamHue(used, reserved) + used = append(used, p.hue) + } + } + props = a.orgWithQuiet(props) + o.thinking, o.props, o.folderOnly, o.cost = false, props, folderOnly, cost + o.cursor, o.top = 0, 0 + o.cleanSet = len(props) == 0 && !folderOnly + if o.cleanSet { + o.cleanSig = organizeSig(keys, a.wall.teams) + } +} + +// organizeCost is what the ask cost, estimated from its size: its characters +// at four to a token and a short answer, priced at the model that answered +// when its price is known, and said in tokens when it is not, since a price +// nobody published is not a figure. +func (a *app) organizeCost(model string, chars int) string { + if chars <= 0 { + return "" + } + in := chars/4 + 1 + if m, ok := a.priceFor(model); ok { + return "about " + dollars(float64(in)*m.PromptPrice+float64(organizeAnswerTokens)*m.CompletionPrice) + } + return "about " + tokenWord(in+organizeAnswerTokens) + " tokens" +} + +// wallOrganizeClose puts the card away with no change; an answer still on its +// way is dropped. +func (a *app) wallOrganizeClose() { + o := &a.wall.org + o.on, o.thinking = false, false + o.gen++ + a.wall.hover = wallHitRef{} + a.wall.stirred = true + a.touch() +} + +// wallOrganizeToggle ticks suggestion i, or unticks it. +func (a *app) wallOrganizeToggle(i int) { + o := &a.wall.org + if i < 0 || i >= len(o.props) { + return + } + o.cursor = i + o.props[i].take = !o.props[i].take + a.touch() +} + +// wallOrganizeApply makes the ticked suggestions, in one save: each new team +// with the name and colour the card showed, which is the name it is made +// with, and each addition's members put into their team. The list as it was +// is kept for Undo. A new team whose name was taken while the card was up +// goes into the team that has it. +func (a *app) wallOrganizeApply() { + o := &a.wall.org + if !o.on || o.thinking { + return + } + prior := teamsClone(a.wall.teams) + now := a.now() + // What Apply does is worked out against the teams this window holds, once, + // as new teams (their ids minted here) and members added to teams that + // exist, and then made through [app.teamEdit], which makes it again to the + // file as it is on disk. The same two lists are what Undo takes back. + var fresh []team + var joins []orgJoin + var closes []string + for _, p := range o.props { + if !p.take { + continue + } + if p.team == orgCloseRow { + closes = append(closes, p.closes...) + continue + } + members := teamFromTabs(p.name, a.wallTabsFor(p.keys, nil), now).Members + i := teamIndex(a.wall.teams, p.team) + if p.team == "" { + i = teamNamed(a.wall.teams, p.name) + if i < 0 { + for j := range fresh { + if strings.EqualFold(strings.TrimSpace(fresh[j].Name), strings.TrimSpace(p.name)) { + for _, m := range members { + if !teamHolds(fresh[j], m.Key) { + fresh[j].Members = append(fresh[j].Members, m) + joins = append(joins, orgJoin{team: fresh[j].ID, member: m}) + } + } + members = nil + } + } + if members == nil { + continue + } + } + } + if i < 0 && p.team == "" && len(members) > 0 { + made := team{ID: newTeamID(), Name: p.name, Members: members, Made: now} + made.SetHue(p.hue) + fresh = append(fresh, made) + continue + } + if i < 0 { + continue + } + t := a.wall.teams[i] + for _, m := range members { + if !teamHolds(t, m.Key) && !orgJoined(joins, t.ID, m.Key) { + joins = append(joins, orgJoin{team: t.ID, member: m}) + } + } + } + a.wallOrganizeClose() + made, added := len(fresh), len(joins) + if made == 0 && added == 0 && len(closes) == 0 { + return + } + o.undo, o.doneAt, o.made, o.added, o.closed = prior, now, made, added, len(closes) + o.undoMade, o.undoJoins, o.undoClosed = nil, joins, closes + for _, t := range fresh { + o.undoMade = append(o.undoMade, t.ID) + } + err := a.teamEdit(func(f *teamstore.File) error { + for _, t := range fresh { + if teamIndex(f.Teams, t.ID) < 0 { + f.Teams = append(f.Teams, t.Clone()) + } + } + for _, j := range joins { + if teamIndex(f.Teams, j.team) < 0 { + continue + } + if err := f.AddMember(j.team, j.member); err != nil { + return err + } + } + // A quiet team closes with no report: nothing was running to wrap up. + for _, id := range closes { + if t, ok := f.Team(id); !ok || t.Closed() { + continue + } + if err := f.Close(id, now, ""); err != nil { + return err + } + } + return nil + }) + if err != nil { + a.note("the teams are kept for this window, but " + err.Error()) + } + for _, id := range closes { + if a.wall.activeID == id { + a.wall.activeID = "" + } + } +} + +// orgJoin is one conversation Apply put into a team. +type orgJoin struct { + team string + member teamMember +} + +// orgJoined reports whether joins already puts key into team id. +func orgJoined(joins []orgJoin, id, key string) bool { + for _, j := range joins { + if j.team == id && j.member.Key == key { + return true + } + } + return false +} + +// wallOrganizeUndo takes back the last Apply, while the Teams row still offers +// it: the teams it made are dropped and the members it added are taken out +// again. It is made through [app.teamEdit] like every other edit, so a manager, +// a handle or a member another process wrote since the Apply is kept, and with +// nothing written in between the list is back exactly as it was. +func (a *app) wallOrganizeUndo() { + o := &a.wall.org + if o.undo == nil || o.doneAt.IsZero() || a.now().Sub(o.doneAt) >= wallOrganizedFor { + return + } + made, joins, closed := o.undoMade, o.undoJoins, o.undoClosed + o.undo, o.doneAt = nil, time.Time{} + o.undoMade, o.undoJoins, o.undoClosed = nil, nil, nil + a.wall.hover = wallHitRef{} + a.wall.stirred = true + a.touch() + err := a.teamEdit(func(f *teamstore.File) error { + for _, id := range made { + teamDrop(f, id) + } + for _, j := range joins { + if teamIndex(f.Teams, j.team) < 0 { + continue + } + if err := f.RemoveMember(j.team, j.member.Key); err != nil { + return err + } + } + for _, id := range closed { + if t, ok := f.Team(id); !ok || !t.Closed() { + continue + } + if err := f.Reopen(id); err != nil { + return err + } + } + return nil + }) + if teamIndex(a.wall.teams, a.wall.activeID) < 0 { + a.wall.activeID = "" + } + if err != nil { + a.note("the teams are back for this window, but " + err.Error()) + } +} + +// teamsClone is a copy of teams that shares nothing with it, so a change to +// one is never a change to the other. +func teamsClone(teams []team) []team { + if teams == nil { + return []team{} + } + out := make([]team, len(teams)) + for i, t := range teams { + out[i] = t.Clone() + } + return out +} + +// wallOrganizeKey is a key while the card is up; the card has the keyboard. +// ↑ ↓ walk the rows, space ticks one, enter applies (or closes a card with +// nothing in it), esc or q puts it away with no change. +func (a *app) wallOrganizeKey(key string) tea.Cmd { + o := &a.wall.org + switch key { + case "esc", "q": + a.wallOrganizeClose() + case "up", "k": + o.cursor = max(o.cursor-1, 0) + case "down", "j": + o.cursor = min(o.cursor+1, max(len(o.props)-1, 0)) + case "space": + a.wallOrganizeToggle(o.cursor) + case "enter": + switch { + case o.thinking: + case len(o.props) == 0: + a.wallOrganizeClose() + default: + a.wallOrganizeApply() + } + } + return nil +} + +// wallOrganizePress is a press while the card is up: its rows and its +// buttons answer, and nothing else does. +func (a *app) wallOrganizePress(hit wallHit) tea.Cmd { + switch { + case hit.kind == wallHitOrgRow: + a.wallOrganizeToggle(hit.arg) + case hit.kind == wallHitAction && wallAct(hit.arg) == wallActOrgApply: + a.wallOrganizeApply() + case hit.kind == wallHitAction && wallAct(hit.arg) == wallActOrgCancel: + a.wallOrganizeClose() + } + return nil +} + +// wallOrganizeFrame fills in what the painter reads of Organize on this +// frame: how many shown conversations are in no team, and whether nothing has +// changed since a run found nothing. It reads memory only. +func (a *app) wallOrganizeFrame(tiles []wallTile, tabs []chatTab) wallOrganize { + o := a.wall.org + o.undo = nil + o.loose = 0 + for _, t := range tiles { + if len(t.teams) == 0 { + o.loose++ + } + } + o.clean = false + if o.cleanSet { + keys := make([]string, 0, len(tabs)) + for _, tab := range tabs { + if c, ok := orgConvOf(tab); ok { + keys = append(keys, c.key) + } + } + o.clean = organizeSig(keys, a.wall.teams) == o.cleanSig + } + return o +} + +// ── PAINTED ───────────────────────────────────────────────────────────────── + +// wallOrgPiece is Organize's part of the Teams row: its paint, its width, and +// its targets from its own first cell. +type wallOrgPiece struct { + s string + w int + hits []wallHit +} + +// wallOrgMarks is the button's two glyphs in the palette's tier. +func wallOrgMarks(pal palette) (spark, check string) { + if pal.ascii { + return "*", "" + } + return "✦", " " + pal.glyph(tokens.GSettled) +} + +// wallOrganizeButton is Organize's part of the Teams row on row y: for a few +// seconds after an Apply what it did and an Undo; otherwise, on All only, the +// button, `✦ Organize` with the count of conversations in no team once there +// are five, or a dim `Organized ✓` when the last run found nothing and nothing +// has changed. It is drawn nowhere else. +func wallOrganizeButton(pal palette, g wallGlyphs, v wallView, y int) wallOrgPiece { + o := v.org + if !o.doneAt.IsZero() && v.now.Sub(o.doneAt) < wallOrganizedFor && v.now.Sub(o.doneAt) >= 0 { + var said []string + if o.made > 0 { + said = append(said, strconv.Itoa(o.made)+" new "+wallPlural(o.made, "team")) + } + if o.added > 0 { + said = append(said, strconv.Itoa(o.added)+" added") + } + if o.closed > 0 { + said = append(said, strconv.Itoa(o.closed)+" closed") + } + word := "Organized " + g.sep + " " + strings.Join(said, ", ") + " " + undo := wallButton{act: wallActOrgUndo, label: "Undo"} + hot := v.hover == wallHitRef{kind: wallHitAction, arg: int(wallActOrgUndo)} + ww, bw := ansi.StringWidth(word), wallButtonW(undo) + return wallOrgPiece{s: pal.dim(word) + wallButtonPaint(pal, undo, hot), w: ww + bw, + hits: []wallHit{{x0: ww, y0: y, x1: ww + bw, y1: y + 1, kind: wallHitAction, arg: int(wallActOrgUndo)}}} + } + if v.team != "" { + return wallOrgPiece{} + } + spark, check := wallOrgMarks(pal) + hot := v.hover == wallHitRef{kind: wallHitAction, arg: int(wallActOrganize)} + var s string + switch { + case o.clean: + s = " " + pal.dim("Organized"+check) + " " + case o.loose >= wallOrganizeLoose: + s = " " + pal.ink(spark+" Organize") + " " + pal.dim(strconv.Itoa(o.loose)) + " " + default: + s = " " + pal.ink(spark+" Organize") + " " + } + w := ansi.StringWidth(s) + if hot { + s = pal.cursor(s, 0) + } + return wallOrgPiece{s: s, w: w, hits: []wallHit{{x0: 0, y0: y, x1: w, y1: y + 1, kind: wallHitAction, arg: int(wallActOrganize)}}} +} + +// wallOrgCardMaxW is the widest the card is drawn. +const wallOrgCardMaxW = 72 + +// wallOrgNameCap is the widest a member's title is drawn in a row's list. +const wallOrgNameCap = 16 + +// wallOrgCard is the card of suggestions, centred over the grid: +// +// ╭─ Organize ──────────────────────────────────────────────╮ +// │ │ +// │ New teams │ +// │ ☑ ● codeaf 5 from the folder │ +// │ ☑ ● nvda research 3 cpu profiling, nvda deep…, 10-K │ +// │ Add to existing │ +// │ ☑ ● harbor + 2 relay audit, footprint table │ +// │ │ +// │ about $0.0020 Cancel esc Apply ↵ │ +// │ │ +// ╰──────────────────────────────────────────────────────────╯ +// +// While the model is asked it says `thinking…`; with nothing to suggest it +// says so beside a Close. When its rows do not fit between the head and the +// foot it drops its padding, then shows a window of them that keeps the +// cursor's row in view, and its bottom border says which way the rest lies. +// top is the first row line it drew, for the wiring to keep. +func wallOrgCard(pal palette, g wallGlyphs, v wallView, width, height int) wallCard { + o := v.org + w := min(wallOrgCardMaxW, width-2*wallMargin-2) + inner := w - 2 - 2*wallCardPadX + if inner < 30 { + return wallCard{} + } + k := wallKeysFor(pal.ascii) + var list []wallCardLine + cursorLine := -1 + var tail []wallCardLine + button := func(lead string, bs ...wallButton) wallCardLine { + bw := wallBarWidth(bs, 1) + s, _, hits := wallLay(pal, bs, v.hover, inner+2-bw, 0, 1) + lw := ansi.StringWidth(lead) + if lead != "" && lw+2 > inner+2-bw { + lead = "" + } + pad := strings.Repeat(" ", max(inner+2-bw-lw-1, 0)) + if lead == "" { + pad = strings.Repeat(" ", max(inner+2-bw, 0)) + return wallCardLine{s: pad + s, hits: hits, bleed: true} + } + return wallCardLine{s: " " + pal.dim(lead) + pad + s, hits: hits, bleed: true} + } + cancel := wallButton{act: wallActOrgCancel, label: "Cancel", key: "esc"} + switch { + case o.thinking: + word := "thinking…" + if pal.ascii { + word = "thinking..." + } + list = append(list, wallCardLine{s: pal.dim(word)}) + tail = append(tail, wallCardLine{}, button("", cancel)) + case len(o.props) == 0: + list = append(list, wallCardLine{s: pal.ink("Everything is organized")}) + tail = append(tail, wallCardLine{}, button("", wallButton{act: wallActOrgCancel, label: "Close", key: "esc"})) + default: + nameW, countW := 6, 1 + for _, p := range o.props { + nameW = max(nameW, min(ansi.StringWidth(p.name), teamNameCells)) + countW = max(countW, len(wallOrgCount(p))) + } + heading := func(s string) { + list = append(list, wallCardLine{s: pal.bold(pal.muted(s))}) + } + for i, p := range o.props { + if i == 0 && p.team == "" { + heading("New teams") + } + if p.team != "" && p.team != orgCloseRow && (i == 0 || o.props[i-1].team == "") { + heading("Add to existing") + } + if p.team == orgCloseRow { + heading("Quiet for a week") + } + if i == o.cursor { + cursorLine = len(list) + } + list = append(list, wallOrgRow(pal, g, k, v, p, i, inner, nameW, countW)) + } + if o.folderOnly { + tail = append(tail, wallCardLine{}, wallCardLine{s: pal.dim("suggestions from folders only")}) + } + apply := wallButton{act: wallActOrgApply, label: "Apply", key: k.enter} + tail = append(tail, wallCardLine{}, button(o.cost, cancel, apply)) + } + + top := wallGridTop + floor := height - wallFootRows + 1 // the first row a card may not cover + room := floor - top + padY := wallCardPadY + if len(list)+len(tail)+2+2*padY > room { + padY = 0 + } + vis := room - 2 - 2*padY - len(tail) + if vis < 1 { + return wallCard{} + } + over := max(len(list)-vis, 0) + from := min(max(o.top, 0), over) + if cursorLine >= 0 { + // The cursor's row is kept in view, moving the window as little as it + // can; the heading over the first row comes with it. + if cursorLine < from { + from = cursorLine + } + if cursorLine >= from+vis { + from = cursorLine - vis + 1 + } + if cursorLine == 1 && vis >= 2 { + from = 0 + } + } + from = min(max(from, 0), over) + lines := append(append([]wallCardLine(nil), list[from:min(from+vis, len(list))]...), tail...) + h := len(lines) + 2 + 2*padY + x := (width - w) / 2 + y := top + max((room-h)/2, 0) + card := wallCardBuild(pal, "Organize", lines, x, y, w, wallCardPadX, padY) + card.top = from + if over > 0 { + card.over = over + card.rows[len(card.rows)-1] = wallHelpFoot(pal, w, from < over) + } + return card +} + +// wallOrgCount is a row's count: how many a new team holds, or `+ 2` for how +// many an existing team gains. +func wallOrgCount(p orgProp) string { + if p.team == orgCloseRow { + return strconv.Itoa(len(p.closes)) + } + if p.team != "" { + return "+ " + strconv.Itoa(len(p.keys)) + } + return strconv.Itoa(len(p.keys)) +} + +// wallOrgRow is one suggestion: its box, its colour, its name, its count and +// what it holds, the whole row a target that ticks it. +func wallOrgRow(pal palette, g wallGlyphs, k wallKeys, v wallView, p orgProp, i, inner, nameW, countW int) wallCardLine { + box := pal.muted(k.boxOff) + if p.take { + box = pal.ink(k.boxOn) + } + mark := pal.dim(g.cell) + if ink := pal.teamInk(p.hue); ink != nil { + mark = ink("●") + } else if r := []rune(p.name); len(r) > 0 && ansi.StringWidth(string(r[0])) == 1 { + mark = pal.dim(strings.ToLower(string(r[0]))) + } + name := p.name + if ansi.StringWidth(name) > nameW { + name = ansi.Truncate(name, nameW, g.more) + } + count := wallOrgCount(p) + left := box + " " + mark + " " + pal.ink(name) + strings.Repeat(" ", nameW-ansi.StringWidth(name)+1) + + strings.Repeat(" ", countW-len(count)) + pal.dim(count) + " " + // THE QUIET-TEAMS ROW IS NOT A TEAM. It has no colour to wear and its + // count is already in its words, so it is its sentence whole (`Close 2 + // quiet teams`), then the teams it names; cut to a team name's width it + // read `● Close 2 quiet t… 2`. + if p.team == orgCloseRow { + name = fit(p.name, max(inner/2, 8)) + left = box + " " + pal.ink(name) + " " + } + detail := "from the folder" + if !p.folder || p.team != "" { + cut := make([]string, 0, len(p.names)) + for _, n := range p.names { + if ansi.StringWidth(n) > wallOrgNameCap { + // Cut at a word's end where it can be, so no blank sits + // before the ellipsis. + n = strings.TrimRight(ansi.Truncate(n, wallOrgNameCap-ansi.StringWidth(g.more), ""), " ") + g.more + } + cut = append(cut, n) + } + detail = strings.Join(cut, ", ") + } + if room := inner - ansi.StringWidth(left); ansi.StringWidth(detail) > room { + detail = ansi.Truncate(detail, max(room, 0), g.more) + } + lit := v.org.cursor == i || v.hover == wallHitRef{kind: wallHitOrgRow, arg: i} + return wallCardLine{ + s: wallPopRowPaint(pal, left+pal.muted(detail), inner, lit), + hits: []wallHit{{x0: 0, y0: 0, x1: inner, y1: 1, kind: wallHitOrgRow, arg: i}}, + } +} diff --git a/internal/tui3/teamorganize_test.go b/internal/tui3/teamorganize_test.go new file mode 100644 index 0000000000..29eddb4c67 --- /dev/null +++ b/internal/tui3/teamorganize_test.go @@ -0,0 +1,480 @@ +package tui3 + +import ( + "context" + "errors" + "fmt" + "os" + "reflect" + "strings" + "sync" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// proposingAgent is an agent whose model pass answers what it is loaded with, +// and remembers what it was asked. +type proposingAgent struct { + Agent + mu sync.Mutex + res session.TeamProposal + err error + calls int + in session.TeamProposalInput +} + +func (p *proposingAgent) ProposeTeams(_ context.Context, in session.TeamProposalInput) (session.TeamProposal, error) { + p.mu.Lock() + defer p.mu.Unlock() + p.calls++ + p.in = in + return p.res, p.err +} + +// orgKeys is the keys of props, row by row, for comparing. +func orgKeys(props []orgProp) [][]string { + out := make([][]string, 0, len(props)) + for _, p := range props { + out = append(out, p.keys) + } + return out +} + +// THE FOLDER PASS IS EXACT: two or more conversations in one folder are a team +// named after it, unless one team already holds them all, or a team has the +// folder's name, when only the missing ones are suggested for it. +func TestOrganizeFolderPass(t *testing.T) { + convs := []orgConv{ + {key: "a", title: "one", where: "/src/codeaf"}, + {key: "b", title: "two", where: "/src/codeaf/"}, + {key: "c", title: "three", where: "/work/codeaf"}, + {key: "d", title: "four", where: "/src/nvda"}, + {key: "e", title: "five", where: "/src/solo"}, + {key: "f", title: "six", where: ""}, + {key: "g", title: "seven", where: ""}, + {key: "h", title: "eight", where: "/src/nvda"}, + {key: "i", title: "nine", where: "/src/harbor"}, + {key: "j", title: "ten", where: "/src/harbor"}, + {key: "k", title: "eleven", where: "/work/codeaf"}, + } + t.Run("new teams, two folders of one name are one", func(t *testing.T) { + props := organizeFolders(convs, nil) + var names []string + for _, p := range props { + names = append(names, p.name) + if p.team != "" || !p.folder { + t.Fatalf("a folder row that is not a new folder team: %+v", p) + } + } + if !reflect.DeepEqual(names, []string{"codeaf", "nvda", "harbor"}) { + t.Fatalf("teams %v", names) + } + if !reflect.DeepEqual(orgKeys(props), [][]string{{"a", "b", "c", "k"}, {"d", "h"}, {"i", "j"}}) { + t.Fatalf("members %v", orgKeys(props)) + } + }) + t.Run("a team holding them all, and a team of the folder's name", func(t *testing.T) { + teams := []team{ + {ID: "t-ops", Name: "ops", Members: []teamMember{{Key: "d"}, {Key: "h"}, {Key: "a"}}}, + {ID: "t-harbor", Name: "Harbor", Members: []teamMember{{Key: "i"}}}, + } + props := organizeFolders(convs, teams) + if len(props) != 2 { + t.Fatalf("props %+v", props) + } + if props[0].team != "" || props[0].name != "codeaf" { + t.Fatalf("first row %+v", props[0]) + } + if props[1].team != "t-harbor" || !reflect.DeepEqual(props[1].keys, []string{"j"}) { + t.Fatalf("the harbor row %+v", props[1]) + } + }) +} + +// THE FOLDER PASS WINS. A model team with a folder team's name or exactly its +// members is dropped; a model addition to a team the folder pass adds to +// brings only what that row lacks; new teams come first. +func TestOrganizeMergeFolderWins(t *testing.T) { + folder := []orgProp{ + {team: "t1", name: "harbor", keys: []string{"f"}, folder: true}, + {name: "codeaf", keys: []string{"a", "b"}, folder: true}, + } + model := []orgProp{ + {name: "codeaf", keys: []string{"c", "d"}, reason: "same name"}, + {name: "other", keys: []string{"b", "a"}, reason: "same members"}, + {name: "nvda", keys: []string{"c", "d"}, reason: "one company"}, + {team: "t1", name: "harbor", keys: []string{"e", "f"}}, + {team: "t2", name: "orbit", keys: []string{"g"}}, + } + got := organizeMerge(folder, model) + var names []string + for _, p := range got { + names = append(names, p.name) + } + if !reflect.DeepEqual(names, []string{"codeaf", "nvda", "harbor", "orbit"}) { + t.Fatalf("rows %v", names) + } + if !reflect.DeepEqual(orgKeys(got), [][]string{{"a", "b"}, {"c", "d"}, {"f", "e"}, {"g"}}) { + t.Fatalf("members %v", orgKeys(got)) + } + if !got[0].folder || got[1].reason != "one company" { + t.Fatalf("the rows lost where they came from: %+v", got[:2]) + } +} + +// organizeApp is the strip's three conversations on the wall, two of them in +// /tmp/lab, with agent as the one that answers. +func organizeApp(t *testing.T, agent func(Agent) Agent) *app { + t.Helper() + a, _, _ := tabApp(t) + if agent != nil { + a.agent = agent(a.agent) + } + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + return a +} + +// orgFrame is the wall as text. +func orgFrame(a *app) string { + return wallPlainFrame(a.wallFrame(a.width, a.height)) +} + +// orgHitAt is where the last frame drew the first target of kind and arg. +func orgHitAt(t *testing.T, a *app, kind wallHitKind, arg int) wallHit { + t.Helper() + for _, h := range a.wall.hits { + if h.kind == kind && h.arg == arg { + return h + } + } + t.Fatalf("no target %d/%d on the frame:\n%s", kind, arg, orgFrame(a)) + return wallHit{} +} + +// WITH NO MODEL TO ASK, THE FOLDER PASS IS SHOWN ALONE AND SAYS SO, and every +// row is toggled by space and by a press. +func TestOrganizeCardTogglesAndSaysFoldersOnly(t *testing.T) { + a := organizeApp(t, nil) + a.wallKey(tea.KeyPressMsg{Code: 'o', Text: "o"}) + if !a.wall.org.on || a.wall.org.thinking { + t.Fatalf("the card is not up with its rows: %+v", a.wall.org) + } + frame := orgFrame(a) + for _, want := range []string{"─ Organize ", "New teams", "lab", "from the folder", "suggestions from folders only", "Cancel esc", "Apply ↵"} { + if !strings.Contains(frame, want) { + t.Fatalf("the card lacks %q:\n%s", want, frame) + } + } + if len(a.wall.org.props) != 1 || !a.wall.org.props[0].take { + t.Fatalf("props %+v", a.wall.org.props) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeySpace, Text: " "}) + if a.wall.org.props[0].take { + t.Fatal("space did not untick the row") + } + if frame := orgFrame(a); !strings.Contains(frame, "☐ ") { + t.Fatalf("the row does not show it is unticked:\n%s", frame) + } + row := orgHitAt(t, a, wallHitOrgRow, 0) + _, _ = a.wallPress(row.x0+1, row.y0) + if !a.wall.org.props[0].take { + t.Fatal("a press did not tick the row") + } + // A press off the card puts it away with no change. + _, _ = a.wallPress(0, a.height-4) + if a.wall.org.on || len(a.wall.teams) != 0 { + t.Fatalf("a press off the card: on %v, teams %d", a.wall.org.on, len(a.wall.teams)) + } +} + +// APPLY MAKES THE TICKED TEAMS IN ONE SAVE, AND UNDO PUTS BACK THE EXACT LIST +// THAT WAS THERE, on disk as in memory. +func TestOrganizeApplyThenUndoRestoresTheExactList(t *testing.T) { + a := organizeApp(t, nil) + tiles := a.wallShown(a.now()) + if _, err := a.teamMake("orbit", []chatTab{tiles[1].tab}); err != nil { + t.Fatal(err) + } + // The list Undo must give back is the one as written: the save is queued, + // and the member's handle and the stored time come back with it. + teamsFlush(t, a) + prior := teamsClone(a.wall.teams) + before, err := os.ReadFile(teamsPath(a.profileDir)) + if err != nil { + t.Fatal(err) + } + a.wallKey(tea.KeyPressMsg{Code: 'o', Text: "o"}) + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEnter}) + if a.wall.org.on || len(a.wall.teams) != 2 || a.wall.teams[1].Name != "lab" || len(a.wall.teams[1].Members) != 2 { + t.Fatalf("after Apply: %+v", a.wall.teams) + } + if hue := a.wall.teams[1].HueSpec(); hue == a.wall.teams[0].HueSpec() { + t.Fatal("the new team took an existing team's colour") + } + frame := orgFrame(a) + if !strings.Contains(frame, "Organized · 1 new team ") || !strings.Contains(frame, " Undo ") { + t.Fatalf("the Teams row does not offer Undo:\n%s", frame) + } + undo := orgHitAt(t, a, wallHitAction, int(wallActOrgUndo)) + if got := ansi.Strip(ansi.Cut(a.wallFrame(a.width, a.height)[undo.y0], undo.x0, undo.x1)); got != " Undo " { + t.Fatalf("the Undo target lies on %q", got) + } + _, _ = a.wallPress(undo.x0+1, undo.y0) + if !reflect.DeepEqual(a.wall.teams, prior) { + t.Fatalf("Undo left %+v\nwant %+v", a.wall.teams, prior) + } + teamsFlush(t, a) + after, err := os.ReadFile(teamsPath(a.profileDir)) + if err != nil { + t.Fatal(err) + } + if string(after) != string(before) { + t.Fatalf("the file after Undo:\n%s\nbefore:\n%s", after, before) + } + if frame := orgFrame(a); strings.Contains(frame, "Undo") { + t.Fatalf("Undo is still offered:\n%s", frame) + } +} + +// THE BUTTON IS ON ALL ONLY, and o does nothing while a team is shown. +func TestOrganizeOnlyOnAll(t *testing.T) { + a := organizeApp(t, nil) + if frame := orgFrame(a); !strings.Contains(frame, "✦ Organize") { + t.Fatalf("All has no Organize:\n%s", frame) + } + hit := orgHitAt(t, a, wallHitAction, int(wallActOrganize)) + if got := ansi.Strip(ansi.Cut(a.wallFrame(a.width, a.height)[hit.y0], hit.x0, hit.x1)); got != " ✦ Organize " { + t.Fatalf("the button's target lies on %q", got) + } + tiles := a.wallShown(a.now()) + id, err := a.teamMake("orbit", []chatTab{tiles[0].tab}) + if err != nil { + t.Fatal(err) + } + a.wallSetTeam(id) + if frame := orgFrame(a); strings.Contains(frame, "Organize") { + t.Fatalf("a team's view has Organize:\n%s", frame) + } + a.wallKey(tea.KeyPressMsg{Code: 'o', Text: "o"}) + if a.wall.org.on { + t.Fatal("o opened the card on a team's view") + } +} + +// THE BUTTON COUNTS FIVE OR MORE CONVERSATIONS IN NO TEAM, and after a run +// that found nothing it says Organized until something changes. +func TestOrganizeCountAndOrganizedStates(t *testing.T) { + for pname, pal := range wallTestPalettes() { + v := wallUnmarked(wallFixture(6)) + v.team = "" + v.org.loose = 7 + rows, _ := renderWall(pal, v, 120, 40) + want := "✦ Organize 7" + if pal.ascii { + want = "* Organize 7" + } + if got := ansi.Strip(rows[1]); !strings.Contains(got, want) { + t.Fatalf("%s: the Teams row %q lacks %q", pname, got, want) + } + v.org.loose = 4 + rows, _ = renderWall(pal, v, 120, 40) + if got := ansi.Strip(rows[1]); strings.Contains(got, "Organize 4") || !strings.Contains(got, "Organize ") { + t.Fatalf("%s: under five the row is %q", pname, got) + } + v.org.clean = true + rows, _ = renderWall(pal, v, 120, 40) + want = "Organized ✓" + if pal.ascii { + want = "Organized" + } + if got := ansi.Strip(rows[1]); !strings.Contains(got, want) { + t.Fatalf("%s: the clean row %q lacks %q", pname, got, want) + } + } + + // On the app: a run that finds nothing says so beside a Close, and the + // button says Organized until the teams change. + p := &proposingAgent{} + a := organizeApp(t, func(inner Agent) Agent { p.Agent = inner; return p }) + tiles := a.wallShown(a.now()) + var lab []chatTab + for _, tile := range tiles { + if tile.tab.where == "/tmp/lab" { + lab = append(lab, tile.tab) + } + } + if _, err := a.teamMake("lab", lab); err != nil { + t.Fatal(err) + } + cmd := a.wallOrganizeOpen() + if !a.wall.org.thinking || !strings.Contains(orgFrame(a), "thinking…") { + t.Fatalf("the card does not say it is thinking:\n%s", orgFrame(a)) + } + namerDoors(t, a, cmd) + if frame := orgFrame(a); !strings.Contains(frame, "Everything is organized") || !strings.Contains(frame, "Close esc") { + t.Fatalf("an empty run:\n%s", frame) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + if frame := orgFrame(a); !strings.Contains(frame, "Organized ✓") { + t.Fatalf("the button does not say Organized:\n%s", frame) + } + if _, err := a.teamMake("orbit", []chatTab{tiles[0].tab}); err != nil { + t.Fatal(err) + } + if frame := orgFrame(a); strings.Contains(frame, "Organized ✓") || !strings.Contains(frame, "✦ Organize") { + t.Fatalf("a change left the button saying Organized:\n%s", frame) + } +} + +// A FAILED MODEL PASS SHOWS THE FOLDER PASS ALONE; a good one is merged in +// and priced. +func TestOrganizeModelFailureFallsBackToFolders(t *testing.T) { + p := &proposingAgent{err: errors.New("no provider answered")} + a := organizeApp(t, func(inner Agent) Agent { p.Agent = inner; return p }) + cmd := a.wallOrganizeOpen() + namerDoors(t, a, cmd) + if !a.wall.org.folderOnly || len(a.wall.org.props) != 1 || a.wall.org.props[0].name != "lab" { + t.Fatalf("after a failure: %+v", a.wall.org) + } + if frame := orgFrame(a); !strings.Contains(frame, "suggestions from folders only") { + t.Fatalf("the card does not say it is folders only:\n%s", frame) + } + if len(p.in.Conversations) != 3 || p.in.Conversations[0].Folder == "" { + t.Fatalf("the model was asked about %+v", p.in.Conversations) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + + var lab, leadgen string + for _, tile := range a.wallShown(a.now()) { + switch tile.tab.where { + case "/tmp/lab": + lab = tile.tab.key + case "/tmp/leadgen": + leadgen = tile.tab.key + } + } + p.err = nil + p.res = session.TeamProposal{ + New: []session.ProposedTeam{{Name: "scrapers", Members: []string{lab, leadgen}, Reason: "both scrape"}}, + Model: "some/unpriced-model", + PromptChars: 4000, + } + cmd = a.wallOrganizeOpen() + namerDoors(t, a, cmd) + o := a.wall.org + if o.folderOnly || len(o.props) != 2 || o.props[0].name != "lab" || o.props[1].name != "scrapers" { + t.Fatalf("after an answer: %+v", o.props) + } + if o.props[0].hue == o.props[1].hue { + t.Fatal("two new teams were offered one colour") + } + frame := orgFrame(a) + if !strings.Contains(frame, "about 1.3k tokens") || strings.Contains(frame, "folders only") { + t.Fatalf("the priced card:\n%s", frame) + } + if p.calls != 2 { + t.Fatalf("%d asks, want one per press", p.calls) + } +} + +// orgFixture is a view with the card up over six tiles: two new teams, one +// with a long name and long titles, and an addition. +func orgFixture(pal palette) wallView { + v := wallUnmarked(wallFixture(6)) + v.team = "" + v.org.on = true + v.org.loose = 6 + v.org.cost = "about $0.0020" + reserved := teamReservedFrom(darkRamp) + hues := wallViewHues(v) + h1 := nextTeamHue(hues, reserved) + h2 := nextTeamHue(append(hues, h1), reserved) + v.org.props = []orgProp{ + {name: "codeaf", hue: h1, keys: []string{"k0", "k1", "k2", "k3", "k4"}, names: []string{"a", "b", "c", "d", "e"}, folder: true, take: true}, + {name: "nvda research", hue: h2, keys: []string{"k1", "k2", "k5"}, names: []string{"cpu profiling", "nvda deep dive into the tree", "10-K"}, reason: "one company", take: true}, + {team: wallTestIDs[0], name: "port", hue: v.teams[0].hue, keys: []string{"k3", "k4"}, names: []string{"relay audit", "footprint table"}, take: false}, + } + return v +} + +// EVERY ROW FITS AND EVERY TARGET LIES ON ITS LABEL, at 80, 120 and 180 +// columns, in both tiers, with the card up and with the button and the minimap +// sharing the Teams row. +func TestOrganizeRowWidths(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, sz := range [][2]int{{80, 24}, {120, 40}, {180, 50}, {80, 12}} { + w, h := sz[0], sz[1] + for _, n := range []int{6, 13} { + v := orgFixture(pal) + if n != 6 { + big := wallUnmarked(wallFixture(n)) + big.team, big.org = "", v.org + v = big + } + for _, cardOn := range []bool{true, false} { + v.org.on = cardOn + name := fmt.Sprintf("%s/%dx%d/n%d/card%v", pname, w, h, n, cardOn) + rows, hits := renderWall(pal, v, w, h) + wallCheckRows(t, name, rows, w, h) + wallCheckHits(t, name, hits, w, h) + for _, hit := range hits { + label := ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0, hit.x1)) + switch { + case hit.kind == wallHitAction && hit.arg == int(wallActOrganize): + if !strings.Contains(label, "Organize") { + t.Fatalf("%s: the button's target lies on %q", name, label) + } + case hit.kind == wallHitAction && hit.arg == int(wallActOrgApply): + if strings.TrimSpace(label) != "Apply "+wallKeysFor(pal.ascii).enter { + t.Fatalf("%s: Apply's target lies on %q", name, label) + } + case hit.kind == wallHitOrgRow: + if !strings.Contains(label, v.org.props[hit.arg].name[:4]) { + t.Fatalf("%s: row %d's target lies on %q", name, hit.arg, label) + } + } + } + } + } + } + } + // The mock's rows, at 120. + pal := wallTestPalettes()["unicode"] + rows, _ := renderWall(pal, orgFixture(pal), 120, 40) + frame := wallPlainFrame(rows) + for _, want := range []string{ + "☑ ● codeaf 5 from the folder", + "☑ ● nvda research 3 cpu profiling, nvda deep dive…, 10-K", + "☐ ● port + 2 relay audit, footprint table", + "about $0.0020", + } { + if !strings.Contains(frame, want) { + t.Fatalf("the card lacks %q:\n%s", want, frame) + } + } +} + +// THE FRAMES, printed for a person to look at: the All header with the +// button, the card with suggestions, and the Undo on the Teams row. +func TestOrganizePrintsFrames(t *testing.T) { + pal := wallTestPalettes()["unicode"] + v := wallUnmarked(wallFixture(6)) + v.team = "" + v.org.loose = 6 + v.hover = wallHitRef{kind: wallHitAction, arg: int(wallActOrganize)} + rows, _ := renderWall(pal, v, 120, 40) + t.Logf("120x40, All with the Organize button hovered:\n%s", wallPlainFrame(rows)) + + rows, _ = renderWall(pal, orgFixture(pal), 120, 40) + t.Logf("120x40, the Organize card:\n%s", wallPlainFrame(rows)) + + v.hover = wallHitRef{} + v.org.doneAt, v.org.made, v.org.added = wallTestNow.Add(-2e9), 2, 2 + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("120x40, after Apply, Undo offered:\n%s", wallPlainFrame(rows)) +} diff --git a/internal/tui3/teamrail.go b/internal/tui3/teamrail.go new file mode 100644 index 0000000000..bff0b797fb --- /dev/null +++ b/internal/tui3/teamrail.go @@ -0,0 +1,180 @@ +package tui3 + +import ( + "strings" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TRAFFIC'S WORDS ───────────────────────────────────────────────────── +// +// The Traffic is read on the side column, as its second word (sidecol.go and +// sidetraffic.go draw it). This file is the vocabulary both it and the thread +// cards in the conversation spell an entry with: an address, whether an entry +// is drawn at all, whether it is a member asking the person, how old it is, +// and what the person has already had in front of them. +// +// EVERY HANDLE IS A DOOR to its member, and a message's words are a door to +// the message; a word about the whole team (`everyone`) is not, and does not +// light. Under the pointer the hint line says what a press does, and over a +// message its whole text. + +const ( + // trafficHandleCap is the most cells one address takes on a row. + trafficHandleCap = 10 + // trafficKey shows or hides the side column, and teamManagerKey goes to the + // team's manager. Both were free in keys.md and in every key map here. + trafficKey = "alt+l" + teamManagerKey = "alt+m" +) + +// ── ONE ROW ───────────────────────────────────────────────────────────────── + +// trafficAddr is one address of an entry as the rail spells it: `@handle`, the +// manager's mark, or the word for everyone, cut to [trafficHandleCap]. +func (a *app) trafficAddr(s string) string { + switch s { + case teamstore.FromManager: + return a.teamManagerMark() + case teamstore.FromSystem: + return "codeaf" + case teamstore.ToEveryone: + return "all" + case teamstore.ToRoom: + return "room" + case "": + return "" + } + word := "@" + s + if ansi.StringWidth(word) > trafficHandleCap { + word = ansi.Truncate(word, trafficHandleCap, a.linearMark("…", "~")) + } + return word +} + +// trafficShown reports whether an entry is drawn at all. The person's own +// words are in the manager's conversation already, where they said them. A +// wake is drawn only as the `working…` of the thread it answers +// (teamthread.go), so one that answers nothing, and a member waking the +// manager, which the manager's own turn already shows, are not drawn. +func trafficShown(e teamstore.Entry) bool { + // A RULING THE PERSON MADE is still a ruling every party's log carries, + // so it is drawn, as `you ruling → …` (teamthread.go). + if teamstore.IsRuling(e) { + return true + } + if e.Kind == teamstore.KindYou || e.From == teamstore.FromYou { + return false + } + if e.Wake() { + return e.Answers != "" && e.From == teamstore.FromManager + } + return true +} + +// trafficAsking reports whether an event is a member waiting on the person, +// the one row on the rail in the needs-you amber. +func trafficAsking(e teamstore.Entry) bool { + if e.Kind != teamstore.KindEvent { + return false + } + if e.State != "" { + return e.State == teamstore.StateAsking + } + text := strings.ToLower(strings.TrimSpace(e.Text)) + return strings.HasPrefix(text, "ask") || strings.HasPrefix(text, "needs you") +} + +// trafficAge is how long ago an entry was written, in the same few cells a +// task row and a home session use ([sinceAt]): `now`, `2m`, `3h`, `1d`. One +// ladder, so a row and the home never disagree about what two minutes is. +func (a *app) trafficAge(e teamstore.Entry) string { + return sinceAt(e.At, a.now()) +} + +// trafficBelongsTo is the conversation a Traffic entry was written in. A +// message the sender wrote belongs in the sender's chat: the manager's mark +// is the manager, a handle is that member. A message put to the person +// belongs in the manager's chat, which is where the person reads it. +func (a *app) trafficBelongsTo(t team, e teamstore.Entry) string { + if e.To == teamstore.ToYou { + return t.Manager + } + switch e.From { + case teamstore.FromManager, teamstore.FromYou, teamstore.FromSystem, "": + return t.Manager + } + if m, ok := t.ByHandle(e.From); ok { + return m.Key + } + return t.Manager +} + +// trafficSenderWord is who a row says the message is from, the same word the +// row draws: the manager's mark, `you` for this member, `codeaf`, or `@handle`. +func (a *app) trafficSenderWord(from, self string) string { + if self != "" && (from == self || from == "@"+self) { + return "you" + } + switch from { + case teamstore.FromManager: + return a.teamManagerMark() + case teamstore.FromYou: + return "you" + case teamstore.FromSystem: + return "codeaf" + case "": + return "it" + } + return "@" + strings.TrimPrefix(from, "@") +} + +// trafficOpenHint is the hint over a row that opens a message: who wrote it, +// how long ago, then whatever else the row gave up, then the click. +func trafficOpenHint(sender, age, extra string) string { + head := "Open " + sender + "'s message" + if sender == "you" { + head = "Open your message" + } + out := head + switch age { + case "": + case "now": + out += hintSegment + "now" + default: + out += hintSegment + age + " ago" + } + if extra != "" { + out += hintSegment + extra + } + return out + hintSegment + "click" +} + +// trafficMarkSeen records that the person has team t's newest entry in front of +// them. It is memory, written by the frame that showed it. +func (a *app) trafficMarkSeen(t team) { + rows := a.traffic.rows[t.ID] + if len(rows) == 0 { + return + } + if a.traffic.seen == nil { + a.traffic.seen = map[string]string{} + } + a.traffic.seen[t.ID] = rows[len(rows)-1].ID +} + +// trafficRulingText is a ruling's words without the lead the store writes +// (`ruling on the conflict p…, `), which the row's head already says. +func trafficRulingText(text string) string { + const lead = "ruling on the conflict " + if !strings.HasPrefix(text, lead) { + return text + } + rest := text[len(lead):] + if at := strings.Index(rest, ", "); at >= 0 && at < 40 { + return rest[at+2:] + } + return rest +} diff --git a/internal/tui3/teamrailpointer.go b/internal/tui3/teamrailpointer.go new file mode 100644 index 0000000000..3a2160be34 --- /dev/null +++ b/internal/tui3/teamrailpointer.go @@ -0,0 +1,119 @@ +package tui3 + +import ( + tea "charm.land/bubbletea/v2" +) + +// ── THE TRAFFIC'S KEYS AND DOORS (teamrail.go says what it is) ───────────── + +// trafficToggle lays one message out in full under a thread card, or folds it +// again. It moves no focus and changes nothing but what the cards draw. +func (a *app) trafficToggle(key string) { + if a.traffic.open == nil { + a.traffic.open = map[string]bool{} + } + if a.traffic.open[key] { + delete(a.traffic.open, key) + } else { + a.traffic.open[key] = true + } + a.traffic.opened++ + a.touch() +} + +// trafficGo switches to member key: its tab when the strip has one, and +// otherwise what the team kept of it, which is enough to open it again. +func (a *app) trafficGo(key string) tea.Cmd { + if key == "" || key == a.frontTabKey() { + return nil + } + for _, tab := range a.tabList() { + if tab.key == key { + return a.tabGo(tab) + } + } + if held := a.behind[key]; held != nil { + cmd, _ := a.bringForward(held.conv.SessionFile) + return cmd + } + for _, t := range a.wall.teams { + if m, ok := t.Member(key); ok && m.File != "" { + return a.tabGo(chatTab{key: m.Key, file: m.File, where: m.Where, word: m.Word, full: m.Word}) + } + } + return nil +} + +// trafficKeyPress takes two keys on the conversation: [trafficKey] shows or +// hides the side column (sidecol.go's [app.sideToggle]), and [teamManagerKey] +// goes to the team's manager. Every overlay and page that owns the keyboard is +// read before it and keeps these keys. +func (a *app) trafficKeyPress(msg tea.KeyPressMsg) (tea.Cmd, bool) { + key := msg.String() + if key != trafficKey && key != teamManagerKey { + return nil, false + } + if a.asking() || a.at(pageSettings) || a.at(pageTasks) || a.at(pageHome) || a.pick.open || + a.copy.on || a.welcome.open || a.menu.open || a.comp.open || a.effPick.open || a.wall.on { + return nil, false + } + if key == trafficKey { + return nil, a.sideToggle() + } + t, ok := a.teamOfFront() + if !ok || t.Manager == "" { + return nil, false + } + if a.teamsOff() { + a.note(teamHostedWord) + return nil, true + } + return a.trafficGo(t.Manager), true +} + +// teamOfFront is the team the conversation in front belongs to and is run +// from: the team shown when it holds it, else the first managed team that +// does, else the team shown. Frame-safe: memory only. +func (a *app) teamOfFront() (team, bool) { + if !a.wall.loaded { + return team{}, false + } + front := a.frontTabKey() + shown, showing := a.teamActive() + if showing && teamHolds(shown, front) { + return shown, true + } + for _, t := range a.wall.teams { + if t.Manager != "" && teamHolds(t, front) { + return t, true + } + } + return shown, showing +} + +// trafficHint is the composer's placeholder in a managed team: the person's +// words go to the manager when it is in front and to the member when one is, +// and the box says which. "" elsewhere. Frame-safe, allocation free for every +// conversation that is not in a managed team. +func (a *app) trafficHint() string { + if a.teamsOff() || !a.wall.loaded || len(a.wall.teams) == 0 { + return "" + } + // On the teams page the box says which team as well as who. + if words := a.teamsComposerWord(); words != "" { + return words + } + if _, ok := a.teamFrontManaged(); ok { + return "to " + a.teamManagerMark() + " manager" + } + front := a.frontTabKey() + for _, t := range a.wall.teams { + if t.Manager == "" { + continue + } + if m, ok := t.Member(front); ok && m.Handle != "" { + return "to @" + m.Handle + } + } + return "" +} diff --git a/internal/tui3/teamrenamelabel_test.go b/internal/tui3/teamrenamelabel_test.go new file mode 100644 index 0000000000..1837ece39b --- /dev/null +++ b/internal/tui3/teamrenamelabel_test.go @@ -0,0 +1,72 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// A RENAME REACHES THE LABELS THAT SAY THE NAME. The side column caches the +// rows it drew, and the composer's `to ◆ name manager` is read when the box is drawn. +// Both follow the name the teams hold now, with no read of the disk. +func TestARenamedTeamUpdatesTheRunLabelAndTheComposer(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + if _, ok := a.teamByID(harbor); !ok { + t.Fatal("no harbor") + } + start := teamstore.Entry{ + ID: "000000000008", Kind: teamstore.KindStart, From: teamstore.FromManager, + To: "api", Team: orbit, Text: "run it", + } + if a.traffic.rows == nil { + a.traffic.rows = map[string][]teamstore.Entry{} + } + a.traffic.rows[harbor] = []teamstore.Entry{start} + // The start is chatter, so it is a line of the General thread, laid open. + a.sideToggleThread(sideThreadKey(harbor, sideGeneral)) + draw := func() string { + t, _ := a.teamByID(harbor) + s := &sideSheet{a: a, t: t, width: 70} + s.threads(sideKindManager, "") + var rows []string + for _, l := range s.lines { + rows = append(rows, l.text) + } + return ansi.Strip(strings.Join(rows, "\n")) + } + if got := draw(); !strings.Contains(got, "to run orbit") { + t.Fatalf("the start does not name the team it made:\n%s", got) + } + a.side.traffic = sideTrafficCache{lines: []railLine{{text: "to run orbit"}}} + if err := a.teamRename(orbit, "backend"); err != nil { + t.Fatal(err) + } + if a.side.traffic.lines != nil { + t.Fatal("the rename left the column's cached rows, which still carry the old name") + } + got := draw() + if strings.Contains(got, "to run orbit") || !strings.Contains(got, "to run backend") { + t.Fatalf("after the rename the column still says the old name:\n%s", got) + } + + a.tp.sel = harbor + a.tp.host = a.frontTabKey() + before := a.teamsComposerWord() + if !strings.Contains(before, "harbor") { + t.Fatalf("the composer does not name the team: %q", before) + } + if err := a.teamRename(harbor, "dock"); err != nil { + t.Fatal(err) + } + after := a.teamsComposerWord() + if strings.Contains(after, "harbor") || !strings.Contains(after, "dock") { + t.Fatalf("after the rename the composer says %q", after) + } + a.input.insert("hi") + if pieces := a.seamPieces(120); !strings.Contains(pieces.name, "dock") { + t.Fatalf("the seam kept the old team: %q", pieces.name) + } +} diff --git a/internal/tui3/teams.go b/internal/tui3/teams.go new file mode 100644 index 0000000000..14ba7f8f72 --- /dev/null +++ b/internal/tui3/teams.go @@ -0,0 +1,734 @@ +package tui3 + +import ( + "errors" + "fmt" + "path/filepath" + "strconv" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── TEAMS: NAMED SETS OF CONVERSATIONS, KEPT ON THEIR OWN FILE ───────────── +// +// A team is a set of conversations a person marked on the wall and named. +// Activating one narrows the tab strip to its members; leaving it widens the +// strip again. Neither ever ends work: the strip's own law (chattabs.go) is +// that the × closes a view, never work, and a team is only a view of the +// strip. A member whose tab was closed is still a member, and it carries the +// file and the workspace it needs to be opened again. +// +// A TEAM IS KNOWN BY ITS ID, NEVER BY ITS PLACE OR ITS NAME. The id is random +// and minted once; the active team, each team's remembered place on the wall, +// an open popover and every pointer target name a team by it, so deleting or +// reordering one never moves any of those onto another. The name is the +// person's and may change. +// +// THE STORE IS internal/teams. The file, the ids, the tree, the migration from +// the first build's spaces.json, handles, the manager and the lock two writers +// share all live there, because the team tools a model calls (internal/session) +// write the same file. What is here is the interface's side: which tabs make a +// team, how a team is named on the card, what the strip shows. +// +// EVERY EDIT HERE IS THE STORE'S READ-MODIFY-WRITE ([app.teamEdit], over +// [TeamsSeam.Update]). The change is made to what this window loaded, so the +// person sees it at once and keeps it even when the store refuses, and then +// made again, off the loop and under the store's lock, to the file as it is +// now, on whichever machine the session keeps it (teamseam.go); what that wrote +// is what the window holds afterwards. A manager, a handle or a member another +// process wrote since the opening is therefore kept, where saving the whole +// loaded list would have put the old list back over it. +// +// THE FRAME NEVER READS IT (framedisk_law_test.go). The file is read once, by +// [app.teamsEnsure], on an opening (the wall, an alt+digit, the strip chip); +// every function a frame calls reads only what that loaded. + +// teamsFile is the file's name inside the profile directory, and +// teamsLegacyFile the first build's. +const ( + teamsFile = teamstore.FileName + teamsLegacyFile = teamstore.LegacyFileName +) + +// teamNameCells is the widest a suggested name may be, in cells. +const teamNameCells = 16 + +// newTeamID is a fresh random id ([teamstore.NewID]). +func newTeamID() string { return teamstore.NewID() } + +// teamIndex is where the team with id sits in teams, -1 when it is not there. +func teamIndex(teams []team, id string) int { return teamstore.Index(teams, id) } + +// ── THE TREE ──────────────────────────────────────────────────────────────── + +// teamTree is the loaded sets as the store's file, for its tree walks. It +// shares the slice, so a change through it is a change to the loaded sets. +func (a *app) teamTree() *teamstore.File { return &teamstore.File{Teams: a.wall.teams} } + +// teamByID is the team with id. Frame-safe: memory only. +func (a *app) teamByID(id string) (team, bool) { return a.teamTree().Team(id) } + +// teamChildren is every team whose parent is id, in stored order; id "" is +// the top level. +func (a *app) teamChildren(id string) []team { return a.teamTree().Children(id) } + +// teamAncestors is id's parent, its parent's parent, and so on to the top, +// nearest first. +func (a *app) teamAncestors(id string) []team { return a.teamTree().Ancestors(id) } + +// teamSetParent puts team id under parent, or at the top level for "". The +// parent must exist and may not be the team or anything under it. It is the +// tree's one door and nothing in the interface opens it yet. +func (a *app) teamSetParent(id, parent string) error { + return a.teamEdit(func(f *teamstore.File) error { return f.SetParent(id, parent) }) +} + +// ── MEMBERS AND NAMES ─────────────────────────────────────────────────────── + +// teamFromTabs makes a team of the given tabs. The start tab and the work +// tab are pages of this window rather than conversations, and a tab with no +// key is nothing that could be found again, so none of those become members. +// A key already taken is taken once. +func teamFromTabs(name string, tabs []chatTab, now time.Time) team { + t := team{Name: name, Made: now} + for _, tab := range tabs { + if tab.start || tab.work || tab.key == "" || teamHolds(t, tab.key) { + continue + } + t.Members = append(t.Members, teamMember{Key: tab.key, File: tab.file, Where: tab.where, Word: tab.word}) + } + return t +} + +// teamHolds reports whether key is one of t's members. +func teamHolds(t team, key string) bool { return t.Holds(key) } + +// teamSuggestName is a short name for tabs from their own words. Conversations +// that all sit in one workspace are most likely that project's, so its folder +// name is the suggestion; otherwise the first conversation's first word is. +// It is lowercased and cut to [teamNameCells] so it fits the strip's corner. +func teamSuggestName(tabs []chatTab) string { + if name := teamFolder(tabs); name != "" { + return name + } + first := "" + for _, tab := range tabs { + if tab.start || tab.work || tab.key == "" { + continue + } + if words := strings.Fields(tab.word); len(words) > 0 { + first = words[0] + break + } + } + return ansi.Truncate(strings.ToLower(first), teamNameCells, "") +} + +// teamFolder is the folder name every conversation in tabs shares, lowercased +// and cut to [teamNameCells], or "" when they do not all sit in one. +func teamFolder(tabs []chatTab) string { + where, shared := "", true + for _, tab := range tabs { + if tab.start || tab.work || tab.key == "" { + continue + } + w := filepath.Clean(tab.where) + if tab.where == "" { + shared = false + } else if where == "" { + where = w + } else if w != where { + shared = false + } + } + if !shared || where == "" { + return "" + } + base := filepath.Base(where) + if base == "/" || base == "." { + return "" + } + return ansi.Truncate(strings.ToLower(base), teamNameCells, "") +} + +// teamWords is the short list a new team's name is drawn from when its +// conversations share no folder: plain, pleasant, easy to say and to type. +var teamWords = []string{"harbor", "orbit", "lumen", "atlas", "ember", "quartz", "ridge", "tide", "cedar", "delta", "north", "prism"} + +// teamFreshName is the name the new-team card starts with. Conversations +// that share a folder get the folder's name; otherwise it is a word from +// [teamWords]. It is never a name a team already has, compared without case, +// because [app.teamMake] would read that as editing the team that has it. +// not is the name being shuffled away from, and it also turns the folder off: +// a person asking for another name has seen that one. pick is the dice, so a +// test can load them. +func teamFreshName(tabs []chatTab, taken []string, not string, pick func(int) int) string { + used := func(name string) bool { + if strings.EqualFold(name, not) { + return true + } + for _, t := range taken { + if strings.EqualFold(t, name) { + return true + } + } + return false + } + if not == "" { + if name := teamFolder(tabs); name != "" && !used(name) { + return name + } + } + var free []string + for _, w := range teamWords { + if !used(w) { + free = append(free, w) + } + } + if len(free) > 0 { + return free[pick(len(free))] + } + // Every word is taken: the words again, numbered. + base := teamWords[pick(len(teamWords))] + for n := 2; ; n++ { + if name := base + strconv.Itoa(n); !used(name) { + return name + } + } +} + +// teamTabs is t's members THIS WINDOW HAS OPEN, as strip tabs, in the order +// the person stored them. A member this window still has a tab for is THAT +// tab, so its here, held and signal are the strip's own and a press attaches +// rather than opens. +// +// A MEMBER THIS WINDOW DOES NOT HAVE OPEN GETS NO TAB. The strip is what is +// open in this window, narrowed to the team; a team's whole membership lives +// on the team, and the wall's `2 more in test · Open them` is the door to the +// rest ([app.wallResumeAway]). Drawing a closed member as a tab made the strip +// and the wall disagree about the same team: three tabs over a wall of one. +// +// held is whether the keeper holds a conversation behind this window. A member +// the manager started is held from its first moment but has no title yet, so +// the strip's list does not carry it ([app.tabList] draws no nameless tab); +// it is open all the same, and is drawn by its handle, `@lexer`, until its +// first answer names it. +func teamTabs(t team, live []chatTab, held func(key string) bool) []chatTab { + out := make([]chatTab, 0, len(t.Members)) + for _, m := range t.Members { + tab, found := chatTab{}, false + for _, l := range live { + if l.key == m.Key { + tab, found = l, true + break + } + } + if !found { + if held == nil || !held(m.Key) { + continue + } + word := m.Word + if strings.TrimSpace(word) == "" && m.Handle != "" { + word = "@" + m.Handle + } + if strings.TrimSpace(word) == "" { + continue + } + tab = chatTab{key: m.Key, file: m.File, where: m.Where, word: word, full: word} + } + out = append(out, tab) + } + return out +} + +// teamHeldOpen is [teamTabs]' held: a conversation the keeper holds whose tab +// the person has not closed. Memory only. +func (a *app) teamHeldOpen(key string) bool { + return a.behind[key] != nil && !a.tabShut[key] +} + +// teamAway is the members of t this window does not have open: no tab on the +// strip's list, and not held behind. They are still members; the wall offers +// to resume them ([app.wallResumeAway]). Frame-safe: memory only. +func (a *app) teamAway(t team, tabs []chatTab) []teamMember { + var out []teamMember + for _, m := range t.Members { + if m.Key == "" || tabsHold(tabs, m.Key) || a.teamHeldOpen(m.Key) { + continue + } + out = append(out, m) + } + return out +} + +// ── THE APP'S SETS ────────────────────────────────────────────────────────── + +// teamsEnsure loads the sets the first time anything needs them, through the +// seam's [TeamsSeam.Load], which answers without blocking: locally one small +// file read at an opening, over a connection what is held. It is called on an +// opening and never from a frame. +// +// A SEAM THAT HOLDS NOTHING YET IS ASKED OFF THE LOOP. Over a connection the +// first opening may come before the engine's answer; the window then holds no +// teams and asks [TeamsSeam.ReadSince] beside the loop ([app.teamsWrite]), and the +// answer is folded in when it comes ([app.teamsTake]). +func (a *app) teamsEnsure() { + if a.wall.loaded { + return + } + // A window with no teams it can keep holds none, and reads nothing: this + // machine's own file is not the session's ([app.teamsOff]). + if a.teamsOff() { + a.wall.loaded, a.wall.activeID, a.wall.teams = true, "", nil + return + } + teams, stamp, known := a.teamsSeam().Load(teamReservedHues(a.pal)) + if !known { + a.teamsDisk.fetch = true + return + } + a.wall.loaded = true + a.wall.activeID = "" + a.wall.teams = teams + a.traffic.stamp = stamp +} + +// errTeamsHosted is [app.teamEdit]'s refusal over --host when the engine has +// no teams doors ([app.teamsOff]). +var errTeamsHosted = errors.New("teams are not kept over --host yet") + +// teamEdit makes one change to the teams, and it is the only way the +// interface writes them. +// +// THE CHANGE IS MADE TWICE, AND THAT IS THE POINT. First to what this window +// holds, so the strip and the wall show it on this frame and keep it when the +// store refuses (the note says the store did not take it, and the change stays +// "for this window"). Then again, off the loop, inside the store's +// read-modify-write ([app.teamsWrite], [TeamsSeam.Update]), to the file as it +// is now, so a manager, a handle, a member or a whole team another process +// wrote since this window loaded is kept rather than replaced. What that +// second pass wrote, tidied and coloured, is what the window holds afterwards +// ([app.teamsTake]). So change must depend only on the file it is handed and +// on values its caller chose beforehand: an id minted inside it would be two +// ids, and over a connection it may be made a third time. +// +// Each member this window has an open tab for takes the tab's current name on +// the way ([app.teamRefreshWords]), which is how a conversation that joined +// before it had a title gets one, and with it a handle ([teamstore.DeriveHandle] +// through the store's tidy). +// +// It touches no disk and no wire: the error it returns is the change refusing +// what this window holds, and a refusal from the store arrives later, as a note. +func (a *app) teamEdit(change func(f *teamstore.File) error) error { + // A WINDOW WITH NO TEAMS IT CAN KEEP WRITES NOTHING. Over --host facing an + // engine without the teams doors, this window's own file is not the + // session's, and a member kept here would be a path the far session never + // sees (host.go). + if a.teamsOff() { + return errTeamsHosted + } + a.teamsEnsure() + mine := &teamstore.File{Version: teamstore.Version, Teams: teamsClone(a.wall.teams)} + if err := change(mine); err != nil { + return err + } + a.teamRefreshWords(mine.Teams) + a.wall.teams = mine.Teams + // THE SIDE COLUMN REMEMBERS THE ROWS IT DREW, keyed by everything but a + // team's name (sidetraffic.go's [sideTrafficCacheKey]). A rename would + // otherwise leave `to run <old name>` on screen until something else moved + // the key. The next frame reads the name from the teams it now holds. + a.side.traffic = sideTrafficCache{} + // A window still waiting on its first read over a connection holds only + // this edit; the write brings the whole list back ([app.teamsTake]). + a.wall.loaded = true + // A Traffic read already out may carry the file from before this write; + // counting the edit keeps it from being put back (teamtraffic.go). + a.traffic.edits++ + a.teamsDisk.queue = append(a.teamsDisk.queue, change) + return nil +} + +// teamAdopt makes teams what this window holds: a list that came off the disk, +// newer than the one loaded. The active team is cleared when it is gone, and +// nothing else moves, because everything else names a team by its id. +// +// A time a change put on a team came from the clock and carries its monotonic +// reading, which the same time read back from the file does not; it is dropped +// here, so a team is the same value whichever way it reached this window. +func (a *app) teamAdopt(teams []team) { + for i := range teams { + teams[i].Made = teams[i].Made.Round(0) + } + a.wall.teams = teams + if a.wall.activeID != "" && teamIndex(teams, a.wall.activeID) < 0 { + a.wall.activeID = "" + } +} + +// teamRefreshWords gives each member of teams that this window has an open tab +// for the tab's current name. A member keeps the name it has when its tab has +// none, or is a page rather than a conversation. +func (a *app) teamRefreshWords(teams []team) { + for i := range teams { + for j, m := range teams[i].Members { + for _, tab := range a.chatTabs { + if tab.key == m.Key && strings.TrimSpace(tab.word) != "" && !tab.start && !tab.work { + teams[i].Members[j].Word = tab.word + break + } + } + } + } +} + +// teamMake keeps tabs as a team called name and returns its id. A name +// already used, compared without case, is the same team with new members, so +// marking a second time is how a team is edited. The set is kept in memory +// even when the save fails, and the error says the disk did not take it. +func (a *app) teamMake(name string, tabs []chatTab) (string, error) { + a.teamsEnsure() + return a.teamMakeHued(name, tabs, nextTeamHue(a.teamHues(""), teamReservedHues(a.pal))) +} + +// teamHues is every team's colour but the one with id skip ("" skips none). +func (a *app) teamHues(skip string) []teamHueSpec { + out := make([]teamHueSpec, 0, len(a.wall.teams)) + for _, t := range a.wall.teams { + if skip == "" || t.ID != skip { + out = append(out, t.HueSpec()) + } + } + return out +} + +// teamMakeHued is [app.teamMake] with the colour chosen: the new-team card +// offers several and the person may take any. A team remade under a name it +// already has keeps its id, its place in the tree and its colour. +func (a *app) teamMakeHued(name string, tabs []chatTab, hue teamHueSpec) (string, error) { + return a.teamMakeIn(name, tabs, hue, "") +} + +// teamMakeIn is [app.teamMakeHued] with the team made inside parent ("" the +// top level). A new team under a parent with a cap is handed the parent's +// sub-team share of it as its own cap ([teamstore.File.SubTeamCap]), as the +// session's own sub-team start does, and a team remade under a name it +// already has stays where it is. +func (a *app) teamMakeIn(name string, tabs []chatTab, hue teamHueSpec, parent string) (string, error) { + a.teamsEnsure() + name = strings.TrimSpace(name) + if name == "" { + return "", errors.New("a team needs a name") + } + t := teamFromTabs(name, tabs, time.Now()) + if len(t.Members) == 0 { + return "", errors.New("a team needs at least one conversation") + } + // The id is minted here, once, and the change below only uses it: the + // change is made twice ([app.teamEdit]) and must name the same team both + // times. + fresh := newTeamID() + id := fresh + defaults := a.tp.defaults + err := a.teamEdit(func(f *teamstore.File) error { + at := teamNamed(f.Teams, name) + if at < 0 { + made := t.Clone() + made.ID = fresh + made.SetHue(hue) + if parent != "" { + if p, ok := f.Team(parent); ok && !p.Closed() { + made.Parent = parent + if c := f.SubTeamCap(parent, defaults); c > 0 { + made.Settings.CapUSDDay = &c + } + } + } + f.Teams = append(f.Teams, made) + id = fresh + return nil + } + // A team remade under its name keeps what its members already had (a + // handle above all) and keeps its manager while the manager is still + // one of them; the store's tidy clears a manager that is not. + old := &f.Teams[at] + members := make([]teamMember, 0, len(t.Members)) + for _, m := range t.Members { + if kept, ok := old.Member(m.Key); ok { + kept.File, kept.Where = m.File, m.Where + if strings.TrimSpace(m.Word) != "" { + kept.Word = m.Word + } + m = kept + } + members = append(members, m) + } + old.Name, old.Members = name, members + id = old.ID + return nil + }) + return id, err +} + +// teamAt is the index of team id for a change, or an error naming it. +func (a *app) teamAt(id string) (int, error) { + a.teamsEnsure() + if i := teamIndex(a.wall.teams, id); i >= 0 { + return i, nil + } + return -1, fmt.Errorf("no team %s", id) +} + +// teamToggleMember puts tab into team id, or takes it out if it is there. +func (a *app) teamToggleMember(id string, tab chatTab) error { + i, err := a.teamAt(id) + if err != nil { + return err + } + if teamHolds(a.wall.teams[i], tab.key) { + return a.teamRemove(id, []string{tab.key}) + } + return a.teamAdd(id, []chatTab{tab}) +} + +// teamRecolor gives team id another colour. +func (a *app) teamRecolor(id string, hue teamHueSpec) error { + i, err := a.teamAt(id) + if err != nil { + return err + } + id = a.wall.teams[i].ID + return a.teamEdit(func(f *teamstore.File) error { + j := teamIndex(f.Teams, id) + if j < 0 { + return fmt.Errorf("no team %s", id) + } + f.Teams[j].SetHue(hue) + return nil + }) +} + +// teamRename gives team id another name. A name another team has, compared +// without case, is refused: two teams one name would be one team to +// [app.teamMake]. This and the new-team card are the only doors that name a +// team; nothing renames one on its own. +func (a *app) teamRename(id, name string) error { + i, err := a.teamAt(id) + if err != nil { + return err + } + name = strings.TrimSpace(name) + if name == "" { + return errors.New("a team needs a name") + } + for j, t := range a.wall.teams { + if j != i && strings.EqualFold(t.Name, name) { + return fmt.Errorf("there is already a team called %s", t.Name) + } + } + id = a.wall.teams[i].ID + return a.teamEdit(func(f *teamstore.File) error { + j := teamIndex(f.Teams, id) + if j < 0 { + return fmt.Errorf("no team %s", id) + } + f.Teams[j].Name = name + return nil + }) +} + +// teamsOf is the id of every team holding key, in order. Frame-safe: memory +// only. +func (a *app) teamsOf(key string) []string { + if !a.wall.loaded || key == "" { + return nil + } + var out []string + for _, t := range a.wall.teams { + if teamHolds(t, key) { + out = append(out, t.ID) + } + } + return out +} + +// teamAdd puts tabs into team id beside the members it already has, in the +// order given, each key once. It saves as [app.teamMake] does: the set is kept +// in memory even when the disk refuses it. +func (a *app) teamAdd(id string, tabs []chatTab) error { + i, err := a.teamAt(id) + if err != nil { + return err + } + id = a.wall.teams[i].ID + members := teamFromTabs("", tabs, time.Time{}).Members + return a.teamEdit(func(f *teamstore.File) error { + for _, m := range members { + // A member joins with a handle when it has a title + // ([teamstore.File.AddMember]); one already there is left as it is. + if err := f.AddMember(id, m); err != nil { + return err + } + } + return nil + }) +} + +// teamRemove takes the conversations with the given keys out of team id. The +// conversations are untouched, and so is the team, even when it is left +// holding nothing: a team emptied is still a name a person gave. +func (a *app) teamRemove(id string, keys []string) error { + i, err := a.teamAt(id) + if err != nil { + return err + } + id = a.wall.teams[i].ID + return a.teamEdit(func(f *teamstore.File) error { + for _, k := range keys { + // A manager taken out of its team is no longer its manager. + if err := f.RemoveMember(id, k); err != nil { + return err + } + } + return nil + }) +} + +// teamActivate narrows the strip to team id, or widens it to every tab for +// "" (or an id that is gone). It changes the view and nothing else. If the +// conversation in front is not a member, the strip would be narrowed away +// from the page the person is on, so it steps to the first member instead and +// returns that switch. +func (a *app) teamActivate(id string) tea.Cmd { + a.teamsEnsure() + t, ok := a.teamByID(id) + if !ok { + a.wall.activeID = "" + return nil + } + a.wall.activeID = id + if len(t.Members) == 0 || teamHolds(t, a.frontTabKey()) { + return nil + } + // A team with nothing open here narrows the strip to the tab in front, and + // the front stays where it is: nothing to step to is not a reason to open. + tabs := teamTabs(t, a.tabList(), a.teamHeldOpen) + if len(tabs) == 0 { + return nil + } + return a.tabGo(tabs[0]) +} + +// teamActive is the team the strip is narrowed to. It reads only memory and +// is safe from a frame; before the first load no team is active. +func (a *app) teamActive() (team, bool) { + if !a.wall.loaded { + return team{}, false + } + return a.teamByID(a.wall.activeID) +} + +// teamNames is every team's name in order. Frame-safe: memory only. +func (a *app) teamNames() []string { + if !a.wall.loaded { + return nil + } + names := make([]string, len(a.wall.teams)) + for i, t := range a.wall.teams { + names[i] = t.Name + } + return names +} + +// teamDelete forgets team id. Its conversations are untouched; only the name +// for the set goes. A team under it moves up to its parent, so the tree +// keeps every other team, and the active team is cleared only if it was this +// one: nothing else names a team by its place, so nothing else moves. +func (a *app) teamDelete(id string) error { + i, err := a.teamAt(id) + if err != nil { + return err + } + id = a.wall.teams[i].ID + if a.wall.activeID == id { + a.wall.activeID = "" + } + delete(a.wall.places, id) + return a.teamEdit(func(f *teamstore.File) error { + teamDrop(f, id) + return nil + }) +} + +// teamDrop takes team id out of f and moves every team under it up to its +// parent. A team that is not there is nothing to drop. +func teamDrop(f *teamstore.File, id string) { + j := teamIndex(f.Teams, id) + if j < 0 { + return + } + parent := f.Teams[j].Parent + f.Teams = append(f.Teams[:j:j], f.Teams[j+1:]...) + for k := range f.Teams { + if f.Teams[k].Parent == id { + f.Teams[k].Parent = parent + } + } +} + +// teamJoinFront puts the conversation this window has just started, now in +// front, into the team the strip is narrowed to, so a new conversation opened +// while looking at a team is one of it. It is called from the two doors that +// mint a fresh conversation, /new and its road from the strip's + and the start +// page ([app.renewRefusing]) and a path typed on home ([app.startBeside]), at +// the moment the conversation first has its key. It is never called from a +// switch: moving to a conversation that already exists changes no team. +func (a *app) teamJoinFront() { + a.teamJoinNew(chatTab{key: a.convKey(a.file), file: a.file, where: a.workspace}) +} + +// teamJoinNew is [app.teamJoinFront] for any tab. With no team active it does +// nothing, and it never loads the file, because a team can only be active once +// it has been loaded. +func (a *app) teamJoinNew(tab chatTab) { + t, ok := a.teamActive() + if !ok || tab.key == "" || teamHolds(t, tab.key) { + return + } + if err := a.teamAdd(t.ID, []chatTab{tab}); err != nil { + a.note("the conversation is in " + t.Name + " for this window, but " + err.Error()) + } +} + +// teamStripTabs is what the strip draws given the tabs it would draw with no +// team. With a team active it is that team's members, plus the tab in front +// when it is not one of them: THE TAB YOU ARE ON NEVER VANISHES, because a +// strip that does not show where you are cannot show you the way back. With no +// team active the tabs come back unchanged. Frame-safe: memory only. +func (a *app) teamStripTabs(tabs []chatTab) []chatTab { + t, ok := a.teamActive() + if !ok { + return tabs + } + out := a.teamStripManager(t, teamTabs(t, tabs, a.teamHeldOpen)) + // A member held behind that the strip had no tab for yet (one the manager + // started) still says what it is doing, as every held tab does. + for i := range out { + if held := a.behind[out[i].key]; held != nil && !out[i].held { + out[i].held = true + out[i].signal = a.tabSignalFor(out[i].key, false) + } + } + for _, tab := range tabs { + if tab.here && !teamHolds(t, tab.key) { + out = append(out, tab) + break + } + } + return out +} diff --git a/internal/tui3/teams_test.go b/internal/tui3/teams_test.go new file mode 100644 index 0000000000..81e74b7fc2 --- /dev/null +++ b/internal/tui3/teams_test.go @@ -0,0 +1,475 @@ +package tui3 + +import ( + "bytes" + "encoding/json" + "fmt" + "github.com/Agent-Field/codeaf/internal/config" + + "os" + "path/filepath" + "reflect" + "strings" + "testing" + "time" +) + +func TestTeamMissingFileIsNoTeamsAndNoError(t *testing.T) { + got, err := loadTeams(t.TempDir(), nil) + if err != nil || got != nil { + t.Fatalf("missing file: %v, %v", got, err) + } +} + +// AN EMPTY PROFILE DIRECTORY IS THE ORDINARY LAUNCH, and the sets go to this +// process's own profile in the state root rather than nowhere. The first build +// read "" as "keep them in memory", so on a plain launch no team outlived the +// window it was made in. +func TestTeamFileOnTheOrdinaryLaunchIsTheProfilesOwn(t *testing.T) { + got := teamsPath("") + if got == "" || got == teamsFile || !filepath.IsAbs(got) { + t.Fatalf("an empty profile directory put the sets at %q", got) + } + if want := config.ProfilePath("", teamsFile); got != want { + t.Fatalf("sets at %q, the profile keeps its files at %q", got, want) + } +} + +func TestTeamCorruptFileErrorsAndIsNotClobbered(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, teamsFile) + bad := []byte("{not json") + if err := os.WriteFile(path, bad, 0o600); err != nil { + t.Fatal(err) + } + if _, err := loadTeams(dir, nil); err == nil { + t.Fatal("corrupt file loaded without error") + } + if raw, _ := os.ReadFile(path); string(raw) != string(bad) { + t.Fatalf("load changed the file to %q", raw) + } + + // The app's first load moves it aside, so a later save cannot overwrite it. + a := &app{profileDir: dir} + a.teamsEnsure() + if !a.wall.loaded || a.wall.activeID != "" || len(a.wall.teams) != 0 { + t.Fatalf("ensure on corrupt file: %+v", a.wall) + } + if _, err := a.teamMake("new", []chatTab{{key: "k", word: "w"}}); err != nil { + t.Fatal(err) + } + aside, _ := filepath.Glob(path + ".unreadable-*") + if len(aside) != 1 { + t.Fatalf("corrupt file not kept aside: %v", aside) + } + if raw, _ := os.ReadFile(aside[0]); string(raw) != string(bad) { + t.Fatalf("kept file holds %q", raw) + } +} + +func TestTeamFromTabsSkipsPagesAndKeyless(t *testing.T) { + now := time.Now() + sp := teamFromTabs("s", []chatTab{ + {key: "start", word: "Home", start: true}, + {key: "work", word: "Work", work: true}, + {key: "", word: "nameless"}, + {key: "a", file: "fa", where: "/w", word: "alpha"}, + {key: "a", file: "fa", where: "/w", word: "alpha again"}, + {key: "b", file: "fb", where: "/v", word: "beta"}, + }, now) + want := []teamMember{{Key: "a", File: "fa", Where: "/w", Word: "alpha"}, {Key: "b", File: "fb", Where: "/v", Word: "beta"}} + if !reflect.DeepEqual(sp.Members, want) || sp.Name != "s" || !sp.Made.Equal(now) { + t.Fatalf("got %+v", sp) + } +} + +func TestTeamSuggestName(t *testing.T) { + cases := []struct { + name string + tabs []chatTab + want string + }{ + {"shared workspace", []chatTab{{key: "a", where: "/src/CodeAF", word: "Fix it"}, {key: "b", where: "/src/CodeAF/", word: "Other"}}, "codeaf"}, + {"mixed workspaces", []chatTab{{key: "a", where: "/src/one", word: "Ship The Port"}, {key: "b", where: "/src/two", word: "x"}}, "ship"}, + {"no workspace", []chatTab{{key: "a", word: "Hello world"}}, "hello"}, + {"pages skipped", []chatTab{{key: "s", start: true, where: "/elsewhere", word: "Home"}, {key: "a", where: "/src/lab", word: "x"}}, "lab"}, + {"cut to sixteen", []chatTab{{key: "a", where: "/src/a-very-long-project-name", word: "x"}}, "a-very-long-proj"}, + {"nothing", nil, ""}, + } + for _, c := range cases { + if got := teamSuggestName(c.tabs); got != c.want { + t.Errorf("%s: got %q want %q", c.name, got, c.want) + } + } +} + +func TestTeamTabsMergeLiveAndKeepStoredOrder(t *testing.T) { + sp := team{Name: "s", Members: []teamMember{ + {Key: "c", File: "fc", Where: "/w", Word: "gamma"}, + {Key: "a", File: "fa", Where: "/w", Word: "alpha"}, + {Key: "d", File: "fd", Where: "/w", Handle: "lexer"}, + }} + live := []chatTab{ + {key: "a", file: "fa", word: "alpha now", here: true, held: true, signal: tabSignal(1)}, + {key: "b", file: "fb", word: "beta"}, + } + // Held: c is held behind with a title, d is held with none yet (a member + // the manager just started). + held := func(key string) bool { return key == "c" || key == "d" } + got := teamTabs(sp, live, held) + if len(got) != 3 || got[0].key != "c" || got[1].key != "a" || got[2].key != "d" { + t.Fatalf("order: %+v", got) + } + if want := (chatTab{key: "c", file: "fc", where: "/w", word: "gamma", full: "gamma"}); got[0] != want { + t.Fatalf("held member rebuilt as %+v", got[0]) + } + if got[1] != live[0] { + t.Fatalf("live member not the live tab: %+v", got[1]) + } + if got[2].word != "@lexer" { + t.Fatalf("a held member with no title is drawn by its handle: %+v", got[2]) + } +} + +// A MEMBER THIS WINDOW DOES NOT HAVE OPEN GETS NO TAB. The strip is what is +// open here, narrowed to the team; the owner saw three tabs over a wall of one. +func TestTeamTabsDrawNoTabForAMemberNotOpenHere(t *testing.T) { + sp := team{Name: "test", Members: []teamMember{ + {Key: "a", File: "fa", Word: "alpha"}, + {Key: "b", File: "fb", Word: "beta"}, + {Key: "c", File: "fc", Word: "gamma"}, + }} + live := []chatTab{{key: "a", file: "fa", word: "alpha", here: true}} + got := teamTabs(sp, live, func(string) bool { return false }) + if len(got) != 1 || got[0].key != "a" { + t.Fatalf("only the open member is a tab: %+v", got) + } +} + +func TestTeamStripTabsKeepsTheFrontTab(t *testing.T) { + a := &app{} + a.teamsEnsure() + tabs := []chatTab{{key: "a", word: "alpha"}, {key: "b", word: "beta", here: true}, {key: "c", word: "gamma"}} + if got := a.teamStripTabs(tabs); !reflect.DeepEqual(got, tabs) { + t.Fatalf("no team active changed the strip: %+v", got) + } + if _, err := a.teamMake("s", []chatTab{{key: "c", word: "gamma"}, {key: "a", word: "alpha"}}); err != nil { + t.Fatal(err) + } + a.wall.activeID = a.wall.teams[0].ID + got := a.teamStripTabs(tabs) + // The team has no manager, so its first place is the manager's empty one + // (teammanager.go), and the members follow it. + if len(got) == 0 || !got[0].slot { + t.Fatalf("the manager's place is not first: %+v", got) + } + var keys []string + for _, tab := range got[1:] { + keys = append(keys, tab.key) + } + if strings.Join(keys, ",") != "c,a,b" { + t.Fatalf("strip keys %v, want c,a,b", keys) + } + // A front tab that is a member is not drawn twice. + tabs[1].here, tabs[0].here = false, true + if got := a.teamStripTabs(tabs); len(got) != 3 { + t.Fatalf("member front tab doubled: %+v", got) + } +} + +func TestTeamNotActiveBeforeLoad(t *testing.T) { + a := &app{} + a.wall.teams = []team{{ID: "s", Name: "s", Members: []teamMember{{Key: "a"}}}} + a.wall.activeID = "s" + if _, ok := a.teamActive(); ok { + t.Fatal("zero-value active read as a team before any load") + } +} + +func TestTeamMakeReplacesByNameAndDeleteFollowsActive(t *testing.T) { + dir := t.TempDir() + a := &app{profileDir: dir} + i0, err := a.teamMake("Port", []chatTab{{key: "a", word: "alpha"}}) + if err != nil || len(i0) != 12 { + t.Fatalf("make: %q %v", i0, err) + } + i1, _ := a.teamMake("docs", []chatTab{{key: "b", word: "beta"}}) + again, _ := a.teamMake("port", []chatTab{{key: "c", word: "gamma"}}) + if again != i0 || len(a.wall.teams) != 2 || a.wall.teams[0].Members[0].Key != "c" { + t.Fatalf("same name did not replace: %+v", a.wall.teams) + } + if _, err := a.teamMake(" ", []chatTab{{key: "a"}}); err == nil { + t.Fatal("blank name accepted") + } + a.wall.activeID = i1 + if err := a.teamDelete(i0); err != nil { + t.Fatal(err) + } + if sp, ok := a.teamActive(); !ok || sp.Name != "docs" { + t.Fatalf("active did not follow: %+v %v", sp, ok) + } + teamsFlush(t, a) + b := &app{profileDir: dir} + b.teamsEnsure() + if names := b.teamNames(); !reflect.DeepEqual(names, []string{"docs"}) { + t.Fatalf("reloaded names %v", names) + } + if err := a.teamDelete(i1); err != nil { + t.Fatal(err) + } + if _, ok := a.teamActive(); ok { + t.Fatal("deleted team still active") + } +} + +// WHAT A LATER BUILD WROTE SURVIVES THIS ONE. A field it does not know, on a +// team or beside the list, and the reserved Manager, come back out of a load +// and a save exactly as they went in. +func TestTeamRoundTripKeepsUnknownFieldsAndTheManager(t *testing.T) { + dir := t.TempDir() + in := `{"version":2,"teams":[{"id":"abcdefabcdef","name":"harbor","parent":"","members":[{"key":"k1","file":"","where":"","word":""}],` + + `"manager":"k1","hue":120,"tier":1,"made":"2026-09-20T10:00:00Z","pinned":true,"rules":{"quiet":["k2"]}}]}` + if err := os.WriteFile(filepath.Join(dir, teamsFile), []byte(in), 0o600); err != nil { + t.Fatal(err) + } + got, err := loadTeams(dir, nil) + if err != nil || len(got) != 1 { + t.Fatalf("loaded %+v %v", got, err) + } + if got[0].Manager != "k1" { + t.Fatalf("the manager was lost on load: %q", got[0].Manager) + } + if err := saveTeams(dir, got); err != nil { + t.Fatal(err) + } + raw, _ := os.ReadFile(filepath.Join(dir, teamsFile)) + var disk struct { + Teams []map[string]json.RawMessage `json:"teams"` + } + if err := json.Unmarshal(raw, &disk); err != nil || len(disk.Teams) != 1 { + t.Fatalf("saved %s", raw) + } + saved := disk.Teams[0] + for key, want := range map[string]string{"pinned": `true`, "rules": `{"quiet":["k2"]}`, "manager": `"k1"`, "id": `"abcdefabcdef"`} { + var flat bytes.Buffer + if err := json.Compact(&flat, saved[key]); err != nil || flat.String() != want { + t.Fatalf("%s saved as %s, want %s\n%s", key, saved[key], want, raw) + } + } + // And an edit through the app keeps them too. + a := newTestAppWithProfile(dir, nil) + if err := a.teamRename("abcdefabcdef", "dock"); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + raw, _ = os.ReadFile(filepath.Join(dir, teamsFile)) + if !strings.Contains(string(raw), `"pinned": true`) || !strings.Contains(string(raw), `"manager": "k1"`) || !strings.Contains(string(raw), `"dock"`) { + t.Fatalf("an edit dropped what it did not know:\n%s", raw) + } +} + +// THE TREE: one parent, which exists, and no loops; a team deleted hands its +// children to its own parent and closes no conversation. +func TestTeamTreeRefusesLoopsAndDeleteReparents(t *testing.T) { + a := newTestAppWithProfile(t.TempDir(), nil) + mk := func(name, key string) string { + t.Helper() + id, err := a.teamMake(name, []chatTab{{key: key, word: name}}) + if err != nil { + t.Fatal(err) + } + return id + } + top, mid, low, other := mk("top", "k1"), mk("mid", "k2"), mk("low", "k3"), mk("other", "k4") + if err := a.teamSetParent(mid, top); err != nil { + t.Fatal(err) + } + if err := a.teamSetParent(low, mid); err != nil { + t.Fatal(err) + } + for _, c := range []struct{ id, parent, why string }{ + {top, top, "a team under itself"}, + {top, low, "a team under its own grandchild"}, + {mid, low, "a team under its own child"}, + {mid, "nobody", "a parent that does not exist"}, + {"nobody", top, "a team that does not exist"}, + } { + if err := a.teamSetParent(c.id, c.parent); err == nil { + t.Fatalf("%s was allowed", c.why) + } + } + names := func(ts []team) string { + var out []string + for _, tm := range ts { + out = append(out, tm.Name) + } + return strings.Join(out, ",") + } + if got := names(a.teamAncestors(low)); got != "mid,top" { + t.Fatalf("low's ancestors are %q", got) + } + if got := names(a.teamChildren("")); got != "top,other" { + t.Fatalf("the top level is %q", got) + } + if got := names(a.teamChildren(top)); got != "mid" { + t.Fatalf("top's children are %q", got) + } + if err := a.teamSetParent(other, low); err != nil { + t.Fatal(err) + } + if err := a.teamDelete(mid); err != nil { + t.Fatal(err) + } + if lowT, _ := a.teamByID(low); lowT.Parent != top { + t.Fatalf("low's parent after mid went is %q, want top", lowT.Parent) + } + if otherT, _ := a.teamByID(other); otherT.Parent != low { + t.Fatalf("a team under a survivor moved: %q", otherT.Parent) + } + if got := names(a.teamAncestors(other)); got != "low,top" { + t.Fatalf("other's ancestors are %q", got) + } + // The tree is on disk, as every edit is. + teamsFlush(t, a) + b := newTestAppWithProfile(a.profileDir, nil) + b.teamsEnsure() + if lowT, _ := b.teamByID(low); lowT.Parent != top { + t.Fatalf("reloaded, low sits under %q", lowT.Parent) + } +} + +// NOTHING NAMES A TEAM BY ITS PLACE, so deleting one or reordering the list +// never hands another team's state to a neighbour: the active team, its +// remembered place, an open popover and the strip's chip all stay on theirs. +func TestTeamDeleteOrReorderNeverRetargetsAnother(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + if len(tiles) < 3 { + t.Fatalf("the fixture has %d tiles", len(tiles)) + } + first, err := a.teamMake("first", []chatTab{tiles[0].tab}) + if err != nil { + t.Fatal(err) + } + second, _ := a.teamMake("second", []chatTab{tiles[1].tab, tiles[2].tab}) + third, _ := a.teamMake("third", []chatTab{tiles[2].tab}) + + a.wallSetTeam(second) + a.wallMove(1, 2) + a.wallSetTeam("") + a.wallSetTeam(third) + a.wallSetTeam(second) + a.wallOpenSettings(third, wallPop{}) + _ = a.wallFrame(a.width, a.height) + chip := plain(a.tabsRow(a.width)) + + if err := a.teamDelete(first); err != nil { + t.Fatal(err) + } + if a.wall.activeID != second || a.wall.pop.team != third { + t.Fatalf("after the delete the wall shows %q and the settings are %q", a.wall.activeID, a.wall.pop.team) + } + if got, ok := a.teamActive(); !ok || got.Name != "second" { + t.Fatalf("the strip is narrowed to %+v", got) + } + if place, ok := a.wall.places[second]; !ok || place.key != tiles[2].tab.key { + t.Fatalf("second's place is %+v %v", place, ok) + } + a.touch() + if got := plain(a.tabsRow(a.width)); !strings.Contains(got, "● second ▾") || got == "" { + t.Fatalf("the chip went from %q to %q", chip, got) + } + + // The list reordered under the same state. + a.wall.teams[0], a.wall.teams[1] = a.wall.teams[1], a.wall.teams[0] + if got, _ := a.teamActive(); got.Name != "second" { + t.Fatalf("a reorder moved the strip to %q", got.Name) + } + a.wall.pop = wallPop{} + _ = a.wallFrame(a.width, a.height) + a.wall.hover = wallHitForTeam(t, a, wallHitChip, third).ref() + a.wall.teams[0], a.wall.teams[1] = a.wall.teams[1], a.wall.teams[0] + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + if !strings.Contains(frame, "third · 1 open here · 1 member") { + t.Fatalf("the hover followed the place, not the team:\n%s", frame) + } + wallKeyPress(a, "D") + if got, ok := a.teamByID(second); !ok || !got.Closed() || a.wall.activeID != "" { + t.Fatalf("D closed the wrong team: %v active %q", a.teamNames(), a.wall.activeID) + } + if got, ok := a.teamByID(third); !ok || got.Closed() { + t.Fatal("D took a neighbour with it") + } +} + +// A CONVERSATION STARTED WHILE A TEAM IS SHOWN IS ONE OF IT. /new (the strip's +// + and the start page take the same road) and a folder typed on home both +// mint one, and each lands in the team the strip is narrowed to, saved. Going +// back to a conversation that already exists changes no team, and with no +// team shown a new conversation joins nothing. +func TestTeamNewConversationJoinsTheShownTeam(t *testing.T) { + a, _, _ := tabApp(t) + a.profileDir = t.TempDir() + n := 0 + a.start = func(workspace string) (Conversation, error) { + n++ + return Conversation{Agent: &fakeAgent{model: "m"}, SessionFile: fmt.Sprintf("/tmp/lab/new-%d.jsonl", n), Workspace: "/tmp/lab"}, nil + } + before := a.frontTabKey() + tabs := a.tabList() + id, err := a.teamMake("harbor", tabs[:1]) + if err != nil { + t.Fatal(err) + } + a.teamActivate(id) + + if _, ok := a.renew(); !ok { + t.Fatal("/new refused") + } + fresh := a.frontTabKey() + if fresh == before || fresh == "" { + t.Fatalf("/new left %q in front", fresh) + } + if got := a.teamsOf(fresh); len(got) != 1 || got[0] != id { + t.Fatalf("the new conversation is in %v, want harbor", got) + } + if _, refusal := a.startBeside("/tmp/elsewhere"); refusal != "" { + t.Fatalf("home's new conversation refused: %s", refusal) + } + beside := a.frontTabKey() + if got := a.teamsOf(beside); len(got) != 1 || got[0] != id { + t.Fatalf("the conversation started from home is in %v", got) + } + teamsFlush(t, a) + disk, _ := loadTeams(a.profileDir, nil) + if len(disk) != 1 || !teamHolds(disk[0], fresh) || !teamHolds(disk[0], beside) { + t.Fatalf("the joins were not saved: %+v", disk) + } + + // Switching to one that exists is not a join. + outside := "" + for _, tab := range a.tabList() { + if !teamHolds(disk[0], tab.key) { + outside = tab.key + _ = a.tabGo(tab) + break + } + } + if outside == "" { + t.Fatal("every conversation is already in the team") + } + if got := a.teamsOf(outside); len(got) != 0 { + t.Fatalf("switching to %q put it in %v", outside, got) + } + + // With no team shown, nothing joins. + a.teamActivate("") + if _, ok := a.renew(); !ok { + t.Fatal("/new refused") + } + if got := a.teamsOf(a.frontTabKey()); len(got) != 0 { + t.Fatalf("a new conversation with no team shown joined %v", got) + } +} diff --git a/internal/tui3/teamsacts.go b/internal/tui3/teamsacts.go new file mode 100644 index 0000000000..bd2c176872 --- /dev/null +++ b/internal/tui3/teamsacts.go @@ -0,0 +1,398 @@ +package tui3 + +import ( + "path/filepath" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── WHAT THE TEAMS PAGE'S TARGETS DO ──────────────────────────────────────── +// +// One switch for the pointer and the keyboard both ([app.teamsDo]), so a press +// and an `enter` on the same target cannot come to mean two things. Every act +// that reaches the store is an edit through [app.teamEdit] (written off the +// loop) or a seam door asked off the loop; nothing here waits on a disk or a +// wire. + +// teamsDo is one target, pressed. +func (a *app) teamsDo(t teamsTarget) tea.Cmd { + a.tp.msg = "" + a.tp.cur = t.ref() + switch t.act { + case teamsActSelect: + return a.teamsSelect(t.id) + case teamsActClosedFold: + a.tp.closedOpen = !a.tp.closedOpen + if !a.tp.closedOpen { + if sel, ok := a.teamsSelected(); ok && sel.Closed() { + a.tp.sel = "" + a.teamsSettle() + } + } + a.touch() + return nil + case teamsActNewTeam: + // On the rail with a team chosen, the new team is made inside it. + return a.teamMenuNewTeamIn(t.id) + case teamsActOrganize: + open := a.openWall() + a.wallSetTeam("") + return tea.Batch(open, a.wallOrganizeOpen()) + case teamsActWall: + open := a.openWall() + a.wallSetTeam(t.id) + return open + case teamsActManager: + return a.teamsManagerStart(t.id) + case teamsActRootManager: + return a.teamsRootManagerStart() + case teamsActSettings: + return a.teamSheetOpen(t.id, teamSheetSettings) + case teamsActClose: + return a.teamsCloseAsk(t.id) + case teamsActReopen: + return a.teamsReopen(t.id, false) + case teamsActReopenParent: + return a.teamsReopen(t.id, true) + case teamsActDelete: + return a.teamSheetOpen(t.id, teamSheetDelete) + case teamsActMember: + return a.teamsMemberGo(t.id, t.arg) + case teamsActOption: + if t.opt == "" { + a.tp.expand = t.arg + a.tp.top = teamsTopCache{} + a.touch() + return nil + } + return a.teamsDecide(t.arg, t.opt, "") + case teamsActOwnAnswer: + a.tp.answering = t.arg + a.tp.answer.reset() + a.tp.top = teamsTopCache{} + a.touch() + return nil + case teamsActPrompt: + return a.teamsPrompt(t.arg, t.opt) + case teamsActUndo: + return a.teamsUndoAny() + case teamsActRetryManager: + return a.teamsRetryManager() + case teamsActOpenInChats: + return a.teamsOpenInChats() + case teamsActMoveYes: + return a.teamMoveConfirm() + case teamsActMoveNo: + a.teamMoveCancel() + return nil + case teamsActManagerGo: + return a.teamsManagerGo(t.id) + case teamsActCrew: + return a.teamCrewOpen(t.id) + } + return nil +} + +// teamDraggable reports whether a press on target t may become a drag +// (teamdrag.go): an open team's row on the rail, or a member's chip. +func (a *app) teamDraggable(t teamsTarget) bool { + switch t.act { + case teamsActMember: + return t.arg != "" + case teamsActSelect: + u, ok := a.teamByID(t.id) + return ok && !t.pane && !u.Root && !u.Closed() + } + return false +} + +// teamsSelect puts the pane on team id and, when it has a manager, brings that +// conversation in front, where the pane draws it. The keyboard goes back to the +// composer: choosing a team is choosing whom to talk to. +func (a *app) teamsSelect(id string) tea.Cmd { + a.tp.sel = id + a.tp.expand, a.tp.answering = "", "" + a.tp.top = teamsTopCache{} + if t, ok := a.teamByID(id); ok && t.Manager != "" && !t.Closed() { + a.tp.focus = false + } + a.touch() + return tea.Batch(a.teamsBringManager(), a.teamsRead(false)) +} + +// teamsMemberGo is a press on a member: one this window holds is opened, and +// one it does not is resumed BEHIND, as its own tab, without moving the +// person's focus (ruling c-b). +func (a *app) teamsMemberGo(id, key string) tea.Cmd { + if a.trafficHeld(key) { + if key == a.frontTabKey() { + a.leavePlace() + return nil + } + cmd := a.trafficGo(key) + a.leavePlace() + return cmd + } + t, ok := a.teamByID(id) + if !ok { + return nil + } + m, ok := t.Member(key) + if !ok || strings.TrimSpace(m.File) == "" { + return nil + } + return a.teamsResumeBehind(m) +} + +// teamsResumeBehind opens one member's conversation behind the one in front, +// off the loop, and holds it as a tab of its own. +func (a *app) teamsResumeBehind(m teamMember) tea.Cmd { + name := m.Word + if m.Handle != "" { + name = "@" + m.Handle + } + switch { + case a.shared: + a.tp.msg = name + " could not open beside this one: " + oneConversationWord + a.touch() + return nil + case !a.canOpen(): + a.tp.msg = name + ": " + resumeUnavailableWord + a.touch() + return nil + } + open, resume, file, where := a.open, a.resume, m.File, m.Where + a.tp.msg = "opening " + name + " behind" + a.linearMark("…", "...") + a.touch() + return a.besideLine(func() func(bool) tea.Cmd { + var conv Conversation + var err error + if open != nil { + conv, err = open(where, file) + } else { + var agent Agent + agent, err = resume(file) + conv = Conversation{Agent: agent, Workspace: where, SessionFile: file} + } + return func(bool) tea.Cmd { + if err != nil || conv.Agent == nil { + why := "the conversation did not open" + if err != nil { + why = err.Error() + } + a.tp.msg = name + ": " + why + a.touch() + return nil + } + key := a.convKey(conv.SessionFile) + cmd := a.stow(conv, nil) + a.trafficBehindTop(key) + a.chatTabBar = tabBar{} + a.tp.msg = name + " is open behind, in its own tab" + a.tp.top = teamsTopCache{} + a.touch() + return cmd + } + }) +} + +// teamsManagerStart is `+ Manager` on team id: a new conversation in the +// team's folder, made its manager, and in front for the person's first words +// to it, which is where the pane draws it. A team whose manager's transcript is +// gone ([app.teamsManagerMissing]) is offered it too, and the new conversation +// replaces the manager the team named. +func (a *app) teamsManagerStart(id string) tea.Cmd { + t, ok := a.teamByID(id) + if !ok || (t.Manager != "" && !a.teamsManagerMissing(t)) || t.Closed() { + return nil + } + if a.teamsOff() { + a.tp.msg = teamHostedWord + a.touch() + return nil + } + return a.teamsStartManager(a.teamWhere(t), func(tab chatTab) { + if err := a.teamMakeManager(id, tab); err != nil { + a.note("the manager is set for this window, but " + err.Error()) + } + }) +} + +// teamsRootManagerStart is `+ Manager` on the `All teams` row: the optional +// global manager. It makes the root team (every top-level team moves under it, +// internal/teams' root.go) and its manager in one edit. +func (a *app) teamsRootManagerStart() tea.Cmd { + if a.teamsOff() { + a.tp.msg = teamHostedWord + a.touch() + return nil + } + if root, ok := a.teamsRoot(); ok { + if root.Manager != "" { + return a.teamsSelect(root.ID) + } + return a.teamsManagerStart(root.ID) + } + // The id is minted here, once: the edit is made twice (teams.go's + // [app.teamEdit]) and must name the same root both times. + rootID, now := newTeamID(), a.now() + return a.teamsStartManager(a.workspace, func(tab chatTab) { + m := teamFromTabs("", []chatTab{tab}, now).Members + err := a.teamEdit(func(f *teamstore.File) error { + id := rootID + if r, ok := f.Root(); ok { + id = r.ID + } else { + f.Teams = append([]teamstore.Team{{ID: rootID, Name: teamstore.RootName, Made: now, Root: true}}, f.Teams...) + for i := range f.Teams { + if f.Teams[i].ID != rootID && f.Teams[i].Parent == "" { + f.Teams[i].Parent = rootID + } + } + } + if len(m) > 0 { + if err := f.AddMember(id, m[0]); err != nil { + return err + } + } + return f.SetManager(id, tab.key) + }) + if err != nil { + a.note("the manager is set for this window, but " + err.Error()) + } + a.tp.sel = rootID + if r, ok := a.teamsRoot(); ok { + a.tp.sel = r.ID + } + }) +} + +// teamsStartManager opens a fresh conversation in where, in front, and hands +// it to made once it is. The conversation is opened on the door line, off the +// loop, because opening one is a call to the engine. +func (a *app) teamsStartManager(where string, made func(chatTab)) tea.Cmd { + take := func() { + made(chatTab{key: a.convKey(a.file), file: a.file, where: a.workspace}) + a.tp.top = teamsTopCache{} + a.touch() + } + if a.start == nil || a.shared { + cmd, refusal := a.teamsStartIn(where) + if refusal != "" { + a.tp.msg = refusal + a.touch() + return nil + } + take() + return cmd + } + if !a.canStart() { + a.tp.msg = newUnavailableWord + a.touch() + return nil + } + start := a.start + return a.besideLine(func() func(bool) tea.Cmd { + conv, err := start(where) + return func(bool) tea.Cmd { + if err != nil || conv.Agent == nil { + why := newUnavailableWord + if err != nil { + why = err.Error() + } + a.tp.msg = why + a.touch() + return nil + } + cmd := a.takeBeside(conv) + take() + return cmd + } + }) +} + +// teamsStartIn is [app.teamStartIn] for a folder rather than a team. +func (a *app) teamsStartIn(where string) (tea.Cmd, string) { + if a.start != nil && strings.TrimSpace(where) != "" && where != a.workspace { + return a.startBeside(where) + } + if a.start != nil { + return a.startBeside(a.workspace) + } + cmd, ok := a.renew() + if !ok { + return nil, newUnavailableWord + } + return cmd, "" +} + +// ── DECIDING ──────────────────────────────────────────────────────────────── + +// teamsDecide decides packet id with option opt, or with the person's own +// words, through the seam, off the loop. A closing report's `Close` (or +// `Close now`, on an incomplete one) closes the team on its report +// ([app.teamsAcceptReport]). A cap's `Raise to $10` is only the decision: the +// session lifts the ceiling for the day from the packet's own figures +// (DESIGN.md 8.8), and a manager can never decide one. +func (a *app) teamsDecide(id, opt, words string) tea.Cmd { + seam := a.teamsSeam() + if !seam.delegation() { + a.tp.msg = teamsHostedWord + a.touch() + return nil + } + var packet teamstore.Packet + found := false + for _, p := range a.tp.packets { + if p.ID == id { + packet, found = p, true + } + } + if !found { + return nil + } + decision := opt + if decision == "" { + decision = words + } + label := decision + if o, ok := packet.Option(opt); ok { + label = o.Label + } + a.tp.msg = "decided " + a.teamsDot() + " " + label + a.tp.top = teamsTopCache{} + a.touch() + // A CLOSING REPORT'S `Close` closes the team (DESIGN.md 8.8). Every other + // decision, a cap's `Raise to $X` included, is the decision and nothing + // more: the session reads a raise back from the packet's own figures. + if packet.Kind == teamstore.PacketClosing && (opt == teamstore.OptionClose || opt == teamstore.OptionCloseNow) { + return a.teamsAcceptReport(packet, decision) + } + return a.teamsDecideOnly(seam, id, decision) +} + +// teamsPrompt answers a member's permission prompt from the page, through +// home's own door ([app.sendAnswer]): the answer is left on that +// conversation's doorstep, or given in this window's own hands when it is the +// one in front. +func (a *app) teamsPrompt(file, key string) tea.Cmd { + row, ok := a.tp.world[filepath.Clean(file)] + if !ok { + return nil + } + question, ok := answerable(row, time.Now()) + if !ok { + return nil + } + cmd, took := a.sendAnswer(row, question, key) + if took { + a.tp.msg = answerSentWord + question.Label(key) + a.tp.top = teamsTopCache{} + a.touch() + } + return cmd +} diff --git a/internal/tui3/teamseam.go b/internal/tui3/teamseam.go new file mode 100644 index 0000000000..3d6f51e6fb --- /dev/null +++ b/internal/tui3/teamseam.go @@ -0,0 +1,418 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/config" + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TEAMS SEAM: WHERE THE TEAMS FILE AND THE TRAFFIC ARE ───────────────── +// +// A team's file and its Traffic logs belong to the machine the SESSION runs +// on, because the team tools a model calls (internal/session) read and write +// them in that machine's profile. On a local launch that is this machine's +// profile; over --host it is the far machine's, and this window's own profile +// is somewhere the manager never looks. So the interface does not open the +// store itself. It asks through [TeamsSeam]: the local one wraps +// internal/teams at the profile directory ([localTeams]), and the --host door +// hands one that asks the engine over the wire (cmd/codeaf's hostTeams). +// +// EVERY CALL THAT MAY WAIT IS MADE OFF THE LOOP. An edit is made to what the +// window holds at once, so the strip and the wall show it on the keystroke, +// and queued; the queue is written by one command beside the loop's own +// ([app.teamsWrite]), on the ordered door line, so two edits reach the file in +// the order they were made. The Traffic clock's reads are made by its own +// command ([app.trafficNext]). The one call made on the loop is +// [TeamsSeam.Load], at an opening, and it must not block: locally it is one +// small file (the fourth law's `open`), and over a connection it answers what +// is held and asks the engine behind itself. +// +// A WINDOW THAT CANNOT REACH THE SESSION'S TEAMS HAS NONE, IT DOES NOT BORROW +// THIS MACHINE'S. Over --host with an engine that predates the teams doors the +// door hands no seam, and [app.teamsOff] turns the team writes and the manager +// off with [teamHostedWord] (host.go's honesty table). + +// TeamsSeam is the teams file and the Traffic logs of the machine the session +// runs on, as functions (the reason [StandingSeam] gives). The zero value is +// this machine's own profile, which is every local launch. +type TeamsSeam struct { + // Load is the teams as held, coloured around reserved, and the file's stamp + // (internal/teams' stamp.go). It is asked on the loop, at an opening, and + // must NOT block. known false says nothing is held yet: the window asks + // [TeamsSeam.ReadSince] off the loop and holds no teams until it answers. + Load func(reserved []float64) (teams []teamstore.Team, stamp string, known bool) + // ReadSince is the file when its stamp is not since, and same when it is; "" + // is a window that has never read it and is always answered with the file. + // It may block. + ReadSince func(since string, reserved []float64) (teams []teamstore.Team, stamp string, same bool, err error) + // Update is the store's read-modify-write: change is made to the file as + // it is, and what was written and its stamp come back. change may be made + // more than once (a write over a wire that met another writer reads and + // makes it again), so it depends only on the file it is handed. It may + // block. + Update func(change func(*teamstore.File) error) (teams []teamstore.Team, stamp string, err error) + // Traffic is team's log after the cursor after ("" the tail), at most + // limit entries, oldest first. A log that has not moved since the last + // ask from the same cursor is answered with nothing from a stat. It may + // block. + Traffic func(team, after string, limit int) ([]teamstore.Entry, error) + + // ── DELEGATION (DESIGN.md section 8) ── + // + // The doors below are the delegation store of the same machine: its + // `teams.` defaults, its decision packets, a team's spend and the delete + // that removes a closed team's files. Every one of them may block and is + // asked off the loop. Over --host against an engine without + // [remote.Welcome.Delegation] they are nil, and [TeamsSeam.delegation] + // says so: the window then says the inbox and the spend are not available + // over that connection, and never reads this machine's packet files. + // Closing and reopening a team are not doors of their own: they are + // [teamstore.File.Close] and [teamstore.File.Reopen] made through Update. + + // Defaults is the five `teams.` defaults, for a card's `· from Settings`. + Defaults func() (teamstore.Defaults, error) + // ApplyDefault writes one of those rows the way the settings tab writes it + // locally (config's ApplyTeamDefault) and answers the five as they stand + // after. Nil over --host against an engine without [remote.Welcome.TeamSettings]: + // the Teams tab stays read-only and says so, and nothing is written here. + ApplyDefault func(key, raw string) (teamstore.Defaults, error) + // Packets is the packets waiting on scope (a team id, teamstore.Person, + // or teamstore.ScopeAll), or same when the packet files are still at + // since ("" is never same). + Packets func(scope, since string) (packets []teamstore.Packet, stamp string, same bool, err error) + // Raise, Decide and Escalate are teamstore's, on that machine. + Raise func(p teamstore.Packet) (teamstore.Packet, error) + Decide func(id, by, decision, reason string) (teamstore.Packet, error) + Escalate func(id, by, to, reason string) (teamstore.Packet, error) + // Spend is team's spend on day ("" that machine's today) with its stamp, + // or same when neither the teams file nor the ledger moved since since. + Spend func(team, day, since string) (spend teamstore.Spend, stamp string, same bool, err error) + // Delete forgets a closed team, the teams under it and their files, and + // answers the ids forgotten. The window reads the list again after it + // (ReadSince), because the file moved. + Delete func(team string) ([]string, error) + + // ── THE TEAMS PAGE (place_teams.go) ── + // + // Two more doors, OPTIONAL: a seam without them is a seam, and the page says + // what it cannot show rather than reading this machine's files. Over --host + // no wire answers them yet, so cmd/codeaf's hostTeams leaves them nil. + + // History is team's packets, decided ones included, oldest first: the + // closed view reads its closing report from it (teamstore.Packets). + History func(team string) ([]teamstore.Packet, error) + // Append writes one entry to team's Traffic (teamstore.AppendTraffic). The + // page uses it for the two things the person says to a team outside a + // conversation that the session does not write itself: a close and a + // reopen. + Append func(team string, e teamstore.Entry) error + + // ── THE WRAP-UP (DESIGN.md 8.8) ── + // + // Two narrow doors, which cross --host when the engine says so + // ([remote.Welcome.WrapUp]); an engine without them offers `Close now` + // only, and the close card says so. + + // WrapUp asks team's manager to wrap up: it appends exactly + // teamstore.WrapUpRequest(text) to the team's Traffic, which the manager's + // session reads, and nothing else. text "" is the standard words. + WrapUp func(team, text string) error + // AcceptClosing closes the team a decided closing packet reports on, with + // the packet as its report (teamstore.AcceptClosing), and says whether + // this call closed it. The page calls it after the person's Decide. + AcceptClosing func(id string) (bool, error) +} + +// present reports whether the seam was handed at all. +func (s TeamsSeam) present() bool { return s.Load != nil && s.Update != nil } + +// delegation reports whether the seam carries the delegation doors. +func (s TeamsSeam) delegation() bool { + return s.Defaults != nil && s.Packets != nil && s.Raise != nil && s.Decide != nil && + s.Escalate != nil && s.Spend != nil && s.Delete != nil +} + +// localTeams is the seam onto internal/teams in dir, the profile of this +// machine. watch is the window's stat-before-read memory of the logs. +func localTeams(dir string, watch *teamstore.Watch) TeamsSeam { + return TeamsSeam{ + Load: func(reserved []float64) ([]teamstore.Team, string, bool) { + stamp := teamstore.Stamp(dir) + f, err := teamstore.LoadHued(dir, reserved) + if err != nil { + // AN UNREADABLE FILE IS MOVED ASIDE, NOT OVERWRITTEN. Starting + // empty is the only way the person can go on making teams, but + // the next write would then replace a file that may hold every + // team they made; renamed to teams.json.unreadable-<nanos> it + // survives for a person to recover. + _, _ = teamstore.SetAside(dir) + return nil, teamstore.Stamp(dir), true + } + return f.Teams, stamp, true + }, + ReadSince: func(since string, reserved []float64) ([]teamstore.Team, string, bool, error) { + stamp := teamstore.Stamp(dir) + if since != "" && since == stamp { + return nil, stamp, true, nil + } + f, err := teamstore.LoadHued(dir, reserved) + if err != nil { + return nil, stamp, false, err + } + return f.Teams, stamp, false, nil + }, + Update: func(change func(*teamstore.File) error) ([]teamstore.Team, string, error) { + f, stamp, err := teamstore.Change(dir, change) + if err != nil { + return nil, "", err + } + return f.Teams, stamp, nil + }, + Traffic: func(team, after string, limit int) ([]teamstore.Entry, error) { + entries, _, err := watch.Traffic(dir, team, after, limit) + return entries, err + }, + Defaults: func() (teamstore.Defaults, error) { return teamstore.DefaultsAt(dir), nil }, + ApplyDefault: func(key, raw string) (teamstore.Defaults, error) { + if err := config.ApplyTeamDefault(dir, key, raw); err != nil { + return teamstore.Defaults{}, err + } + return teamstore.DefaultsAt(dir), nil + }, + Packets: func(scope, since string) ([]teamstore.Packet, string, bool, error) { + stamp := teamstore.PacketsStamp(dir) + if since != "" && since == stamp { + return nil, stamp, true, nil + } + packets, _, err := teamstore.OpenPackets(dir, scope) + return packets, stamp, false, err + }, + Raise: func(p teamstore.Packet) (teamstore.Packet, error) { return teamstore.Raise(dir, p) }, + Decide: func(id, by, decision, reason string) (teamstore.Packet, error) { + return teamstore.Decide(dir, id, by, decision, reason) + }, + Escalate: func(id, by, to, reason string) (teamstore.Packet, error) { + return teamstore.Escalate(dir, id, by, to, reason) + }, + Spend: func(team, day, since string) (teamstore.Spend, string, bool, error) { + if day == "" { + day = teamstore.Today() + } + stamp := teamstore.TeamSpendStamp(dir, team, day) + if since != "" && since == stamp { + return teamstore.Spend{}, stamp, true, nil + } + spend, err := teamstore.TeamSpend(dir, team, day) + return spend, stamp, false, err + }, + Delete: func(team string) ([]string, error) { return teamstore.Delete(dir, team) }, + History: func(team string) ([]teamstore.Packet, error) { + return teamstore.Packets(dir, team) + }, + Append: func(team string, e teamstore.Entry) error { return teamstore.AppendTraffic(dir, team, e) }, + WrapUp: func(team, text string) error { + return teamstore.AppendTraffic(dir, team, teamstore.WrapUpRequest(text)) + }, + AcceptClosing: func(id string) (bool, error) { return teamsAcceptClosingLocal(dir, id) }, + } +} + +// teamsAcceptClosingLocal closes the team decided closing packet id in this +// profile reports on. +func teamsAcceptClosingLocal(dir, id string) (bool, error) { + p, err := teamstore.PacketByID(dir, id) + if err != nil { + return false, err + } + return teamstore.AcceptClosing(dir, p) +} + +// teamsDisk is the window's side of the seam: the door, the queue of edits +// not yet written, and the read asked for when nothing was held. +type teamsDisk struct { + // door is [Options.Teams]; its zero value is the local seam. + door TeamsSeam + // watch is the local seam's stat-before-read memory of the logs. + watch teamstore.Watch + // queue is every edit made to what this window holds and not yet handed + // to the store, in the order they were made. + queue []func(*teamstore.File) error + // fetch says an opening found nothing held ([TeamsSeam.Load]'s known + // false) and a read is wanted; fetching says it is out. + fetch, fetching bool + // rows reads named conversations' rows off this machine's disk for the + // teams page ([app.teamsRead]); nil is [session.ReadRows]. It is a field + // so a test can see exactly which conversations a read asked about. + rows func(transcripts []string) map[string]session.SessionRow +} + +// teamsSeam is the seam this window reads and writes teams through, bound now, +// on the loop, so a command that carries it off never reads the window. +func (a *app) teamsSeam() TeamsSeam { + if a.teamsDisk.door.present() { + return a.teamsDisk.door + } + return localTeams(a.profileDir, &a.teamsDisk.watch) +} + +// THE FRAME ASKS WHICH DOORS THERE ARE, NEVER FOR THE SEAM. Binding the local +// seam builds closures that read the disk when called, and the paint walks +// every closure it builds (framedisk_law_test.go), so a draw that only wants to +// know whether a door exists asks here: the engine's seam when there is one, +// and otherwise the local one, which has every door. + +// teamsCanDelegate reports whether the seam carries the delegation doors. +func (a *app) teamsCanDelegate() bool { + return !a.teamsDisk.door.present() || a.teamsDisk.door.delegation() +} + +// teamsCanWrapUp reports whether the seam has the wrap-up door. +func (a *app) teamsCanWrapUp() bool { + return !a.teamsDisk.door.present() || a.teamsDisk.door.WrapUp != nil +} + +// teamsCanReadHistory reports whether the seam can read a team's packets. +func (a *app) teamsCanReadHistory() bool { + return !a.teamsDisk.door.present() || a.teamsDisk.door.History != nil +} + +// teamsOff reports whether this window has no teams it can keep: over --host, +// facing an engine that does not answer the teams doors. The window's own +// profile is never the answer there, so the writes and the manager say +// [teamHostedWord] and the Traffic clock does not run. +func (a *app) teamsOff() bool { return a.hosted() && !a.teamsDisk.door.present() } + +// teamTabWords is each conversation's current tab name, by key, for the edits +// written off the loop: [app.teamRefreshWords] reads the tabs, and a command +// may not. +func (a *app) teamTabWords() map[string]string { + words := map[string]string{} + for _, tab := range a.chatTabs { + if tab.key != "" && strings.TrimSpace(tab.word) != "" && !tab.start && !tab.work { + if _, ok := words[tab.key]; !ok { + words[tab.key] = tab.word + } + } + } + return words +} + +// teamApplyWords gives each member of teams its tab's name from words. +func teamApplyWords(teams []team, words map[string]string) { + for i := range teams { + for j, m := range teams[i].Members { + if w, ok := words[m.Key]; ok { + teams[i].Members[j].Word = w + } + } + } +} + +// teamsWrote is what one write, or one read asked for at an opening, came back +// with, folded on the loop. +type teamsWrote struct { + teams []team + stamp string + err error + // covers is [trafficState.edits] when the write left, and read says this + // was the opening's read rather than a write. + covers int + read bool +} + +// teamsWrite hands the queued edits to the store in one command on the door +// line, and the opening's read when one is wanted. It is asked after every +// message ([app.Update]) and at [app.Init], and answers nil when there is +// nothing to do, which is almost always. +// +// THE EDITS ARE WRITTEN TOGETHER AND KEPT APART. One command makes every +// queued edit to the file as the store has it now, each on a copy, and an edit +// the file refuses (a team another process deleted) is left out rather than +// taking the others down with it; the first refusal is said. What was written +// is what the window holds afterwards, unless the person has made another edit +// since, whose own write answers for it. +func (a *app) teamsWrite() tea.Cmd { + var cmds []tea.Cmd + if a.teamsDisk.fetch && !a.teamsDisk.fetching { + a.teamsDisk.fetch, a.teamsDisk.fetching = false, true + seam, reserved, covers := a.teamsSeam(), teamReservedHues(a.pal), a.traffic.edits + cmds = append(cmds, a.besideLine(func() func(bool) tea.Cmd { + teams, stamp, _, err := seam.ReadSince("", reserved) + return func(bool) tea.Cmd { + a.teamsTake(teamsWrote{teams: teams, stamp: stamp, err: err, covers: covers, read: true}) + return nil + } + })) + } + if len(a.teamsDisk.queue) > 0 { + changes := a.teamsDisk.queue + a.teamsDisk.queue = nil + seam, words, reserved, covers := a.teamsSeam(), a.teamTabWords(), teamReservedHues(a.pal), a.traffic.edits + cmds = append(cmds, a.offLoop(func() func(bool) tea.Cmd { + var refused error + teams, stamp, err := seam.Update(func(f *teamstore.File) error { + refused = nil + for _, change := range changes { + mine := &teamstore.File{Version: f.Version, Teams: teamsClone(f.Teams)} + if err := change(mine); err != nil { + if refused == nil { + refused = err + } + continue + } + f.Teams = mine.Teams + } + teamApplyWords(f.Teams, words) + f.Colour(reserved) + return nil + }) + if err == nil { + err = refused + } + return func(bool) tea.Cmd { + a.teamsTake(teamsWrote{teams: teams, stamp: stamp, err: err, covers: covers}) + return nil + } + })) + } + return tea.Batch(cmds...) +} + +// teamsTake folds one write or the opening's read in, on the loop. +// +// A LIST FROM THE STORE REPLACES WHAT THE WINDOW HOLDS ONLY WHEN IT IS THE +// NEWEST THING THE WINDOW KNOWS. An edit made since the command left is in +// memory and not in the list, and its own write will answer; taking this list +// would draw that edit undone for the beat between. A refused write is said +// once, and the window keeps what it holds, which is the person's change; an +// edit the file refused is left out of what was written and said the same way. +func (a *app) teamsTake(w teamsWrote) { + if w.read { + a.teamsDisk.fetching = false + } else { + a.traffic.wrote = w.covers + } + if w.err != nil { + if !w.read { + a.note("the teams are kept for this window, but " + w.err.Error()) + } + return + } + if w.covers != a.traffic.edits || w.read && a.wall.loaded { + return + } + if w.read { + a.wall.loaded, a.wall.activeID = true, "" + } + if w.stamp != "" { + a.teamAdopt(teamsClone(w.teams)) + // AND THE FILE AS THIS LEFT IT IS THE ONE THE TRAFFIC CLOCK HAS SEEN, + // so its next turn does not read back what this window just wrote. + a.traffic.stamp = w.stamp + } + a.touch() +} diff --git a/internal/tui3/teamseam_test.go b/internal/tui3/teamseam_test.go new file mode 100644 index 0000000000..c1b3f43856 --- /dev/null +++ b/internal/tui3/teamseam_test.go @@ -0,0 +1,314 @@ +package tui3 + +import ( + "errors" + "os" + "strings" + "sync" + "testing" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── TEST HELPERS FOR THE TEAMS FILE ───────────────────────────────────────── +// +// The interface reaches the store only through its seam (teamseam.go). These +// read and write the file directly, as fixtures and as the witness a test asks +// what reached the disk. + +// teamsPath is where the sets live in profileDir. +func teamsPath(profileDir string) string { return teamstore.Path(profileDir) } + +// loadTeams reads the sets from profileDir, coloured around reserved. +func loadTeams(profileDir string, reserved []float64) ([]team, error) { + f, err := teamstore.LoadHued(profileDir, reserved) + if err != nil { + return nil, err + } + return f.Teams, nil +} + +// saveTeams writes the sets to profileDir as the whole file, as a fixture. +func saveTeams(profileDir string, s []team) error { return teamstore.Save(profileDir, s) } + +// teamsFlush writes the edits this window has queued, and folds the write in, +// as the loop does after the message that made them. +func teamsFlush(t *testing.T, a *app) { + t.Helper() + spend(t, a, a.teamsWrite()) +} + +// farTeams is a seam onto a profile of the test's own that stands for the +// engine's, the way the --host door's seam stands for the far machine. held +// false makes its Load answer "nothing held yet", as a connection does before +// its first answer. reads counts the reads made off the loop. +type farTeams struct { + dir string + watch teamstore.Watch + mu sync.Mutex + held bool + reads int +} + +func (f *farTeams) seam() TeamsSeam { + local := localTeams(f.dir, &f.watch) + return TeamsSeam{ + Load: func(reserved []float64) ([]teamstore.Team, string, bool) { + f.mu.Lock() + defer f.mu.Unlock() + if !f.held { + return nil, "", false + } + return local.Load(reserved) + }, + ReadSince: func(since string, reserved []float64) ([]teamstore.Team, string, bool, error) { + f.mu.Lock() + f.reads++ + f.mu.Unlock() + return local.ReadSince(since, reserved) + }, + Update: local.Update, + Traffic: local.Traffic, + } +} + +// THE LOCAL SEAM IS THE STORE IN THE PROFILE. A load of no file is known and +// empty; an update answers what it wrote and a stamp; a read at that stamp is +// "same" and carries nothing; a quiet log after its cursor is nothing. +func TestTheLocalTeamsSeamIsTheStoreInTheProfile(t *testing.T) { + dir := t.TempDir() + var watch teamstore.Watch + seam := localTeams(dir, &watch) + teams, stamp, known := seam.Load(nil) + if !known || len(teams) != 0 || stamp != teamstore.MissingStamp { + t.Fatalf("a load of no file: %v, %q, %v", teams, stamp, known) + } + wrote, stamp, err := seam.Update(func(f *teamstore.File) error { + f.Teams = append(f.Teams, team{ID: "0a0a0a0a0a0a", Name: "harbor"}) + return nil + }) + if err != nil || len(wrote) != 1 || stamp == teamstore.MissingStamp { + t.Fatalf("the update: %v, %q, %v", wrote, stamp, err) + } + if got, again, same, err := seam.ReadSince(stamp, nil); err != nil || !same || got != nil || again != stamp { + t.Fatalf("a read at the written stamp: %v, %q, %v, %v", got, again, same, err) + } + if got, _, same, _ := seam.ReadSince("", nil); same || len(got) != 1 { + t.Fatalf("a first read: %v, same %v", got, same) + } + if err := teamstore.AppendTraffic(dir, "0a0a0a0a0a0a", teamstore.Entry{Kind: teamstore.KindNote, From: "a", To: "b", Text: "x"}); err != nil { + t.Fatal(err) + } + tail, err := seam.Traffic("0a0a0a0a0a0a", "", 10) + if err != nil || len(tail) != 1 { + t.Fatalf("the tail: %v, %v", tail, err) + } + if more, _ := seam.Traffic("0a0a0a0a0a0a", tail[0].ID, 10); len(more) != 0 { + t.Fatalf("a quiet log answered %v", more) + } +} + +// AN EDIT IS DRAWN AT ONCE AND WRITTEN OFF THE LOOP. teamMake changes what the +// window holds and touches no disk; the command the loop hands back after it +// writes the file, and what it wrote is what the window holds afterwards. +func TestATeamEditIsWrittenOffTheLoop(t *testing.T) { + a, _, _ := tabApp(t) + a.profileDir = t.TempDir() + id, err := a.teamMake("harbor", a.tabList()) + if err != nil { + t.Fatal(err) + } + if _, ok := a.teamByID(id); !ok { + t.Fatal("the edit is not in what the window holds") + } + if _, err := os.Stat(teamsPath(a.profileDir)); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("the edit wrote the disk on the loop: %v", err) + } + if a.traffic.wrote == a.traffic.edits { + t.Fatal("an unwritten edit reads as written") + } + teamsFlush(t, a) + on, err := loadTeams(a.profileDir, nil) + if err != nil || len(on) != 1 || on[0].ID != id { + t.Fatalf("the write: %+v, %v", on, err) + } + if a.traffic.wrote != a.traffic.edits || a.traffic.stamp != teamstore.Stamp(a.profileDir) { + t.Fatalf("the fold did not take the write (wrote %d of %d, stamp %q)", a.traffic.wrote, a.traffic.edits, a.traffic.stamp) + } + if a.teamsWrite() != nil { + t.Fatal("a window with nothing queued asked for a write") + } +} + +// OVER --host WITH A SEAM, NOTHING IS REFUSED AND THE LAPTOP'S FILE IS LEFT +// ALONE. The window's own profile stands for the laptop and the seam's for the +// engine. A team, its manager and a member's handle are written to the +// engine's file; the laptop's teams.json is never created; nothing says +// managers are not available; the manager's Traffic, written in the engine's +// profile, reaches the rail. +func TestTeamsOverAHostedSeamRefuseNothingAndLeaveTheLaptopFileAlone(t *testing.T) { + a, _, _ := tabApp(t) + laptop := t.TempDir() + a.profileDir, a.host = laptop, "devbox" + far := &farTeams{dir: t.TempDir(), held: true} + a.teamsDisk.door = far.seam() + if a.teamsOff() { + t.Fatal("a hosted window with a seam has its teams off") + } + id, err := a.teamMake("harbor", a.tabList()) + if err != nil { + t.Fatal(err) + } + a.teamActivate(id) + front := a.frontTabKey() + for _, tab := range a.tabList() { + if tab.key == front { + if err := a.teamMakeManager(id, tab); err != nil { + t.Fatal(err) + } + } + } + teamsFlush(t, a) + for _, e := range a.entries { + if e.kind == entryNote && strings.Contains(e.text, teamHostedWord) { + t.Fatalf("a hosted window with a seam said %q", e.text) + } + } + on, err := loadTeams(far.dir, nil) + if err != nil || len(on) != 1 || on[0].Manager != front { + t.Fatalf("the engine's file: %+v, %v", on, err) + } + if _, err := os.Stat(teamsPath(laptop)); !errors.Is(err, os.ErrNotExist) { + t.Fatalf("the laptop's teams file was touched: %v", err) + } + if !a.trafficWanted() || a.sideKind() != sideKindManager { + t.Fatal("the manager in front over --host has no clock or no Traffic") + } + handle := "" + for _, m := range on[0].Members { + if m.Key != front && m.Handle != "" { + handle = m.Handle + break + } + } + if err := teamstore.AppendTraffic(far.dir, id, teamstore.Entry{Kind: teamstore.KindDirective, + From: teamstore.FromManager, To: handle, Text: "take the lexer"}); err != nil { + t.Fatal(err) + } + trafficReadNow(t, a) + rows := a.traffic.rows[id] + if len(rows) != 1 || rows[0].Text != "take the lexer" { + t.Fatalf("the cache over --host holds %+v", rows) + } + // AND THE SIDE COLUMN DRAWS IT FROM THAT CACHE: the manager's Traffic in + // front, the directive a row of work, and the frames that draw it write + // nothing on the laptop. + a.width, a.height = 160, 40 + a.welcome.open = false + if col := strings.Join(railLines(t, a), "\n"); !strings.Contains(col, "take the lexer") || a.sideView() != sideTraffic { + t.Fatalf("the column over --host does not draw the engine's Traffic:\n%s", col) + } + if entries, _ := os.ReadDir(laptop); len(entries) != 0 { + t.Fatalf("the laptop's profile holds %v", entries) + } +} + +// AN ENGINE WITHOUT THE TEAMS DOORS TURNS TEAMS OFF, IT DOES NOT FALL BACK TO +// THE LAPTOP. With --host and no seam an edit is refused, the manager's door +// says the honest line, the clock does not run, and the laptop's profile is +// never written. +func TestAnOlderEngineTurnsTeamsOffOverHost(t *testing.T) { + a, _, _ := tabApp(t) + laptop := t.TempDir() + a.profileDir, a.host = laptop, "devbox" + if !a.teamsOff() { + t.Fatal("a hosted window with no seam keeps teams") + } + if _, err := a.teamMake("harbor", a.tabList()); !errors.Is(err, errTeamsHosted) { + t.Fatalf("an edit over an older engine: %v", err) + } + var front chatTab + for _, tab := range a.tabList() { + if tab.key == a.frontTabKey() { + front = tab + } + } + a.wall.teams = []team{{ID: "0a0a0a0a0a0a", Name: "harbor", Members: []teamMember{{Key: front.key}}, Manager: front.key}} + if err := a.teamMakeManager("0a0a0a0a0a0a", front); err != nil { + t.Fatal(err) + } + if got := lastNote(t, a); got != teamHostedWord { + t.Fatalf("the manager's door said %q", got) + } + if a.trafficWanted() || a.teamsWrite() != nil { + t.Fatal("an older engine left the clock or a write running") + } + if entries, _ := os.ReadDir(laptop); len(entries) != 0 { + t.Fatalf("the laptop's profile holds %v", entries) + } +} + +// A SEAM THAT HOLDS NOTHING YET IS READ OFF THE LOOP. The opening finds nothing +// held, holds no teams and asks; the answer is folded in and the teams are +// there, and the ask was made by the command, never by the opening. +func TestAHostedSeamThatHoldsNothingYetIsReadOffTheLoop(t *testing.T) { + a, _, _ := tabApp(t) + a.profileDir, a.host = t.TempDir(), "devbox" + far := &farTeams{dir: t.TempDir()} + if err := saveTeams(far.dir, []team{{ID: "0a0a0a0a0a0a", Name: "harbor"}}); err != nil { + t.Fatal(err) + } + a.teamsDisk.door = far.seam() + a.wall.loaded = false + a.teamsEnsure() + if a.wall.loaded || len(a.wall.teams) != 0 || far.reads != 0 { + t.Fatalf("the opening read on the loop (loaded %v, %d teams, %d reads)", a.wall.loaded, len(a.wall.teams), far.reads) + } + teamsFlush(t, a) + if !a.wall.loaded || len(a.wall.teams) != 1 || a.wall.teams[0].Name != "harbor" || far.reads != 1 { + t.Fatalf("the read off the loop: loaded %v, %+v, %d reads", a.wall.loaded, a.wall.teams, far.reads) + } +} + +// THE LOCAL SEAM CARRIES THE DELEGATION DOORS ONTO THIS PROFILE, and a seam +// handed without them says so. A packet raised through the local seam is read +// back through it, a second read at the stamp is same, and the spend of a team +// nobody has spent in is zero with a stamp that answers same. +func TestTheLocalTeamsSeamCarriesTheDelegationDoors(t *testing.T) { + dir := t.TempDir() + t.Setenv("CODEAF_HOME", t.TempDir()) + var watch teamstore.Watch + seam := localTeams(dir, &watch) + if !seam.delegation() { + t.Fatal("the local seam has no delegation doors") + } + if (TeamsSeam{Load: seam.Load, Update: seam.Update}).delegation() { + t.Fatal("a seam without the doors says it has them") + } + if err := teamstore.Save(dir, []teamstore.Team{{ID: "0a0a0a0a0a0a", Name: "harbor", Manager: "hm", + Members: []teamstore.Member{{Key: "hm", Handle: "boss"}}}}); err != nil { + t.Fatal(err) + } + if d, err := seam.Defaults(); err != nil || d.DepthLimit != 3 { + t.Fatalf("defaults %+v %v", d, err) + } + p, err := seam.Raise(teamstore.Packet{Team: teamstore.Person, Origin: "0a0a0a0a0a0a", + Kind: teamstore.PacketQuestion, RaisedBy: "boss", Question: "Friday or Monday?"}) + if err != nil { + t.Fatal(err) + } + mine, stamp, same, err := seam.Packets(teamstore.Person, "") + if err != nil || same || len(mine) != 1 || mine[0].ID != p.ID { + t.Fatalf("the person's packets %+v %v %v", mine, same, err) + } + if _, _, same, _ := seam.Packets(teamstore.Person, stamp); !same { + t.Fatal("a quiet read was not same") + } + spend, at, same, err := seam.Spend("0a0a0a0a0a0a", "", "") + if err != nil || same || spend.USD != 0 { + t.Fatalf("spend %+v %v %v", spend, same, err) + } + if _, _, same, _ := seam.Spend("0a0a0a0a0a0a", "", at); !same { + t.Fatal("a quiet spend was not same") + } +} diff --git a/internal/tui3/teamsheet.go b/internal/tui3/teamsheet.go new file mode 100644 index 0000000000..ba49266473 --- /dev/null +++ b/internal/tui3/teamsheet.go @@ -0,0 +1,867 @@ +package tui3 + +import ( + "strconv" + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TEAM SETTINGS CARD, AND THE CLOSE AND DELETE CARDS ───────────────── +// +// One card over whatever the frame is showing, opened from three doors that +// mean the same thing: `Team settings…` in the strip's switcher, `e` on the +// wall, and `Settings` in the teams page's header. It was a popover on the wall +// alone; it is a card of its own now because a team's settings are a fact +// about the team and not about the wall. +// +// ╭─ Team settings ─────────────────────────────────────────╮ +// │ │ +// │ Name harbor▏ │ +// │ Colour ◉ ● ● ● ● │ +// │ ────────────────────────────────────────────────────── │ +// │ questions go to the manager on · from Settings │ +// │ daily cap $5 a day reset │ +// │ team depth 3 levels · from harbor │ +// │ sub-team share 50% · from Settings │ +// │ ────────────────────────────────────────────────────── │ +// │ Close team… Done ⏎ │ +// │ │ +// ╰──────────────────────────────────────────────────────────╯ +// +// OVERRIDES ONLY. A value the team inherits is drawn dim with where it comes +// from ([teamstore.Origin.Words]: `from Settings`, `from harbor`); a value the +// team sets is drawn in ink with `reset` beside it. Changing a dim value makes +// it an override; `reset` makes it inherit again. The writes are +// [teamstore.File.SetSettings] through [app.teamEdit], so they reach the +// session's own file, over --host included. +// +// THERE IS NO `wake` ROW. The ruling names one, and the store on this build has +// no such field (internal/teams' teamsettings.go keeps four); a row that wrote +// nothing would be a control that lies, so it waits for the store. +// +// THE SAME CARD CLOSES AND DELETES (teamclose.go says what each does), in two +// more modes, because each is a question about one team asked where the team +// is: the close card from `Close…`, the delete card only on a closed team. + +// The card's modes. +type teamSheetMode int + +const ( + teamSheetSettings teamSheetMode = iota + 1 + teamSheetClose + teamSheetDelete +) + +// The card's rows and buttons, as the keyboard and the pointer name them. +const ( + tsName = iota + tsColour + tsQuestions + tsWake + tsCap + tsDepth + tsShare + tsCloseTeam + tsDone + tsWrapUp + tsCloseNow + tsCancel + tsDelete + tsKeep + // `Inside: harbor ▾` and the move it asks for (teammove.go): its + // consequence line's `Move` and `Cancel`, and the Undo after it. + tsInside + tsMoveYes + tsMoveNo + tsMoveUndo + // The reset words sit on their rows; a reset is its row's code plus this. + tsReset = 100 + // A colour swatch is its choice plus this. + tsSwatch = 200 +) + +// teamSheet is the card's whole state. +type teamSheet struct { + on bool + mode teamSheetMode + team string + // cursor is the row or button the keyboard is on, hot the one under the + // pointer (-1 none). + cursor, hot int + // name is the name being edited, choices and choice the colours offered. + name editor + choices []teamHueSpec + choice int + // editing is the value row whose box is open, and box the box. + editing int + box editor + err string + // rect and hits are where the last frame drew it, in frame cells. + rect wallRect + hits []wallHit +} + +// teamSheetOpen puts the card up on team id in mode. +func (a *app) teamSheetOpen(id string, mode teamSheetMode) tea.Cmd { + a.teamsEnsure() + t, ok := a.teamByID(id) + if !ok { + return nil + } + s := teamSheet{on: true, mode: mode, team: id, hot: -1, editing: -1} + switch mode { + case teamSheetSettings: + s.cursor = tsName + s.name.setText(t.Name) + s.choices = append([]teamHueSpec{t.HueSpec()}, teamHueChoices(a.teamHues(id), teamReservedHues(a.pal), wallSwatchCount-1)...) + case teamSheetClose: + s.cursor = tsCloseNow + if _, managed := a.teamsRunning(id); managed && a.teamsCanWrapUp() { + s.cursor = tsWrapUp + } + case teamSheetDelete: + s.cursor = tsKeep + } + a.tsheet = s + a.touch() + if !a.tp.defaultsOK { + return a.teamsRead(false) + } + return nil +} + +// teamSheetShut puts the card away, keeping a name typed into it. +func (a *app) teamSheetShut() { + a.teamSheetRename() + a.tsheet = teamSheet{} + a.touch() +} + +// teamSheetRename keeps the name typed into the card, when it changed. +func (a *app) teamSheetRename() { + s := &a.tsheet + if s.mode != teamSheetSettings { + return + } + if t, ok := a.teamByID(s.team); ok { + if name := strings.TrimSpace(s.name.String()); name != "" && name != t.Name { + if err := a.teamRename(s.team, name); err != nil { + a.note(err.Error()) + } + } + } +} + +// ── WHAT EACH VALUE ROW SAYS ──────────────────────────────────────────────── + +// teamSheetRow is one value row as drawn: its label, the value, where it came +// from, and whether the team sets it. +type teamSheetRow struct { + code int + label, value string + from string + own bool +} + +// teamSheetRows is the four overrides of team t, in the ruling's order. +func (a *app) teamSheetRows(t team) []teamSheetRow { + e := a.teamTree().Effective(t.ID, a.tp.defaults) + known := a.tp.defaultsOK + row := func(code int, label, value string, o teamstore.Origin) teamSheetRow { + r := teamSheetRow{code: code, label: label, value: value, own: !o.Inherited(), from: o.Words()} + if !known && o.Kind == teamstore.OriginSettings { + r.value = "" + r.from = "from Settings" + } + return r + } + onOff := func(on bool) string { + if on { + return "on" + } + return "off" + } + cap := "no cap" + if e.CapUSDDay > 0 { + cap = dollars(e.CapUSDDay) + " a day" + } + depth := itoa(e.DepthLimit) + " levels" + if e.DepthLimit == 1 { + depth = "1 level" + } + share := strconv.Itoa(int(e.SubShare*100+0.5)) + "%" + return []teamSheetRow{ + row(tsQuestions, "questions go to the manager", onOff(e.QuestionsUp), e.QuestionsUpFrom), + row(tsWake, "team messages wake", onOff(e.Wake), e.WakeFrom), + row(tsCap, "daily cap", cap, e.CapFrom), + row(tsDepth, "team depth", depth, e.DepthFrom), + row(tsShare, "sub-team share", share, e.SubShareFrom), + } +} + +// ── DRAWING IT ────────────────────────────────────────────────────────────── + +// teamSheetOver lays the card over a finished frame and writes down where its +// targets landed. With the card down the frame comes back as it was given. +func (a *app) teamSheetOver(frame string) string { + if !a.tsheet.on { + return frame + } + width, height := a.width, a.height + card := a.teamSheetCard(width, height) + a.tsheet.hits = card.hits + if len(card.rows) == 0 { + a.tsheet.rect = wallRect{} + return frame + } + a.tsheet.rect = wallRect{card.x, card.y, card.x + card.w, card.y + len(card.rows)} + rows := strings.Split(frame, "\n") + for len(rows) < height { + rows = append(rows, "") + } + for dy, cr := range card.rows { + if y := card.y + dy; y >= 0 && y < len(rows) { + rows[y] = wallSplice(rows[y], cr, card.x, width) + } + } + return strings.Join(rows[:height], "\n") +} + +// teamSheetLit reports whether code wears a ground: the keyboard's or the +// pointer's. +func (a *app) teamSheetLit(code int) bool { + return a.tsheet.cursor == code || a.tsheet.hot == code +} + +// teamSheetButton paints one button of a card line at x: its word with a cell +// either side, its key dim after it, on the cursor's ground when lit. The +// default button takes the accent, the one on the card. +func (a *app) teamSheetButton(label, key string, code, x int, accent bool) (string, wallHit, int) { + pal := a.pal + ink := pal.ink + if accent { + ink = pal.accent + } + s := " " + ink(label) + w := 2 + ansi.StringWidth(label) + if key != "" { + s += " " + pal.dim(key) + w += 1 + ansi.StringWidth(key) + } + s += " " + if a.teamSheetLit(code) { + s = pal.cursor(s, 0) + } + return s, wallHit{x0: x, x1: x + w, y1: 1, kind: wallHitPopRow, arg: code}, w +} + +// teamSheetCard is the card in its mode, centred, a third of the way down. +func (a *app) teamSheetCard(width, height int) wallCard { + s := &a.tsheet + t, ok := a.teamByID(s.team) + if !ok { + return wallCard{} + } + var title string + var lines []wallCardLine + inner := min(max(width-12, 40), 64) + switch s.mode { + case teamSheetSettings: + title, lines = "Team settings", a.teamSheetSettingsLines(t, inner) + case teamSheetClose: + title, lines = "Close "+t.Name, a.teamSheetCloseLines(t, inner) + case teamSheetDelete: + title, lines = "Delete "+t.Name, a.teamSheetDeleteLines(t, inner) + } + w := inner + 2 + 2*wallCardPadX + h := len(lines) + 2 + 2*wallCardPadY + if w > width-2 || h > height-1 { + return wallCard{} + } + x := a.teamsCardX(width, w) + y := max((height-h)/3, 1) + return wallCardBuild(a.pal, title, lines, x, y, w, wallCardPadX, wallCardPadY) +} + +// teamsCardX is where a card w wide stands on a frame width wide: centred over +// the teams page's pane while that page stands and the pane can hold it, so +// the rail beside it stays readable (the card is about the team the rail has +// selected, and covering the rail hid which one); centred on the frame +// everywhere else. +func (a *app) teamsCardX(width, w int) int { + if a.at(pageTeams) { + rail := teamsRailCols(width) + if pane := width - rail; rail > 0 && w <= pane-2 { + return rail + (pane-w)/2 + } + } + return (width - w) / 2 +} + +// teamSheetSettingsLines is the settings card's lines. +func (a *app) teamSheetSettingsLines(t team, inner int) []wallCardLine { + pal := a.pal + s := &a.tsheet + var lines []wallCardLine + const labelW = 10 + name := s.name.String() + field := pal.ink(name) + if s.cursor == tsName { + field += pal.ink(a.linearMark("▏", "|")) + } + nameLine := pal.dim(teamsPad("Name", labelW)) + field + if s.cursor == tsName || s.hot == tsName { + nameLine = pal.cursor(teamsPad(nameLine, inner), inner) + } + lines = append(lines, wallCardLine{s: nameLine, hits: []wallHit{{x0: 0, x1: inner, y1: 1, kind: wallHitPopRow, arg: tsName}}}) + sws, _, swh := wallSwatches(pal, wallView{}, s.choices, s.choice, labelW) + for i := range swh { + swh[i].kind, swh[i].arg = wallHitPopRow, tsSwatch+swh[i].arg + } + colour := pal.dim(teamsPad("Colour", labelW)) + sws + if s.cursor == tsColour { + colour += " " + pal.dim("←→") + } + lines = append(lines, wallCardLine{s: colour, hits: swh}) + lines = append(lines, a.teamSheetInsideLines(t, inner, labelW)...) + lines = append(lines, wallCardLine{rule: true}) + const valueX = 31 + for _, r := range a.teamSheetRows(t) { + value := r.value + var text string + switch { + case s.editing == r.code: + box, _, _ := draftBlock(&s.box, pal, inner-valueX-2, 1, teamSheetBoxHint(r.code), "") + text = pal.ink(teamsPad(r.label, valueX)) + strings.Join(box, "") + case r.own: + text = pal.ink(teamsPad(r.label, valueX)) + pal.ink(value) + default: + words := value + if r.from != "" { + if words != "" { + words += " " + a.teamsDot() + " " + } + words += r.from + } + text = pal.dim(teamsPad(r.label, valueX)) + pal.dim(words) + } + ln := wallCardLine{hits: []wallHit{{x0: 0, x1: inner - 8, y1: 1, kind: wallHitPopRow, arg: r.code}}} + if r.own && s.editing != r.code { + reset := "reset" + rs := pal.muted(reset) + if s.hot == r.code+tsReset { + rs = pal.cursor(pal.ink(reset), 0) + } + text = teamsPad(text, inner-ansi.StringWidth(reset)) + rs + ln.hits = append(ln.hits, wallHit{x0: inner - ansi.StringWidth(reset), x1: inner, y1: 1, kind: wallHitPopRow, arg: r.code + tsReset}) + } + if s.cursor == r.code && s.editing != r.code { + text = pal.cursor(teamsPad(text, inner), inner) + } + ln.s = text + lines = append(lines, ln) + } + if s.err != "" { + lines = append(lines, wallCardLine{s: pal.bad(fit(s.err, inner))}) + } + lines = append(lines, wallCardLine{rule: true}) + closeWord := "Close team" + a.linearMark("…", "...") + var hits []wallHit + row := "" + if !t.Root { + b, hit, _ := a.teamSheetButton(closeWord, "", tsCloseTeam, 0, false) + row, hits = b, append(hits, hit) + } + enter := a.linearMark("⏎", "enter") + doneX := inner + 2 - a.teamSheetButtonW("Done", enter) + done, doneHit, _ := a.teamSheetButton("Done", enter, tsDone, doneX, false) + row = teamsPad(row, doneX) + done + lines = append(lines, wallCardLine{s: row, hits: append(hits, doneHit), bleed: true}) + return lines +} + +// teamSheetInsideLines is `Inside: harbor ▾`, the team's place in the tree, +// which opens the move picker; under it, while one is asked from here, the +// move's consequence line with `Move` and `Cancel`, or the move just made with +// `Undo`. The root has no place to move to and draws none. +func (a *app) teamSheetInsideLines(t team, inner, labelW int) []wallCardLine { + if t.Root { + return nil + } + pal := a.pal + s := &a.tsheet + where := "Top level" + if p, ok := a.teamByID(t.Parent); ok && !p.Root { + where = p.Name + } + value := pal.ink(where + " " + a.linearMark("▾", "v")) + line := pal.dim(teamsPad("Inside", labelW)) + value + if s.cursor == tsInside || s.hot == tsInside { + line = pal.cursor(teamsPad(line, inner), inner) + } + out := []wallCardLine{{s: line, hits: []wallHit{{x0: 0, x1: inner, y1: 1, kind: wallHitPopRow, arg: tsInside}}}} + if p := a.tmove.pend; len(p.ids) > 0 && p.from == teamMoveFromCard { + for _, l := range wrap(p.words, max(inner-labelW, 12)) { + out = append(out, wallCardLine{s: strings.Repeat(" ", labelW) + pal.ink(l)}) + } + // The line bleeds a cell to the left (wallCardLine), so a button's cell + // of air stands where the value's first letter's left neighbour is, and + // its word lines up with the value above it. + yes, hy, wy := a.teamSheetButton("Move", "", tsMoveYes, labelW, true) + no, hn, _ := a.teamSheetButton("Cancel", "esc", tsMoveNo, labelW+wy+1, false) + out = append(out, wallCardLine{s: strings.Repeat(" ", labelW) + yes + " " + no, hits: []wallHit{hy, hn}, bleed: true}) + } else if a.teamMoveUndoing() && a.tmove.undo.from == teamMoveFromCard { + said := pal.dim(a.tmove.undo.word) + " " + x := labelW + 1 + ansi.StringWidth(a.tmove.undo.word) + 1 + undo, hu, _ := a.teamSheetButton("Undo", "u", tsMoveUndo, x, false) + out = append(out, wallCardLine{s: strings.Repeat(" ", labelW+1) + said + undo, hits: []wallHit{hu}, bleed: true}) + } + return out +} + +// teamSheetButtonW is a button's width as [app.teamSheetButton] draws it. +func (a *app) teamSheetButtonW(label, key string) int { + w := 2 + ansi.StringWidth(label) + if key != "" { + w += 1 + ansi.StringWidth(key) + } + return w +} + +// teamSheetBoxHint is the dim sentence in a value row's box. +func teamSheetBoxHint(code int) string { + switch code { + case tsCap: + return "dollars a day, 0 no cap" + case tsDepth: + return "levels, 1 to 10" + case tsShare: + return "percent, 1 to 100" + } + return "" +} + +// teamSheetCloseLines is the close card: what is running, and the three ways +// on, the default in the accent. +func (a *app) teamSheetCloseLines(t team, inner int) []wallCardLine { + pal := a.pal + names, managed := a.teamsRunning(t.ID) + var lines []wallCardLine + for _, l := range wrap(teamsCloseWords(names)+".", inner) { + lines = append(lines, wallCardLine{s: pal.ink(l)}) + } + lines = append(lines, wallCardLine{}) + type choice struct { + code int + label, key string + consequence string + } + var cs []choice + switch { + case t.Manager != "" && a.teamsCanWrapUp(): + cs = append(cs, choice{tsWrapUp, "Wrap up first", "", "the manager asks everyone to finish and commit, then brings you a closing report"}) + case t.Manager != "": + // The engine behind this window has no wrap-up door: said, not hidden. + for _, l := range wrap(teamsNoWrapUpWord, inner) { + lines = append(lines, wallCardLine{s: pal.dim(l)}) + } + lines = append(lines, wallCardLine{}) + } + cs = append(cs, + choice{tsCloseNow, "Close now", "", "stops every turn and closes the tabs; Undo for a few seconds"}, + choice{tsCancel, "Cancel", "esc", ""}) + labelW := 0 + for _, c := range cs { + labelW = max(labelW, a.teamSheetButtonW(c.label, c.key)) + } + for _, c := range cs { + accent := c.code == tsWrapUp && managed + b, hit, w := a.teamSheetButton(c.label, c.key, c.code, 0, accent) + text := b + strings.Repeat(" ", max(labelW-w, 0)) + // The consequence wraps under itself rather than being cut: it is the + // one thing that says what the button does. + said := wrap(c.consequence, max(inner-labelW-2, 8)) + if len(said) > 0 { + text += " " + pal.dim(said[0]) + } + lines = append(lines, wallCardLine{s: text, hits: []wallHit{hit}, bleed: true}) + for _, l := range said[min(1, len(said)):] { + lines = append(lines, wallCardLine{s: strings.Repeat(" ", labelW+2) + pal.dim(l)}) + } + } + return lines +} + +// teamSheetDeleteLines is the delete card: what goes, what stays, and the two +// answers, the one that cannot be undone in the failure red. +func (a *app) teamSheetDeleteLines(t team, inner int) []wallCardLine { + pal := a.pal + var lines []wallCardLine + say := "Forget " + t.Name + "? Its grouping, its Traffic and its packets go. Its conversations stay in your history." + for _, l := range wrap(say, inner) { + lines = append(lines, wallCardLine{s: pal.ink(l)}) + } + lines = append(lines, wallCardLine{}) + keepW := a.teamSheetButtonW("Keep", "esc") + delW := a.teamSheetButtonW("Delete", "") + x := inner + 2 - keepW - 1 - delW + keep, kh, _ := a.teamSheetButton("Keep", "esc", tsKeep, x, false) + del := " " + pal.bad("Delete") + " " + if a.teamSheetLit(tsDelete) { + del = pal.cursor(del, 0) + } + dh := wallHit{x0: x + keepW + 1, x1: x + keepW + 1 + delW, y1: 1, kind: wallHitPopRow, arg: tsDelete} + lines = append(lines, wallCardLine{s: strings.Repeat(" ", max(x, 0)) + keep + " " + del, hits: []wallHit{kh, dh}, bleed: true}) + return lines +} + +// ── THE KEYS AND THE POINTER ──────────────────────────────────────────────── + +// teamSheetStops is the rows and buttons the keyboard walks, in order. +func (a *app) teamSheetStops() []int { + s := &a.tsheet + switch s.mode { + case teamSheetSettings: + stops := []int{tsName, tsColour} + t, ok := a.teamByID(s.team) + if ok && !t.Root { + stops = append(stops, tsInside) + if p := a.tmove.pend; len(p.ids) > 0 && p.from == teamMoveFromCard { + stops = append(stops, tsMoveYes, tsMoveNo) + } else if a.teamMoveUndoing() && a.tmove.undo.from == teamMoveFromCard { + stops = append(stops, tsMoveUndo) + } + } + stops = append(stops, tsQuestions, tsWake, tsCap, tsDepth, tsShare) + if ok && !t.Root { + stops = append(stops, tsCloseTeam) + } + return append(stops, tsDone) + case teamSheetClose: + var stops []int + if t, ok := a.teamByID(s.team); ok && t.Manager != "" && a.teamsCanWrapUp() { + stops = append(stops, tsWrapUp) + } + return append(stops, tsCloseNow, tsCancel) + case teamSheetDelete: + return []int{tsKeep, tsDelete} + } + return nil +} + +// teamSheetKey is a key while the card is up: it has the keyboard, as every +// card does. +func (a *app) teamSheetKey(msg tea.KeyPressMsg) tea.Cmd { + s := &a.tsheet + key := msg.String() + a.touch() + if s.editing >= 0 { + switch key { + case "esc": + s.editing, s.err = -1, "" + case "enter": + a.teamSheetSave(s.editing, s.box.String()) + case "backspace": + s.box.deleteBackward() + default: + if text := msg.Key().Text; text != "" { + s.box.insert(text) + } + } + return nil + } + stops := a.teamSheetStops() + at := 0 + for i, c := range stops { + if c == s.cursor { + at = i + } + } + switch key { + case "esc": + // A move waiting on its line is answered first. + if p := a.tmove.pend; len(p.ids) > 0 && p.from == teamMoveFromCard { + a.teamMoveCancel() + return nil + } + if s.mode == teamSheetSettings { + a.teamSheetShut() + } else { + a.tsheet = teamSheet{} + } + return nil + case "up", "shift+tab": + s.cursor = stops[max(at-1, 0)] + return nil + case "down", "tab": + s.cursor = stops[min(at+1, len(stops)-1)] + return nil + case "left", "right": + if s.cursor == tsColour && len(s.choices) > 0 { + step := 1 + if key == "left" { + step = len(s.choices) - 1 + } + return a.teamSheetRecolor((s.choice + step) % len(s.choices)) + } + if s.cursor == tsName { + if key == "left" { + s.name.left() + } else { + s.name.right() + } + } + return nil + case "enter": + return a.teamSheetDo(s.cursor) + } + if s.mode == teamSheetSettings && s.cursor == tsName { + switch key { + case "backspace": + s.name.deleteBackward() + default: + if text := msg.Key().Text; text != "" { + s.name.insert(text) + } + } + return nil + } + if s.mode == teamSheetSettings && key == "u" && a.teamMoveUndoing() && a.tmove.undo.from == teamMoveFromCard { + return a.teamSheetDo(tsMoveUndo) + } + if s.mode == teamSheetSettings && (key == "r" || key == "delete") && s.cursor >= tsQuestions && s.cursor <= tsShare { + return a.teamSheetDo(s.cursor + tsReset) + } + if key == "space" { + return a.teamSheetDo(s.cursor) + } + return nil +} + +// teamSheetDo is one row or button of the card, pressed. +func (a *app) teamSheetDo(code int) tea.Cmd { + s := &a.tsheet + id := s.team + s.err = "" + switch { + case code >= tsSwatch: + return a.teamSheetRecolor(code - tsSwatch) + case code >= tsReset: + a.teamSheetReset(code - tsReset) + return nil + } + switch code { + case tsName: + // enter on the name keeps it and moves on, as a form's field does. + a.teamSheetRename() + s.cursor = tsColour + case tsColour: + s.cursor = code + case tsQuestions: + s.cursor = code + t, ok := a.teamByID(id) + if !ok { + return nil + } + next := !a.teamTree().Effective(t.ID, a.tp.defaults).QuestionsUp + a.teamSheetWrite(func(set *teamstore.Settings) { set.QuestionsUp = &next }) + case tsWake: + s.cursor = code + t, ok := a.teamByID(id) + if !ok { + return nil + } + next := !a.teamTree().Effective(t.ID, a.tp.defaults).Wake + a.teamSheetWrite(func(set *teamstore.Settings) { set.Wake = &next }) + case tsCap, tsDepth, tsShare: + s.cursor, s.editing = code, code + s.box.reset() + case tsInside: + s.cursor = code + return a.teamMoveOpen([]string{id}, teamMoveFromCard) + case tsMoveYes: + s.cursor = tsInside + return a.teamMoveConfirm() + case tsMoveNo: + a.teamMoveCancel() + case tsMoveUndo: + s.cursor = tsInside + return a.teamMoveUndo() + case tsCloseTeam: + a.teamSheetShut() + return a.teamsCloseAsk(id) + case tsDone: + a.teamSheetShut() + case tsWrapUp: + a.tsheet = teamSheet{} + return a.teamsWrapUp(id) + case tsCloseNow: + a.tsheet = teamSheet{} + return a.teamsCloseNow(id, "") + case tsCancel, tsKeep: + a.tsheet = teamSheet{} + a.touch() + case tsDelete: + a.tsheet = teamSheet{} + return a.teamsDelete(id) + } + return nil +} + +// teamSheetRecolor takes colour j at once. +func (a *app) teamSheetRecolor(j int) tea.Cmd { + s := &a.tsheet + if j < 0 || j >= len(s.choices) { + return nil + } + s.choice, s.cursor = j, tsColour + if err := a.teamRecolor(s.team, s.choices[j]); err != nil { + a.note("the colour is kept for this window, but " + err.Error()) + } + return nil +} + +// teamSheetSave reads one value row's box and writes it as the team's own +// override. A value outside its band is said on the card and nothing changes. +func (a *app) teamSheetSave(code int, raw string) { + s := &a.tsheet + raw = strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(raw), "$"), "%")) + if raw == "" { + s.editing = -1 + return + } + switch code { + case tsCap: + if strings.EqualFold(raw, "no cap") { + raw = "0" + } + v, err := strconv.ParseFloat(raw, 64) + if err != nil || v < 0 { + s.err = "a cap is dollars a day, 0 for no cap" + return + } + a.teamSheetWrite(func(set *teamstore.Settings) { set.CapUSDDay = &v }) + case tsDepth: + v, err := strconv.Atoi(strings.TrimSuffix(strings.TrimSuffix(raw, " levels"), " level")) + if err != nil || v < 1 || v > 10 { + s.err = "a depth is 1 to 10 levels" + return + } + a.teamSheetWrite(func(set *teamstore.Settings) { set.DepthLimit = &v }) + case tsShare: + v, err := strconv.Atoi(raw) + if err != nil || v < 1 || v > 100 { + s.err = "a share is 1 to 100 percent" + return + } + f := float64(v) / 100 + a.teamSheetWrite(func(set *teamstore.Settings) { set.SubShare = &f }) + } + if s.err == "" { + s.editing = -1 + } +} + +// teamSheetReset makes one row inherit again. +func (a *app) teamSheetReset(code int) { + a.teamSheetWrite(func(set *teamstore.Settings) { + switch code { + case tsQuestions: + set.QuestionsUp = nil + case tsWake: + set.Wake = nil + case tsCap: + set.CapUSDDay = nil + case tsDepth: + set.DepthLimit = nil + case tsShare: + set.SubShare = nil + } + }) +} + +// teamSheetWrite makes one change to the card's team's overrides, as an +// ordinary edit ([app.teamEdit]). +func (a *app) teamSheetWrite(change func(*teamstore.Settings)) { + id := a.tsheet.team + if err := a.teamEdit(func(f *teamstore.File) error { return f.SetSettings(id, change) }); err != nil { + a.tsheet.err = err.Error() + } + a.tp.top = teamsTopCache{} + a.touch() +} + +// teamSheetHitAt is the card's target under the pointer on the last frame. +func (a *app) teamSheetHitAt(x, y int) (wallHit, bool) { + for _, hit := range a.tsheet.hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit, true + } + } + return wallHit{}, false +} + +// teamSheetPress is a left press while the card is up. A press on a target +// takes it; one on the card between targets does nothing; one off the card +// puts it away, keeping a name typed into it. +func (a *app) teamSheetPress(x, y int) tea.Cmd { + if hit, ok := a.teamSheetHitAt(x, y); ok { + return a.teamSheetDo(hit.arg) + } + if !a.tsheet.rect.holds(x, y) { + if a.tsheet.mode == teamSheetSettings { + a.teamSheetShut() + } else { + a.tsheet = teamSheet{} + a.touch() + } + } + return nil +} + +// teamSheetMotion lights the target under the pointer. +func (a *app) teamSheetMotion(x, y int) { + hot := -1 + if hit, ok := a.teamSheetHitAt(x, y); ok { + hot = hit.arg + } + if hot != a.tsheet.hot { + a.tsheet.hot = hot + a.touch() + } +} + +// teamSheetHint is what the hint line says while the card is up. +func (a *app) teamSheetHint() string { + s := &a.tsheet + switch s.mode { + case teamSheetClose: + return "↑↓ choose · enter · esc cancel" + case teamSheetDelete: + return "enter · esc keep it" + } + if s.editing >= 0 { + return "enter keep it as this team's own · esc cancel" + } + switch s.cursor { + case tsName: + return "type to rename · ↓ next · esc done" + case tsColour: + return "←→ colour · esc done" + case tsQuestions, tsCap, tsDepth, tsShare: + return "enter change it for this team · r reset to inherit · esc done" + case tsInside: + return "enter Move into… another team, or the top level · esc done" + case tsMoveYes: + return a.teamMoveDoing(a.tmove.pend.ids, a.tmove.pend.parent) + " · enter · esc cancel" + case tsMoveNo: + return "Leave it where it is · enter" + case tsMoveUndo: + return "Put it back where it was · u" + } + return "↑↓ move · enter · esc done" +} diff --git a/internal/tui3/teamsopen.go b/internal/tui3/teamsopen.go new file mode 100644 index 0000000000..84351f8327 --- /dev/null +++ b/internal/tui3/teamsopen.go @@ -0,0 +1,437 @@ +package tui3 + +import ( + "errors" + "io/fs" + "os" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── BRINGING THE MANAGER INTO THE PANE ────────────────────────────────────── +// +// The pane hosts the selected team's manager only while that conversation is +// the one in front ([app.teamsHosting]); everything here is how it gets there, +// and what the pane says while it does not. +// +// THE PANE USED TO SAY `opening ◆ prism's manager…` WHENEVER THE MANAGER WAS NOT +// IN FRONT, whether or not anything was opening it. The one attempt was made by +// [app.teamsBringManager] on the page's own doors (opening the page, choosing a +// team, a close and a reopen), and every other road to the same state made +// none: the teams arriving from the disk after the page opened, a manager set +// on the file by a session, a message handed to the hosted conversation that +// moved the front (a press on a Traffic row), a refusal that went to a line the +// pane does not draw. Each of them left the word on the pane with nothing +// behind it, and the owner watched it for as long as he looked (2026-09-24). +// And the attempt that did run went through the switcher's own door, which +// ends by stepping off whatever place is standing ([app.hopLand]): a manager +// this window was not holding was opened and the person was taken off the page +// to it. +// +// SO AN ATTEMPT IS NOW A THING THE PAGE HOLDS ([teamsOpen]), and the word on the +// pane is read off it rather than off the front. [app.teamsSync], which runs +// after every message, starts one whenever the selected team's manager is not +// in front and no attempt has been made for it, so no road can leave the pane +// waiting on nothing. The open is asked off the loop and lands the manager +// behind, then brings it forward only if the page still wants it, so the +// person never leaves the page for it. And the pane never waits silently: a +// refusal is said with its reason, an attempt the engine has not answered +// within [teamsOpenBound] is said too, and both offer `Retry` and +// `Open in chats` (the chat surface's own door, [app.trafficGo]). A manager +// whose transcript is gone offers `+ Manager`, which makes a new one. +// +// ONE OPEN PER MANAGER IS OUT AT A TIME. A team chosen twice (a double press, or +// away and back while the first open was on the wire) used to ask the door +// twice for the same transcript. The first answer came back as a stale attempt +// and was put behind, the second met the first one's lock, and the pane said +// the conversation was open in another window, about a conversation this window +// was holding, until the person pressed Retry. Now a choice while an open is +// out takes that open up as its own ([teamsOpenOut]), an answer for the manager +// the page is asking about is the page's answer whichever attempt it was, and a +// refusal about a conversation this window already holds is no refusal. `Retry` +// alone asks again while an open is out, because it is pressed when that open +// has not answered. +// +// AND THE DOOR IS NEVER ASKED FROM UPDATE. Over a connection that holds one +// conversation at a time the open is the engine's swap; it was made on the +// loop, and the window froze for the round trip. It goes through the ordered +// door line now ([app.offLoop]), because a swap is a gesture whose order +// matters, and the swap is taken when it answers. + +// teamsOpenBound is how long the pane says `opening` before it says the engine +// has not answered. Long enough for an ordinary open over the socket, short +// enough that a person is not left looking at a word with nothing behind it. +const teamsOpenBound = 4 * time.Second + +// teamsManagerGoneWord is the reason for a manager whose transcript is not on +// the disk any more. +const teamsManagerGoneWord = "its conversation is gone" + +// teamsOpenInChatsWord is the button that opens the manager where every +// conversation is opened, off the page. +const teamsOpenInChatsWord = "Open in chats" + +// teamsOpen is the page's one attempt to bring a manager in front: which +// manager, when it was asked, and how it ended. +type teamsOpen struct { + // key is the manager this attempt is for; gen tells a stale answer from + // the current one after a Retry. + key string + gen int + // at is when the open was asked, and out says it has not answered yet. + at time.Time + out bool + // why is the refusal, said on the pane; missing says the transcript is + // gone, which offers `+ Manager` rather than a door that cannot open it. + why string + missing bool + // done says the manager came in front on this attempt. + done bool +} + +// teamsOpenOut is one open a door has not answered yet: its attempt and when +// it was asked. +type teamsOpenOut struct { + gen int + at time.Time +} + +// teamsBringManager brings the selected team's manager in front when it is not +// there yet. It is the one move of the front this page makes, and only ever +// for the team the person chose: the conversation that was in front stays +// open behind, one `tab` away. A new attempt every time it is called, so the +// page's own doors (open, select, reopen) always try again. +func (a *app) teamsBringManager() tea.Cmd { + t, ok := a.teamsSelected() + if !ok || t.Closed() || t.Manager == "" || a.teamsOff() { + a.tp.open = teamsOpen{gen: a.tp.open.gen} + return nil + } + if t.Manager == a.frontTabKey() { + a.tp.open = teamsOpen{key: t.Manager, gen: a.tp.open.gen, done: true} + return nil + } + return a.teamsOpenManager(t, false) +} + +// teamsKeepManager is [app.teamsSync]'s half: an attempt for the selected +// team's manager when none has been made for it, whatever road left it out of +// front. It makes one attempt per manager: a refusal stays said until the +// person presses Retry or chooses again, rather than being asked every beat. +func (a *app) teamsKeepManager(t team) tea.Cmd { + if a.tp.open.key == t.Manager { + return nil + } + return a.teamsOpenManager(t, false) +} + +// teamsOpenManager asks for team t's manager: brought forward at once when this +// window holds it behind, and otherwise opened off the loop, landed behind, and +// brought forward when the answer comes back if the page still wants it. An +// open for the same manager that is still out is taken up rather than asked +// again, unless again says the person pressed Retry. +func (a *app) teamsOpenManager(t team, again bool) tea.Cmd { + key := t.Manager + a.tp.top = teamsTopCache{} + a.touch() + if out, ok := a.tp.opens[key]; ok && !again { + a.tp.open = teamsOpen{key: key, gen: out.gen, at: out.at, out: true} + return nil + } + a.tp.openSeq++ + gen := a.tp.openSeq + a.tp.open = teamsOpen{key: key, gen: gen, at: a.now(), out: true} + if held := a.behind[key]; held != nil { + cmd, _ := a.bringForward(held.conv.SessionFile) + a.tp.open.out, a.tp.open.done = false, true + return cmd + } + m, ok := t.Member(key) + if !ok || strings.TrimSpace(m.File) == "" { + a.teamsOpenFailed(gen, teamsManagerGoneWord, true) + return nil + } + file, where := m.File, m.Where + switch { + case a.shared: + // ONE CONVERSATION PER CONNECTION: the engine swaps in place and there + // is nothing to hold behind ([Options.SharedAgent]), so the swap is the + // open. The identity is asked here, from memory ([app.openBeside]'s + // rule); the swap itself is a door, asked on the line. + if cmd, ours := a.bringForward(file); ours { + a.tp.open.out, a.tp.open.done = false, true + return cmd + } + if !a.canOpen() { + a.teamsOpenFailed(gen, resumeUnavailableWord, false) + return nil + } + case !a.canOpen(): + a.teamsOpenFailed(gen, resumeUnavailableWord, false) + return nil + } + if a.tp.opens == nil { + a.tp.opens = map[string]teamsOpenOut{} + } + a.tp.opens[key] = teamsOpenOut{gen: gen, at: a.tp.open.at} + open, resume, local, shared := a.open, a.resume, !a.hosted(), a.shared + ask := func() func(bool) tea.Cmd { + var conv Conversation + var err error + missing := false + switch { + case local && !shared && transcriptGone(file): + // A local path is this machine's, so its absence is a fact; over + // --host the path is the far machine's and only its engine can say. + missing, err = true, errors.New(teamsManagerGoneWord) + case local && !shared && !homeFolderThere(where): + err = errors.New(WorkspaceGoneWord + " · " + where) + case open != nil: + conv, err = open(where, file) + default: + var agent Agent + agent, err = resume(file) + conv = Conversation{Agent: agent, Workspace: where, SessionFile: file} + } + if shared { + return func(bool) tea.Cmd { return a.teamsSwapped(gen, key, conv, err) } + } + return func(bool) tea.Cmd { return a.teamsOpened(gen, key, file, conv, err, missing) } + } + if shared { + return a.offLoop(ask) + } + return a.besideLine(ask) +} + +// transcriptGone reports whether a local transcript is not on the disk. Only a +// not-exist answer counts: a permission error is a door's to say. +func transcriptGone(file string) bool { + _, err := os.Stat(file) + return errors.Is(err, fs.ErrNotExist) +} + +// teamsOpened folds one open's answer in, on the loop. A conversation that +// opened is held behind, and brought forward only when the page still wants +// that manager: an answer that arrives after the person chose another team, or +// left the page, stays a tab of its own rather than moving them. An answer +// about the manager the page is asking for is the page's answer whichever +// attempt carried it, and a refusal is said only when it is the page's current +// attempt and the conversation is not in this window's hands after all. +func (a *app) teamsOpened(gen int, key, file string, conv Conversation, err error, missing bool) tea.Cmd { + if out, ok := a.tp.opens[key]; ok && out.gen == gen { + delete(a.tp.opens, key) + } + mine := a.tp.open.key == key + current := mine && a.tp.open.gen == gen + if err != nil || conv.Agent == nil { + switch { + case a.teamsOpenHeld(key, file): + return a.teamsLanded(key, file) + case current: + why := "the conversation did not open" + switch { + case errors.Is(err, session.ErrSessionLocked): + why = sessionBusyWord + case err != nil: + why = err.Error() + } + a.teamsOpenFailed(gen, why, missing) + } + return nil + } + var cmd tea.Cmd + if a.holding(conv.SessionFile) { + // Another road opened it while this ask was out (a Retry, or the + // person's own door); the window holds one handle per conversation. + leaveOffFrame(conv.Agent) + } else { + cmd = a.stow(conv, nil) + a.chatTabBar = tabBar{} + } + if mine { + cmd = tea.Batch(cmd, a.teamsLanded(key, conv.SessionFile)) + } + a.tp.top = teamsTopCache{} + a.touch() + return cmd +} + +// teamsLanded is the page's attempt for key answered with the conversation +// held: the pane stops waiting, and the manager comes in front if the page +// still wants it. +func (a *app) teamsLanded(key, file string) tea.Cmd { + a.tp.open.out, a.tp.open.why, a.tp.open.missing = false, "", false + a.tp.top = teamsTopCache{} + a.touch() + if !a.teamsWantsManager(key) { + return nil + } + cmd, _ := a.bringForward(file) + a.tp.open.done = true + return cmd +} + +// teamsOpenHeld reports whether a refusal for key is about a conversation this +// window already holds. Another answer landed it while this one was out, and +// this one met its lock. A refusal about a conversation in hand is no refusal, +// on the local open and on the swap alike. +func (a *app) teamsOpenHeld(key, file string) bool { + return a.tp.open.key == key && a.holding(file) +} + +// teamsSwapped folds a swap over a connection that holds one conversation at a +// time. The engine has already moved when it answers, so a conversation that +// opened is taken in front whatever the page wants now ([app.takeBeside]): the +// window must show the conversation its one handle names. A refusal about a +// conversation this window already holds is no refusal ([app.teamsOpenHeld]), +// the same rule as the local open. Any other refusal is said when it is the +// page's current attempt. +func (a *app) teamsSwapped(gen int, key string, conv Conversation, err error) tea.Cmd { + if out, ok := a.tp.opens[key]; ok && out.gen == gen { + delete(a.tp.opens, key) + } + current := a.tp.open.key == key && a.tp.open.gen == gen + if err != nil || conv.Agent == nil { + if a.teamsOpenHeld(key, conv.SessionFile) { + return a.teamsLanded(key, conv.SessionFile) + } + if current { + why := "the conversation did not open" + switch { + case errors.Is(err, session.ErrSessionLocked): + why = sessionBusyWord + case err != nil: + why = err.Error() + } + a.teamsOpenFailed(gen, why, false) + } + return nil + } + cmd := a.takeBeside(conv) + if a.tp.open.key == key { + a.tp.open.out, a.tp.open.why, a.tp.open.done = false, "", true + } + a.tp.top = teamsTopCache{} + a.touch() + return cmd +} + +// teamsOpenFailed says attempt gen's refusal on the pane. +func (a *app) teamsOpenFailed(gen int, why string, missing bool) { + if a.tp.open.gen != gen { + return + } + a.tp.open.out, a.tp.open.done = false, false + a.tp.open.why, a.tp.open.missing = why, missing + a.tp.top = teamsTopCache{} + a.touch() +} + +// teamsWantsManager reports whether the page still wants key in front: it is +// standing, and key is the selected open team's manager. +func (a *app) teamsWantsManager(key string) bool { + if !a.at(pageTeams) { + return false + } + t, ok := a.teamsSelected() + return ok && !t.Closed() && t.Manager == key +} + +// teamsRetryManager is `Retry`: a new attempt for the selected team's manager. +func (a *app) teamsRetryManager() tea.Cmd { + t, ok := a.teamsSelected() + if !ok || t.Closed() || t.Manager == "" { + return nil + } + return a.teamsOpenManager(t, true) +} + +// teamsOpenInChats is `Open in chats`: the manager opened through the chat +// surface's own door ([app.trafficGo]), off the page, where a refusal is said +// on the conversation's own line. +func (a *app) teamsOpenInChats() tea.Cmd { + t, ok := a.teamsSelected() + if !ok || t.Manager == "" { + return nil + } + a.leavePlace() + return a.trafficGo(t.Manager) +} + +// teamsManagerMissing reports whether team t's manager is known to be gone, so +// `+ Manager` may replace it. +func (a *app) teamsManagerMissing(t team) bool { + return t.Manager != "" && a.tp.open.key == t.Manager && a.tp.open.missing +} + +// teamsOpeningRows is the pane under the header while the selected team's +// manager is not in front: `opening` for the beat it takes, and once it has +// taken longer than [teamsOpenBound] or been refused, the reason and a way +// forward. +func (a *app) teamsOpeningRows(d *teamsDraw, t team, width, y int) []string { + pal := a.pal + name := t.Name + if t.Root { + name = "all teams" + } + manager := a.teamManagerMark() + " " + name + "'s manager" + o := a.tp.open + mine := o.key == t.Manager + why := "" + switch { + case t.Manager == a.frontTabKey(): + // In front, with a surface over it that keeps the pane from hosting it + // for now; nothing is being opened. + return nil + case mine && o.why != "": + why = o.why + case mine && o.out && a.now().Sub(o.at) >= teamsOpenBound: + why = "no answer in " + itoa(int(teamsOpenBound/time.Second)) + "s" + case mine && o.done: + // It came in front on this attempt and something has since moved the + // front off it. + out := []string{"", " " + pal.dim(fit(manager+" is not in front", width-2))} + return append(out, a.teamsOpenButtons(d, t, y+len(out), "Bring it here")...) + default: + word := "opening " + manager + a.linearMark("…", "...") + return []string{"", " " + pal.dim(fit(word, width-2))} + } + out := []string{""} + for _, l := range wrap("couldn't open "+manager+": "+why, max(width-2, 8)) { + out = append(out, " "+pal.muted(l)) + } + out = append(out, "") + return append(out, a.teamsOpenButtons(d, t, y+len(out), "Retry")...) +} + +// teamsOpenButtons is the pane's way forward: `retry` (the word says what it +// does here) and `Open in chats`, or `+ Manager` in place of the second when +// the manager's transcript is gone. +func (a *app) teamsOpenButtons(d *teamsDraw, t team, y int, retry string) []string { + pal := a.pal + row := " " + x := 1 + if a.teamsManagerMissing(t) { + s, w := d.button(teamManagerSlotWord, teamsTarget{act: teamsActManager, id: t.ID, x0: x, y: y, + hint: "Start a new manager for " + t.Name + hintSegment + "m"}, pal.ink) + row += s + " " + x += w + 2 + } + s, w := d.button(retry, teamsTarget{act: teamsActRetryManager, id: t.ID, x0: x, y: y, + hint: "Open " + t.Name + "'s manager here again"}, pal.ink) + row += s + x += w + if !a.teamsManagerMissing(t) { + row += " " + x += 2 + s, _ := d.button(teamsOpenInChatsWord, teamsTarget{act: teamsActOpenInChats, id: t.ID, x0: x, y: y, + hint: "Open " + t.Name + "'s manager as a conversation, off this page"}, pal.ink) + row += s + } + return []string{row} +} diff --git a/internal/tui3/teamsopen_test.go b/internal/tui3/teamsopen_test.go new file mode 100644 index 0000000000..64dbd40058 --- /dev/null +++ b/internal/tui3/teamsopen_test.go @@ -0,0 +1,388 @@ +package tui3 + +import ( + "errors" + "os" + "path/filepath" + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE MANAGER BROUGHT INTO THE PANE (teamsopen.go) ──────────────────────── + +// teamsOpenLab is the teams page lab with orbit given a manager this window is +// NOT holding: a transcript in a folder of its own, which is not the window's +// (`/tmp/lab`). made says whether the transcript is on the disk. The open door +// is a fake that records what it was asked and answers with err when set. +type teamsOpenLab struct { + a *app + harbor, orbit string + file, where string + key string + asked []string + err error +} + +func newTeamsOpenLab(t *testing.T, made bool) *teamsOpenLab { + t.Helper() + l := &teamsOpenLab{} + l.a, l.harbor, l.orbit = teamsPlaceLabIDs(t) + l.where = t.TempDir() + l.file = filepath.Join(l.where, "manager.jsonl") + if made { + if err := os.WriteFile(l.file, []byte("{}\n"), 0o600); err != nil { + t.Fatal(err) + } + } + l.key = l.a.convKey(l.file) + l.a.open = func(where, file string) (Conversation, error) { + l.asked = append(l.asked, where+" "+file) + if l.err != nil { + return Conversation{}, l.err + } + return Conversation{Agent: &fakeAgent{model: "m"}, Workspace: where, SessionFile: file}, nil + } + if err := l.a.teamEdit(func(f *teamstore.File) error { + if err := f.AddMember(l.orbit, teamstore.Member{Key: l.key, File: l.file, Where: l.where, Word: "run orbit", Handle: "boss"}); err != nil { + return err + } + return f.SetManager(l.orbit, l.key) + }); err != nil { + t.Fatal(err) + } + return l +} + +// selectOrbit chooses orbit on the rail, as a press does, and runs what that +// asked for. +func (l *teamsOpenLab) selectOrbit(t *testing.T) { + t.Helper() + drive(t, l.a, runCmd(l.a.teamsSelect(l.orbit))...) +} + +// A MANAGER THIS WINDOW IS NOT HOLDING OPENS IN THE PANE, AND THE PERSON STAYS +// ON THE PAGE. It is opened in its own folder, not the window's, off the loop, +// and the pane hosts it; the conversation that was in front stays open behind. +// Before the fix the open went through the switcher's door, which steps off +// the place standing, and the person was taken off the page to it. +func TestTeamsManagerNotHeldOpensInThePane(t *testing.T) { + l := newTeamsOpenLab(t, true) + was := l.a.frontTabKey() + l.selectOrbit(t) + if len(l.asked) != 1 || l.asked[0] != l.where+" "+l.file { + t.Fatalf("the door was asked %q, want the manager in its own folder %q", l.asked, l.where) + } + if !l.a.at(pageTeams) { + t.Fatalf("opening the manager took the person off the page, to %q", l.a.page.word()) + } + if l.a.frontTabKey() != l.key || !l.a.teamsHosting() { + t.Fatalf("the pane does not host the manager (front %q):\n%s", l.a.frontTabKey(), teamsFrameText(l.a)) + } + if !l.a.trafficHeld(was) { + t.Fatal("the conversation that was in front is not held behind") + } + if strings.Contains(teamsFrameText(l.a), "opening") { + t.Fatalf("the hosted pane still says opening:\n%s", teamsFrameText(l.a)) + } +} + +// A MANAGER HELD BEHIND COMES FORWARD at once, with no door asked. +func TestTeamsManagerHeldBehindComesForward(t *testing.T) { + a, _, orbit := teamsPlaceLabIDs(t) + m := mustTeam(t, a, orbit).Members[0] + if err := a.teamEdit(func(f *teamstore.File) error { return f.SetManager(orbit, m.Key) }); err != nil { + t.Fatal(err) + } + asked := 0 + a.open = func(where, file string) (Conversation, error) { + asked++ + return Conversation{}, errors.New("not asked") + } + drive(t, a, runCmd(a.teamsSelect(orbit))...) + if asked != 0 || a.frontTabKey() != m.Key || !a.teamsHosting() { + t.Fatalf("the held manager did not come forward (asked %d, front %q)", asked, a.frontTabKey()) + } +} + +// A MANAGER SET WHILE THE PAGE STANDS IS BROUGHT IN without anybody choosing +// the team again: a session naming one on the file, or the teams arriving +// after the page opened. The pane used to say `opening` with nothing behind it. +func TestTeamsManagerSetWhileThePageStandsIsBroughtIn(t *testing.T) { + a, _, orbit := teamsPlaceLabIDs(t) + drive(t, a, runCmd(a.teamsSelect(orbit))...) + where := t.TempDir() + file := filepath.Join(where, "later.jsonl") + if err := os.WriteFile(file, []byte("{}\n"), 0o600); err != nil { + t.Fatal(err) + } + a.open = func(w, f string) (Conversation, error) { + return Conversation{Agent: &fakeAgent{model: "m"}, Workspace: w, SessionFile: f}, nil + } + key := a.convKey(file) + if err := a.teamEdit(func(f *teamstore.File) error { + if err := f.AddMember(orbit, teamstore.Member{Key: key, File: file, Where: where, Word: "later", Handle: "later"}); err != nil { + return err + } + return f.SetManager(orbit, key) + }); err != nil { + t.Fatal(err) + } + // Any message: the page settles after every one. + drive(t, a, tea.WindowSizeMsg{Width: a.width, Height: a.height}) + if a.frontTabKey() != key || !a.teamsHosting() || !a.at(pageTeams) { + t.Fatalf("the manager set on the file was not brought in (front %q):\n%s", a.frontTabKey(), teamsFrameText(a)) + } +} + +// A REFUSAL IS SAID ON THE PANE WITH ITS REASON, and offers Retry and +// Open in chats. Retry asks again and hosts it; the refusal is not asked +// again on every beat. +func TestTeamsManagerRefusedSaysWhyAndRetries(t *testing.T) { + l := newTeamsOpenLab(t, true) + l.err = errors.New("the engine said no") + l.selectOrbit(t) + drive(t, l.a, tea.WindowSizeMsg{Width: l.a.width, Height: l.a.height}) + text := teamsFrameText(l.a) + for _, want := range []string{"couldn't open " + teamManagerGlyph + " orbit's manager: the engine said no", "Retry", teamsOpenInChatsWord} { + if !strings.Contains(text, want) { + t.Fatalf("the pane does not say %q:\n%s", want, text) + } + } + if len(l.asked) != 1 { + t.Fatalf("the refused open was asked %d times without a Retry", len(l.asked)) + } + if !l.a.at(pageTeams) { + t.Fatal("a refusal took the person off the page") + } + l.err = nil + drive(t, l.a, runCmd(l.a.teamsDo(teamsTargetOf(t, l.a, teamsActRetryManager, l.orbit)))...) + if l.a.frontTabKey() != l.key || !l.a.teamsHosting() { + t.Fatalf("Retry did not host the manager:\n%s", teamsFrameText(l.a)) + } +} + +// AN OPEN THE ENGINE HAS NOT ANSWERED IS SAID AFTER THE BOUND: `opening` for +// the beat it takes, then the reason and the way forward. Open in chats goes +// through the chat surface's own door, off the page. +func TestTeamsManagerSlowOpenIsSaidAfterTheBound(t *testing.T) { + l := newTeamsOpenLab(t, true) + now := time.Date(2026, 9, 24, 20, 0, 0, 0, time.UTC) + l.a.clock = func() time.Time { return now } + // The ask is left out: the engine has not answered. + _ = l.a.teamsSelect(l.orbit) + text := teamsFrameText(l.a) + if !strings.Contains(text, "opening "+teamManagerGlyph+" orbit's manager") || strings.Contains(text, "Retry") { + t.Fatalf("the pane does not say opening for the beat:\n%s", text) + } + now = now.Add(teamsOpenBound + time.Second) + l.a.tp.top = teamsTopCache{} + text = teamsFrameText(l.a) + for _, want := range []string{"couldn't open " + teamManagerGlyph + " orbit's manager: no answer in 4s", "Retry", teamsOpenInChatsWord} { + if !strings.Contains(text, want) { + t.Fatalf("after the bound the pane does not say %q:\n%s", want, text) + } + } + drive(t, l.a, runCmd(l.a.teamsDo(teamsTargetOf(t, l.a, teamsActOpenInChats, l.orbit)))...) + if l.a.at(pageTeams) || l.a.frontTabKey() != l.key { + t.Fatalf("Open in chats did not open the manager off the page (page %q, front %q)", l.a.page.word(), l.a.frontTabKey()) + } +} + +// A MANAGER WHOSE TRANSCRIPT IS GONE SAYS SO AND OFFERS `+ Manager`, which +// makes a new conversation the team's manager and hosts it. +func TestTeamsManagerGoneOffersANewManager(t *testing.T) { + l := newTeamsOpenLab(t, false) + l.selectOrbit(t) + text := teamsFrameText(l.a) + for _, want := range []string{"couldn't open " + teamManagerGlyph + " orbit's manager: " + teamsManagerGoneWord, teamManagerSlotWord, "Retry"} { + if !strings.Contains(text, want) { + t.Fatalf("the pane does not say %q:\n%s", want, text) + } + } + if len(l.asked) != 0 { + t.Fatalf("the door was asked for a transcript that is not there: %q", l.asked) + } + fresh := filepath.Join(t.TempDir(), "fresh.jsonl") + l.a.start = func(where string) (Conversation, error) { + return Conversation{Agent: &fakeAgent{model: "m"}, Workspace: where, SessionFile: fresh}, nil + } + drive(t, l.a, runCmd(l.a.teamsDo(teamsTargetOf(t, l.a, teamsActManager, l.orbit)))...) + teamsFlush(t, l.a) + if got := mustTeam(t, l.a, l.orbit).Manager; got != l.a.convKey(fresh) { + t.Fatalf("+ Manager did not replace the gone manager: %q", got) + } + if !l.a.teamsHosting() || !l.a.at(pageTeams) { + t.Fatalf("the new manager is not in the pane:\n%s", teamsFrameText(l.a)) + } +} + +// A PRESS ON A TRAFFIC ROW IN THE HOSTED MANAGER GOES THROUGH THE CHAT'S OWN +// DOOR and takes the person to that member, as a press on a member row does, +// rather than leaving the page over a conversation it does not host with the +// pane saying `opening`. +func TestTeamsHostedTrafficRowGoesToTheMember(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 180, 40 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "prices are in"}) + trafficReadNow(t, a) + if cmd := a.showPage(pageTeams); cmd != nil { + drive(t, a, runCmd(cmd)...) + } + drive(t, a, runCmd(a.teamsSelect(harbor))...) + a.tp.traffic = true + a.teamsSync() + if !a.teamsHosting() { + t.Fatalf("the pane does not host harbor's manager:\n%s", teamsFrameText(a)) + } + // The note answers nothing, so it is a line under General, laid open. + a.sideToggleThread(sideThreadKey(harbor, sideGeneral)) + frame, _, _ := a.frame() + rows := strings.Split(ansi.Strip(frame), "\n") + cols := a.railWidth() + // THE RAIL IS THREADS: the member's handle heads the thread and opens it, + // and the words under it are a door of their own. + at, x := -1, -1 + for y, r := range rows { + cells := plainCells(r, a.width-cols, a.width) + if i := strings.Index(cells, "@"+price); i >= 0 { + at, x = y, a.width-cols+len([]rune(cells[:i]))+1 + break + } + } + if at < 0 { + t.Fatalf("no Traffic row in the hosted pane:\n%s", strings.Join(rows, "\n")) + } + drive(t, a, tea.MouseClickMsg{X: x, Y: at, Button: tea.MouseLeft}) + if a.frontTabKey() != priceKey { + t.Fatalf("the row went to %q, want %q", a.frontTabKey(), priceKey) + } + if a.at(pageTeams) { + t.Fatalf("the page stayed over a conversation it does not host:\n%s", teamsFrameText(a)) + } +} + +// lockingOpen makes the lab's door behave like the real one about the +// transcript's lock: the first open of a file takes it, and every later open of +// the same file while it is held is refused as another window's. +func (l *teamsOpenLab) lockingOpen() { + held := map[string]bool{} + l.a.open = func(where, file string) (Conversation, error) { + l.asked = append(l.asked, where+" "+file) + if held[file] { + return Conversation{}, session.ErrSessionLocked + } + held[file] = true + return Conversation{Agent: &fakeAgent{model: "m"}, Workspace: where, SessionFile: file}, nil + } +} + +// A TEAM CHOSEN TWICE WHILE ITS MANAGER IS OPENING ASKS THE DOOR ONCE, AND THE +// MANAGER COMES IN. The second choice used to ask again: the first answer came +// back as a stale attempt and was put behind, the second met its lock, and the +// pane said the manager was open in another window until Retry was pressed. +// The two answers are run one after the other, first ask first, which is the +// order that stuck. +func TestTeamsManagerChosenTwiceWhileOpeningAsksOnceAndComesIn(t *testing.T) { + l := newTeamsOpenLab(t, true) + l.lockingOpen() + first := l.a.teamsSelect(l.orbit) + second := l.a.teamsSelect(l.orbit) + drive(t, l.a, runCmd(first)...) + drive(t, l.a, runCmd(second)...) + if len(l.asked) != 1 { + t.Fatalf("the door was asked %d times for one manager: %q", len(l.asked), l.asked) + } + if l.a.frontTabKey() != l.key || !l.a.teamsHosting() || l.a.tp.open.why != "" { + t.Fatalf("the manager is not in the pane (front %q, pane says %q):\n%s", l.a.frontTabKey(), l.a.tp.open.why, teamsFrameText(l.a)) + } +} + +// A RETRY PRESSED WHILE THE FIRST OPEN IS STILL OUT ASKS AGAIN, and whichever +// answer lands the manager is the page's: the first one, which the Retry made +// stale, brings the manager in, and the Retry's refusal about a conversation +// this window now holds is no refusal. +func TestTeamsManagerRetryRacingTheFirstOpenStillComesIn(t *testing.T) { + l := newTeamsOpenLab(t, true) + l.lockingOpen() + first := l.a.teamsSelect(l.orbit) + again := l.a.teamsRetryManager() + drive(t, l.a, runCmd(first)...) + drive(t, l.a, runCmd(again)...) + if len(l.asked) != 2 { + t.Fatalf("Retry did not ask the door again: %q", l.asked) + } + if l.a.frontTabKey() != l.key || !l.a.teamsHosting() || l.a.tp.open.why != "" { + t.Fatalf("the manager is not in the pane (front %q, pane says %q):\n%s", l.a.frontTabKey(), l.a.tp.open.why, teamsFrameText(l.a)) + } + if strings.Contains(teamsFrameText(l.a), sessionBusyWord) { + t.Fatalf("the pane says the manager is busy:\n%s", teamsFrameText(l.a)) + } +} + +// OVER A CONNECTION THAT HOLDS ONE CONVERSATION AT A TIME THE SWAP IS NOT MADE +// FROM UPDATE. Choosing the team asks nothing on the keystroke; the swap is a +// command, and when it answers the manager is the conversation in front. +func TestTeamsManagerSwapOverASharedConnectionIsAskedOffTheLoop(t *testing.T) { + l := newTeamsOpenLab(t, true) + l.a.shared = true + l.a.open = nil + swapped := 0 + l.a.resume = func(file string) (Agent, error) { + swapped++ + return &fakeAgent{model: "m"}, nil + } + cmd := l.a.teamsSelect(l.orbit) + if swapped != 0 { + t.Fatal("the swap was asked on the keystroke, from Update") + } + drive(t, l.a, runCmd(cmd)...) + if swapped != 1 { + t.Fatalf("the swap was asked %d times", swapped) + } + if l.a.frontTabKey() != l.key || !l.a.teamsHosting() { + t.Fatalf("the swapped manager is not in the pane (front %q):\n%s", l.a.frontTabKey(), teamsFrameText(l.a)) + } +} + +// A SWAP THAT MEETS THIS WINDOW'S OWN LOCK, WHILE THE MANAGER IS HELD BEHIND, +// IS NO REFUSAL. The local open forgives that case. The swap used to say the +// conversation was open in another window about one this window already holds. +// (A manager already in front is a different road: the page settles to done +// and the refusal does not stay on the pane.) +func TestTeamsSwappedLockWhileThisWindowHoldsItIsNoRefusal(t *testing.T) { + l := newTeamsOpenLab(t, true) + l.a.shared = true + if l.a.behind == nil { + l.a.behind = map[string]*kept{} + } + l.a.tp.sel = l.orbit + l.a.behind[l.key] = &kept{conv: Conversation{Agent: &fakeAgent{model: "m"}, SessionFile: l.file}} + if !l.a.holding(l.file) || l.a.frontTabKey() == l.key { + t.Fatal("the manager is not held behind") + } + l.a.tp.openSeq++ + gen := l.a.tp.openSeq + l.a.tp.open = teamsOpen{key: l.key, gen: gen, at: l.a.now(), out: true} + if selected, ok := l.a.teamsSelected(); !ok || selected.Manager != l.key || !l.a.at(pageTeams) { + t.Fatalf("the page does not want this manager (ok %v, manager %q, key %q, on page %v)", ok, selected.Manager, l.key, l.a.at(pageTeams)) + } + cmd := l.a.teamsSwapped(gen, l.key, Conversation{SessionFile: l.file}, session.ErrSessionLocked) + drive(t, l.a, tea.WindowSizeMsg{Width: l.a.width, Height: l.a.height}) + if cmd != nil { + drive(t, l.a, runCmd(cmd)...) + } + if l.a.tp.open.why != "" || strings.Contains(teamsFrameText(l.a), sessionBusyWord) { + t.Fatalf("a lock on a conversation this window holds was said (why %q):\n%s", l.a.tp.open.why, teamsFrameText(l.a)) + } + if l.a.frontTabKey() != l.key || !l.a.teamsHosting() { + t.Fatalf("the held manager was not brought forward (front %q):\n%s", l.a.frontTabKey(), teamsFrameText(l.a)) + } +} diff --git a/internal/tui3/teamspage.go b/internal/tui3/teamspage.go new file mode 100644 index 0000000000..a336f140dd --- /dev/null +++ b/internal/tui3/teamspage.go @@ -0,0 +1,858 @@ +package tui3 + +import ( + "path/filepath" + "strings" + "sync" + "time" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TEAMS PAGE: THE TEAM-LEVEL VIEW ───────────────────────────────────── +// +// The third of the three surfaces (DESIGN.md section 8.4, ruling c-b): the +// strip is what is open in this window, the wall is the same open set drawn +// big, and this page is the team as a team. Every member is on it whether this +// window has it open or not, with what it is doing and when it last moved; the +// packets waiting on the person are cards on it; and the selected team's +// manager is not summarised here, it IS here, as the real conversation +// (teamspagehost.go), so a person can run most of their work from this one +// page and step away. +// +// home teams chats sessions spend settings +// ──────────────────────────────────────────────────────────────────────── +// All teams + Manager │ ◆ harbor $1.20 of $5 today Settings Close… Open ▦ +// ● harbor ⠿ │ @web running now · @api idle 2h · @docs not open 3d +// ● parser ? 1 │ +// ● orbit │ ◆ conflict · raised by @web waiting on you +// │ which shape does the signup form send? +// + New team │ JSON @api changes the handler recommended +// ✦ Organize │ +// │ (the manager's own conversation, composer and all) +// ▸ Closed · 2 │ +// +// THE LEFT RAIL IS THE TREE (teamspagedraw.go). One row per open team, +// indented by level, each with its colour dot and at most one mark, and a mark +// only when something is happening: `⠿` dim while a member works, and the +// needs-you amber `? N` while N things wait on the person. Idle draws nothing. +// Above the teams is `All teams`: with no root team it carries `+ Manager` (the +// optional global manager, which makes the root); with one it is the root and +// selects like any team. Below them `+ New team` and `✦ Organize`, and at the +// foot, folded, `Closed · N`. +// +// EVERYTHING HERE IS READ OFF THE LOOP, THROUGH THE SEAM, WITH A STAMP +// (teamseam.go). The page's clock turns only while the page is up AND some +// team has a manager, because nothing else writes packets or spends a team's +// money; each turn asks the seam for the packets and the spend with the stamps +// it holds, and a quiet turn is answered `same` and draws nothing new. The +// frame reads memory and nothing else (framedisk_law_test.go). + +// teamsAllRow is the rail's `All teams` row while there is no root team behind +// it: a row the page draws over the top level with nothing stored. +const teamsAllRow = "\x00all" + +// The rail's width: a fifth of the frame between its floor and ceiling, and +// none at all under teamsRailFloor, where the page is the pane alone (the rail +// is still walked with its keys). +const ( + teamsRailMin = 22 + teamsRailMax = 30 + teamsRailFloor = 72 +) + +// teamsInboxWhole is how many cards the inbox draws whole; past it each card is +// one line, still pressable. +const teamsInboxWhole = 3 + +// The page's words, quoted in the manual exactly as spelled here. +const ( + teamsExplainWord = "A team is a set of conversations you run together; give it a manager and you talk to the manager, which hands out the work and asks you only what it cannot decide." + teamsNoManagerWord = "a manager takes your messages to the team and asks you only what it cannot decide" + teamsOrganizeWord = "Organize my conversations" + teamsNewTeamWord = "New team" + teamsHostedWord = "the inbox and the spend are not available over this connection" + teamsFocusKeys = "alt+↑↓" +) + +// teamsPage is the page's whole state, on the app (place_teams.go's handle +// holds none). +type teamsPage struct { + // sel is the team the pane is about: a team id, [teamsAllRow], or "" for + // none (no teams at all). + sel string + // closedOpen says the `Closed · N` fold is open. + closedOpen bool + // focus says the keyboard is on the page's buttons rather than on the + // manager's composer. With no manager in the pane there is no composer and + // the page always has the keyboard ([app.teamsHasKeys]). + focus bool + // cur is the target the keyboard is on and hot the one under the pointer, + // each named by what it does rather than by where it was drawn, so a + // frame that moved it keeps it lit. + cur, hot teamsRef + // targets is every pressable thing the last frame drew, in frame cells. + targets []teamsTarget + // expand is an inbox card beyond the first three that a press unfolded. + expand string + // railW is the rail's columns on the last sync, its separator included. + railW int + // host is the manager key the pane hosts, "" when it hosts none; forwarding + // says a key or a pointer event is being handed to that conversation + // (teamspagehost.go). + host string + forwarding bool + // traffic says the hosted manager's Traffic rail is out. It is folded by + // default here, because this page has a rail of its own on the left. + traffic bool + // reading says a read is out, so a beat that comes round before it is + // answered does not start a second; again says a read was asked for while + // it was out, and againWorld that the ask wanted the members' rows too. + // Neither is ever dropped: the fold asks again ([app.teamsFold]). + reading, again, againWorld bool + // The readings the frame draws from, each with the stamp the next read + // asks the seam to answer `same` to. + packets []teamstore.Packet + packetsStamp string + packetsKnown bool + spend map[string]teamstore.Spend + spendStamp map[string]string + defaults teamstore.Defaults + defaultsOK bool + world map[string]session.SessionRow + worldKnown bool + history map[string][]teamstore.Packet + // answering is the packet whose `Your own answer…` box is open, and answer + // the box. + answering string + answer editor + // msg is the page's one line of news, said on its note. + msg string + // open is the attempt to bring the selected team's manager in front, so + // the pane says what it is doing and, when it cannot, why (teamsopen.go). + // opens is every open a door has not answered yet, by manager, and + // openSeq the last attempt's number. + open teamsOpen + opens map[string]teamsOpenOut + openSeq int + // top is the hosted pane's header rows, kept between frames. + top teamsTopCache + // undo is the last close, while Undo is offered (teamclose.go). + undo teamsUndo + // picked is the teams picked on the rail with `space`, which one `Move + // into…` moves together (teammove.go). + picked map[string]bool +} + +// teamsTarget is one pressable thing on the page, in frame cells. +type teamsTarget struct { + x0, x1, y int + act teamsAct + // id is the team it acts on; arg and opt are the member key, the packet + // id and option, or the session row's transcript and answer key. + id, arg, opt string + // hint is what the hint line says with the pointer or the cursor on it, + // its key included. + hint string + // pane says the target is in the pane rather than on the rail. ↑ and ↓ + // walk within one of the two, and ← and → cross between them. + pane bool + // line is the body line the target is on with the pane unscrolled: the + // router's name for a row ([place.stops]), which a scroll does not move. + line int +} + +// teamsRef names a target by what it does. +type teamsRef struct { + act teamsAct + id, arg, opt string +} + +// ref is the target's name. +func (t teamsTarget) ref() teamsRef { return teamsRef{act: t.act, id: t.id, arg: t.arg, opt: t.opt} } + +// teamsAct is what a target does. +type teamsAct int + +const ( + teamsActNone teamsAct = iota + teamsActSelect + teamsActRootManager + teamsActNewTeam + teamsActOrganize + teamsActClosedFold + teamsActManager + teamsActSettings + teamsActClose + teamsActWall + teamsActMember + teamsActOption + teamsActOwnAnswer + teamsActPrompt + teamsActReopen + teamsActReopenParent + teamsActDelete + teamsActTraffic + teamsActUndo + teamsActRetryManager + teamsActOpenInChats + // The nesting acts (teammove.go, teamcrew.go): `Move` and `Cancel` on a + // move's consequence line, the header's `◆ Manager` and its members word. + teamsActMoveYes + teamsActMoveNo + teamsActManagerGo + teamsActCrew +) + +// ── THE TREE ──────────────────────────────────────────────────────────────── + +// teamsRailRow is one row of the rail's model. +type teamsRailRow struct { + kind int + id string + depth int +} + +const ( + railRowAll = iota + railRowTeam + railRowBlank + railRowNew + railRowOrganize + railRowClosed + railRowClosedTeam + // railRowNewIn is the second row of `+ New team in harbor` on a rail too + // narrow to say it on one: `in harbor`, under `+ New team`. + railRowNewIn +) + +// teamsRoot is the root team, false when there is none. Memory only. +func (a *app) teamsRoot() (team, bool) { + for _, t := range a.wall.teams { + if t.Root { + return t, true + } + } + return team{}, false +} + +// teamsOpenTree is every open team that is not the root, in tree order: each +// top-level team (or each team directly under the root) and then its open +// sub-teams, depth first, in stored order, with its depth from 0. +func (a *app) teamsOpenTree() []teamsRailRow { + root, hasRoot := a.teamsRoot() + var out []teamsRailRow + var walk func(parent string, depth int) + walk = func(parent string, depth int) { + for _, t := range a.wall.teams { + if t.Root || t.Closed() || t.Parent != parent { + continue + } + out = append(out, teamsRailRow{kind: railRowTeam, id: t.ID, depth: depth}) + if depth < 10 { + walk(t.ID, depth+1) + } + } + } + top := "" + if hasRoot { + top = root.ID + } + walk(top, 0) + return out +} + +// teamsClosed is every closed team, newest close first. +func (a *app) teamsClosed() []team { + return a.teamTree().ClosedTeams() +} + +// teamsRailRows is the rail, top to bottom. Memory only. +func (a *app) teamsRailRows() []teamsRailRow { + rows := []teamsRailRow{{kind: railRowAll}} + rows = append(rows, a.teamsOpenTree()...) + rows = append(rows, teamsRailRow{kind: railRowBlank}, teamsRailRow{kind: railRowNew}) + if _, split := a.teamsRailNewWords(); split { + rows = append(rows, teamsRailRow{kind: railRowNewIn}) + } + rows = append(rows, teamsRailRow{kind: railRowOrganize}) + if closed := a.teamsClosed(); len(closed) > 0 { + rows = append(rows, teamsRailRow{kind: railRowBlank}, teamsRailRow{kind: railRowClosed}) + if a.tp.closedOpen { + for _, t := range closed { + rows = append(rows, teamsRailRow{kind: railRowClosedTeam, id: t.ID}) + } + } + } + return rows +} + +// teamsAny reports whether there is any team at all, closed ones included. +func (a *app) teamsAny() bool { + for _, t := range a.wall.teams { + if !t.Root { + return true + } + } + _, root := a.teamsRoot() + return root +} + +// teamsSelected is the team the pane is about, false for the `All teams` row +// with no root and for nothing selected. +func (a *app) teamsSelected() (team, bool) { + if a.tp.sel == "" || a.tp.sel == teamsAllRow { + return team{}, false + } + return a.teamByID(a.tp.sel) +} + +// teamsSettle keeps the selection on something that exists: a team that went +// is replaced by the team of the conversation in front, else the first open +// team, else the root, else the `All teams` row, else nothing. +func (a *app) teamsSettle() { + if a.tp.sel == teamsAllRow { + if _, root := a.teamsRoot(); !root && a.teamsAny() { + return + } + a.tp.sel = "" + } + if t, ok := a.teamByID(a.tp.sel); ok { + if !t.Closed() || a.tp.closedOpen { + return + } + } + a.tp.sel = "" + if t, ok := a.teamOfFront(); ok && !t.Closed() && !t.Root { + a.tp.sel = t.ID + return + } + if tree := a.teamsOpenTree(); len(tree) > 0 { + a.tp.sel = tree[0].id + return + } + if root, ok := a.teamsRoot(); ok { + a.tp.sel = root.ID + return + } + if a.teamsAny() { + a.tp.sel = teamsAllRow + } +} + +// teamsManaged reports whether any open team has a manager, which is when the +// page's clock turns: nothing else writes packets or spends a team's money. +func (a *app) teamsManaged() bool { + for _, t := range a.wall.teams { + if t.Manager != "" && !t.Closed() { + return true + } + } + return false +} + +// teamsSubtree reports whether id is sel or under it. +func (a *app) teamsSubtree(sel, id string) bool { + if id == sel { + return true + } + for _, t := range a.teamAncestors(id) { + if t.ID == sel { + return true + } + } + return false +} + +// teamsPickedIDs is the teams picked with `space`, in rail order, the ones +// that went (closed, gone) left out. +func (a *app) teamsPickedIDs() []string { + var out []string + for _, r := range a.teamsOpenTree() { + if a.tp.picked[r.id] { + out = append(out, r.id) + } + } + return out +} + +// teamsPick picks team id on the rail with `space`, or unpicks it. +func (a *app) teamsPick(id string) { + t, ok := a.teamByID(id) + if !ok || t.Root || t.Closed() { + return + } + if a.tp.picked == nil { + a.tp.picked = map[string]bool{} + } + if a.tp.picked[id] { + delete(a.tp.picked, id) + } else { + a.tp.picked[id] = true + } + a.tp.top = teamsTopCache{} + a.touch() +} + +// teamsMoveIDs is what `Move into…` moves: the picked teams, else the selected +// one, else nothing. +func (a *app) teamsMoveIDs() []string { + if ids := a.teamsPickedIDs(); len(ids) > 0 { + return ids + } + if t, ok := a.teamsSelected(); ok && !t.Root && !t.Closed() { + return []string{t.ID} + } + return nil +} + +// ── WHAT A TEAM IS DOING ──────────────────────────────────────────────────── + +// teamsMemberState is one member as the page draws it: a word, whether it is +// the needs-you amber, and when it last moved ("" unknown). +type teamsMemberState struct { + word string + asking bool + open bool + at time.Time +} + +// teamsMember reads one member's state from memory: this window's own signal +// for a conversation it holds, and the world reading for one it does not. +func (a *app) teamsMember(m teamMember) teamsMemberState { + row, known := a.tp.world[filepath.Clean(m.File)] + st := teamsMemberState{} + if known { + st.at = row.At + } + if a.trafficHeld(m.Key) { + st.open = true + switch a.tabSignalFor(m.Key, m.Key == a.frontTabKey()) { + case tabNeedsPerson: + st.word, st.asking = "asking", true + case tabWorking: + st.word = "running" + default: + st.word = "idle" + } + if st.word == "running" { + st.at = a.now() + } + return st + } + switch { + case known && row.NeedsPerson(): + st.word, st.asking, st.open = "asking", true, true + case known && row.Live && row.Presence.State != "" && string(row.Presence.State) != "idle": + st.word, st.open = "running", true + case known && row.Open: + // Open in another window is a fact about that window, not the team: + // on this page it is idle like any other member at rest. + st.word, st.open = "idle", true + default: + st.word = "idle" + } + return st +} + +// teamsNeeds is how many things in team id wait on the person: packets raised +// from it (or under it) that wait on the person, and members asking. +func (a *app) teamsNeeds(t team) int { + n := 0 + for _, p := range a.tp.packets { + if p.Team == teamstore.Person && p.Waiting() && a.teamsSubtree(t.ID, p.Origin) { + n++ + } + } + for _, m := range t.Members { + if a.teamsMember(m).asking { + n++ + } + } + return n +} + +// teamsWorking reports whether a member of t is running. +func (a *app) teamsWorking(t team) bool { + for _, m := range t.Members { + if a.trafficHeld(m.Key) && a.tabSignalFor(m.Key, m.Key == a.frontTabKey()) == tabWorking { + return true + } + } + return false +} + +// teamsInbox is the packets the pane's inbox shows for the selection, oldest +// first so the newest is last: those waiting on the person that were raised in +// it or under it (every one of them on the root and the `All teams` row), and +// those waiting on its own manager. +func (a *app) teamsInbox() []teamstore.Packet { + sel := a.tp.sel + var out []teamstore.Packet + root, hasRoot := a.teamsRoot() + all := sel == teamsAllRow || hasRoot && sel == root.ID + for _, p := range a.tp.packets { + if !p.Waiting() { + continue + } + switch { + case p.Team == teamstore.Person && (all || a.teamsSubtree(sel, p.Origin)): + out = append(out, p) + case p.Team == sel && sel != "": + out = append(out, p) + } + } + return out +} + +// teamsPrompts is every member of the selection whose conversation is stopped +// on a question the person can answer from here: the session's own offer, read +// off the world, never this window's own conversation in front (its card is in +// the pane already). +func (a *app) teamsPrompts(t team) []session.SessionRow { + var out []session.SessionRow + now := time.Now() + for _, m := range t.Members { + row, ok := a.tp.world[filepath.Clean(m.File)] + if !ok || a.answeringHere(row) { + continue + } + if _, ok := answerable(row, now); ok { + out = append(out, row) + } + } + return out +} + +// ── THE SPEND AND THE CAP ─────────────────────────────────────────────────── + +// teamsPool is whose spend sits beside team t's cap, and the effective +// settings: the team itself with no cap or its own, the ancestor whose cap it +// inherits, and the top of the chain when the cap is the profile's default. A +// cap is a pool (DESIGN.md section 8.2), so the figure beside it is always the +// pool owner's. +func (a *app) teamsPool(t team) (string, teamstore.Effective) { + e := a.teamTree().Effective(t.ID, a.tp.defaults) + if e.CapUSDDay <= 0 { + return t.ID, e + } + switch e.CapFrom.Kind { + case teamstore.OriginTeam, teamstore.OriginAncestor: + return e.CapFrom.Team, e + } + top := t.ID + for _, up := range a.teamAncestors(t.ID) { + if !up.Closed() { + top = up.ID + } + } + return top, e +} + +// ── THE READ ──────────────────────────────────────────────────────────────── + +// teamsGot is what one read found, folded on the loop. +type teamsGot struct { + packets []teamstore.Packet + packetsStamp string + packetsSame bool + packetsErr error + defaults teamstore.Defaults + defaultsOK bool + spend map[string]teamstore.Spend + spendStamp map[string]string + world map[string]session.SessionRow + worldKnown bool + worldAsked bool + history map[string][]teamstore.Packet +} + +// THE PAGE HAS NO CLOCK OF ITS OWN. It answers the router's beat, which every +// place but home answers ([placeTeams.tick]), and on that beat it reads the +// store only while an open team has a manager: nothing else raises a packet +// or spends a team's money, so a page of plain teams reads nothing at all. +// Each read is stamped, so a quiet store answers `same` and the frame before +// it stands. +// +// ONE READ IS OUT AT A TIME, AND NONE IS EVER DROPPED. A read asked for while +// one is out (a team chosen while the beat's read is on the wire) is kept, and +// made the moment the one out is folded, with what the page wants THEN: the +// selection's own pool, not the pool of the team that was selected when the +// first read left. It used to be dropped, and the spend of a team chosen in that +// window waited for the next beat, or for ever on a page whose clock was not +// turning. +// +// AND IT READS WHAT THE PAGE DRAWS, NOT THE MACHINE. The rows are the members' +// of the open teams, twenty-five on a big machine: on this machine's disk they +// are read by name ([session.ReadRows]), where the page used to walk every +// session under the root on its opening and on every beat to find them, and +// over a connection they are taken out of the world the window already holds +// (tui3.go's [Options.World]), which costs nothing here. The store's doors are +// asked side by side rather than one after another, because over --host each +// of them is a round trip. + +// teamsRead asks the seam, beside the door line, for what the page draws: the +// packets and the spend of the selection's pool (each with its stamp, so a +// quiet file is answered `same`), the defaults, and the rows that say what a +// member this window does not hold is doing. withWorld is false for a read a +// gesture asked for, which needs only the store. +func (a *app) teamsRead(withWorld bool) tea.Cmd { + if a.teamsOff() { + return nil + } + if a.tp.reading { + a.tp.again = true + a.tp.againWorld = a.tp.againWorld || withWorld + return nil + } + a.tp.reading = true + seam := a.teamsSeam() + packetsSince := a.tp.packetsStamp + var pools []string + var closedReports []string + if t, ok := a.teamsSelected(); ok { + if t.Closed() { + closedReports = append(closedReports, t.ID) + } else { + owner, _ := a.teamsPool(t) + pools = append(pools, owner) + if owner != t.ID { + pools = append(pools, t.ID) + } + } + } + spendSince := make([]string, len(pools)) + for i, id := range pools { + spendSince[i] = a.tp.spendStamp[id] + } + var files []string + if withWorld { + files = a.teamsMemberFiles() + } + worldDoor, hosted, rowsDoor := a.world, a.hosted(), a.teamsDisk.rows + if rowsDoor == nil { + rowsDoor = session.ReadRows + } + return a.besideLine(func() func(bool) tea.Cmd { + got := teamsGot{spend: map[string]teamstore.Spend{}, spendStamp: map[string]string{}} + var wg sync.WaitGroup + side := func(read func()) { + wg.Add(1) + go func() { + defer wg.Done() + read() + }() + } + type spendGot struct { + spend teamstore.Spend + stamp string + ok bool + } + spends := make([]spendGot, len(pools)) + if seam.delegation() { + side(func() { + got.packets, got.packetsStamp, got.packetsSame, got.packetsErr = seam.Packets(teamstore.ScopeAll, packetsSince) + }) + side(func() { + if d, err := seam.Defaults(); err == nil { + got.defaults, got.defaultsOK = d, true + } + }) + for i, id := range pools { + side(func() { + s, stamp, same, err := seam.Spend(id, "", spendSince[i]) + if err == nil && !same { + spends[i] = spendGot{spend: s, stamp: stamp, ok: true} + } + }) + } + } + var histories [][]teamstore.Packet + if seam.History != nil && len(closedReports) > 0 { + histories = make([][]teamstore.Packet, len(closedReports)) + for i, id := range closedReports { + side(func() { + if list, err := seam.History(id); err == nil { + histories[i] = list + } + }) + } + } + if withWorld { + got.worldAsked = true + side(func() { got.world, got.worldKnown = teamsMemberRows(worldDoor, hosted, rowsDoor, files) }) + } + wg.Wait() + for i, id := range pools { + if spends[i].ok { + got.spend[id], got.spendStamp[id] = spends[i].spend, spends[i].stamp + } + } + for i, id := range closedReports { + if histories[i] != nil { + if got.history == nil { + got.history = map[string][]teamstore.Packet{} + } + got.history[id] = histories[i] + } + } + return func(bool) tea.Cmd { return a.teamsFold(got) } + }) +} + +// teamsMemberFiles is every member transcript of the open teams, cleaned and +// once each: what the page's rows are read for. Memory only. +func (a *app) teamsMemberFiles() []string { + seen := map[string]bool{} + var files []string + for _, t := range a.wall.teams { + if t.Closed() { + continue + } + for _, m := range t.Members { + file := strings.TrimSpace(m.File) + if file == "" { + continue + } + file = filepath.Clean(file) + if !seen[file] { + seen[file] = true + files = append(files, file) + } + } + } + return files +} + +// teamsMemberRows is the rows of files, keyed by cleaned transcript, and +// whether that is an answer: out of the world a connection's door holds, none +// at all over a connection with no such door (the rule [worldSeam] states), +// and otherwise read by name off this machine's disk. It runs off the loop. +func teamsMemberRows(door func() (session.World, bool), hosted bool, + read func([]string) map[string]session.SessionRow, files []string) (map[string]session.SessionRow, bool) { + switch { + case door != nil: + world, known := door() + if !known { + return nil, false + } + want := make(map[string]bool, len(files)) + for _, f := range files { + want[f] = true + } + rows := map[string]session.SessionRow{} + for _, p := range world.Projects { + for _, row := range p.Sessions { + if key := strings.TrimSpace(row.Transcript); key != "" && want[filepath.Clean(key)] { + rows[filepath.Clean(key)] = row + } + } + } + return rows, true + case hosted: + return nil, false + } + rows := read(files) + if rows == nil { + rows = map[string]session.SessionRow{} + } + return rows, true +} + +// teamsFold folds one read in. A read that found nothing new leaves the frame +// before it standing: the clock costs a stat and draws nothing. +func (a *app) teamsFold(got teamsGot) tea.Cmd { + a.tp.reading = false + changed := false + if got.packetsErr == nil && !got.packetsSame && got.packetsStamp != "" { + a.tp.packets, a.tp.packetsStamp, a.tp.packetsKnown = got.packets, got.packetsStamp, true + changed = true + } + if got.defaultsOK && (!a.tp.defaultsOK || got.defaults != a.tp.defaults) { + a.tp.defaults, a.tp.defaultsOK = got.defaults, true + changed = true + } + if len(got.spend) > 0 { + if a.tp.spend == nil { + a.tp.spend, a.tp.spendStamp = map[string]teamstore.Spend{}, map[string]string{} + } + for id, s := range got.spend { + a.tp.spend[id], a.tp.spendStamp[id] = s, got.spendStamp[id] + } + changed = true + } + if got.worldAsked && got.worldKnown && !teamsSameWorld(a.tp.world, got.world) { + a.tp.world, a.tp.worldKnown = got.world, true + changed = true + } + if len(got.history) > 0 { + if a.tp.history == nil { + a.tp.history = map[string][]teamstore.Packet{} + } + for id, list := range got.history { + a.tp.history[id] = list + } + changed = true + } + if changed { + a.tp.top = teamsTopCache{} + a.touch() + } else { + a.ptr.still = a.drawn + } + // A read asked for while this one was out is made now, for the page as it + // stands now ([app.teamsRead]). + if a.tp.again { + world := a.tp.againWorld + a.tp.again, a.tp.againWorld = false, false + if a.at(pageTeams) { + return a.teamsRead(world) + } + } + return nil +} + +// teamsSameWorld reports whether two readings say the same about every +// conversation the page draws from them: its state, its question and when it +// last moved. +func teamsSameWorld(was, now map[string]session.SessionRow) bool { + if len(was) != len(now) { + return false + } + for k, r := range now { + o, ok := was[k] + if !ok || !o.At.Equal(r.At) || o.Open != r.Open || o.Live != r.Live || + o.Presence.State != r.Presence.State || o.Presence.Question.ID != r.Presence.Question.ID || + o.Presence.Question.Kind != r.Presence.Question.Kind { + return false + } + } + return true +} + +// wallTeams is the teams the wall, its popovers and the strip's switcher list: +// every open team but the `All teams` root, which is the switcher's own `All` +// row and not a team a conversation is put in. A closed team is on the teams +// page's `Closed` fold and nowhere else. It is the loaded list itself, with +// nothing allocated, while no team is closed and there is no root. +func (a *app) wallTeams() []team { + hidden := 0 + for _, t := range a.wall.teams { + if t.Root || t.Closed() { + hidden++ + } + } + if hidden == 0 { + return a.wall.teams + } + out := make([]team, 0, len(a.wall.teams)-hidden) + for _, t := range a.wall.teams { + if !t.Root && !t.Closed() { + out = append(out, t) + } + } + return out +} diff --git a/internal/tui3/teamspage_test.go b/internal/tui3/teamspage_test.go new file mode 100644 index 0000000000..9b8a741204 --- /dev/null +++ b/internal/tui3/teamspage_test.go @@ -0,0 +1,794 @@ +package tui3 + +import ( + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TEAMS PAGE'S LAB ──────────────────────────────────────────────────── + +// teamsPlaceLab is the teams page over three conversations in two teams, orbit +// nested under harbor, with harbor (the conversation in front) selected and no +// manager yet, so the page draws the shared frame. +func teamsPlaceLab(t *testing.T) *app { + t.Helper() + a, _, _ := teamsPlaceLabIDs(t) + return a +} + +// teamsPlaceLabIDs is [teamsPlaceLab] with the two teams' ids. +func teamsPlaceLabIDs(t *testing.T) (a *app, harbor, orbit string) { + t.Helper() + a, harbor, orbit = menuApp(t) + a.profileDir = t.TempDir() + if err := a.teamEdit(func(f *teamstore.File) error { return f.SetParent(orbit, harbor) }); err != nil { + t.Fatal(err) + } + a.width, a.height = 120, 24 + if cmd := a.showPage(pageTeams); cmd != nil { + drive(t, a, runCmd(cmd)...) + } + if !a.at(pageTeams) { + t.Fatal("the teams place did not open") + } + a.teamsSync() + a.frame() + return a, harbor, orbit +} + +// teamsHits is, for each row of the last frame, the index of the target the +// keyboard walks on it (the cursor's own where it is on that row), and -1 for +// a row with none. +func teamsHits(a *app) []int { + a.frame() + hits := make([]int, a.height) + for i := range hits { + hits[i] = -1 + } + cur := a.teamsCursorIndex() + for i, tg := range a.tp.targets { + // The rail's rows, which the arrows walk as one list, and of those the + // ones a press at the left edge (where the shared tests press) lands on. + if tg.y < 0 || tg.y >= len(hits) || tg.pane || tg.x0 > 4 || tg.x1 <= 4 { + continue + } + if hits[tg.y] < 0 || i == cur { + hits[tg.y] = tg.line + } + } + return hits +} + +// teamsCursorLine is the body line the keyboard is on, -1 for none. +func teamsCursorLine(a *app) int { + if t, ok := a.teamsCursorTarget(); ok { + return t.line + } + return -1 +} + +// teamsFrameText is the whole frame, plain. +func teamsFrameText(a *app) string { + f, _, _ := a.frame() + return plain(f) +} + +// teamsTargetOf is the first drawn target of act (and id, when given). +func teamsTargetOf(t *testing.T, a *app, act teamsAct, id string) teamsTarget { + t.Helper() + a.frame() + for _, tg := range a.tp.targets { + if tg.act == act && (id == "" || tg.id == id) { + return tg + } + } + t.Fatalf("no target %d %q on the frame:\n%s", act, id, teamsFrameText(a)) + return teamsTarget{} +} + +// ── the place ─────────────────────────────────────────────────────────────── + +// TEAMS IS THE SECOND PLACE, right after home, on the bar and on the digits +// (ruling c-2), and /teams opens it too. +func TestTeamsIsTheSecondPlaceOnTheBarTheDigitsAndTheCommand(t *testing.T) { + if placeOrder[1] != pageTeams { + t.Fatalf("the second place is %q", placeOrder[1].word()) + } + a := placeApp(t) + bar := navPlaces(a, 120, false) + if !placeWordsInOrder(bar, "home", "teams", "chats", "sessions") { + t.Fatalf("the bar does not put teams after home: %q", bar) + } + drive(t, a, key("alt+2")) + if !a.at(pageTeams) { + t.Fatalf("alt+2 landed on %q", a.page.word()) + } + a.leavePlace() + typeLine(t, a, "/teams") + if !a.at(pageTeams) { + t.Fatalf("/teams landed on %q", a.page.word()) + } +} + +// NO TEAMS IS ONE SENTENCE AND TWO BUTTONS, and the organize button opens the +// wall's proposal. +func TestTeamsWithNoTeamsSaysWhatTheyAreAndOffersTwoWays(t *testing.T) { + a := placeApp(t) + a.width, a.height = 110, 24 + drive(t, a, key("alt+2")) + text := teamsFrameText(a) + for _, want := range []string{"A team is a set of conversations", teamsOrganizeWord, teamsNewTeamWord} { + if !strings.Contains(text, want) { + t.Fatalf("the empty page lost %q:\n%s", want, text) + } + } +} + +// THE RAIL IS THE TREE: orbit under harbor, indented, and the needs-you mark +// only when a packet waits on the person. +func TestTeamsRailIsTheTreeWithMarksOnlyWhenSomethingHappens(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + rail := func() []string { + lines := strings.Split(teamsFrameText(a), "\n") + for i, l := range lines { + if at := strings.Index(l, "│"); at >= 0 { + lines[i] = l[:at] + } + } + return lines + } + lines := rail() + hy, oy := -1, -1 + for y, l := range lines { + // The head is skipped: the strip's team chip reads `● harbor ▾` on + // every page. + if y < placeHeadRows { + continue + } + if hy < 0 && strings.Contains(l, "harbor") { + hy = y + } + if oy < 0 && strings.Contains(l, "orbit") { + oy = y + } + } + if hy < 0 || oy <= hy { + t.Fatalf("harbor at %d, orbit at %d:\n%s", hy, oy, strings.Join(lines, "\n")) + } + if strings.Index(lines[oy], "orbit") <= strings.Index(lines[hy], "harbor") { + t.Fatalf("orbit is not indented under harbor:\n%s\n%s", lines[hy], lines[oy]) + } + if strings.Contains(lines[hy], "?") || strings.Contains(lines[oy], "?") { + t.Fatalf("a quiet team carries a mark:\n%s", strings.Join(lines, "\n")) + } + a.tp.packets = []teamstore.Packet{{ID: "p1", Team: teamstore.Person, Origin: orbit, + Kind: teamstore.PacketQuestion, RaisedBy: "boss", Question: "Friday or Monday?", + State: teamstore.PacketOpen}} + a.tp.top = teamsTopCache{} + a.touch() + lines = rail() + if !strings.Contains(lines[oy], "? 1") { + t.Fatalf("orbit does not say a packet waits on you:\n%s", lines[oy]) + } + _ = harbor +} + +// THE INBOX CARD DECIDES A PACKET with one press on an option's word. +func TestTeamsInboxCardDecidesAPacket(t *testing.T) { + a, harbor, _ := teamsPlaceLabIDs(t) + flushTeams(t, a) + seam := a.teamsSeam() + p, err := seam.Raise(teamstore.Packet{Team: teamstore.Person, Origin: harbor, + Kind: teamstore.PacketConflict, RaisedBy: "boss", Question: "Which parser wins?", + Options: []teamstore.Option{{ID: "a", Label: "Keep the old one", Consequence: "no churn"}, + {ID: "b", Label: "Take the new one", Consequence: "two files move"}}, + Recommendation: &teamstore.Recommendation{Option: "b", Reason: "it is faster"}}) + if err != nil { + t.Fatal(err) + } + drive(t, a, runCmd(a.teamsRead(false))...) + text := teamsFrameText(a) + for _, want := range []string{"Which parser wins?", "Keep the old one", "Take the new one", "recommended"} { + if !strings.Contains(text, want) { + t.Fatalf("the card lost %q:\n%s", want, text) + } + } + var opt teamsTarget + for _, tg := range a.tp.targets { + if tg.act == teamsActOption && tg.arg == p.ID && tg.opt == "b" { + opt = tg + } + } + if opt.opt == "" { + t.Fatalf("no button for the recommended option:\n%s", text) + } + drive(t, a, runCmd(a.teamsDo(opt))...) + list, _, _, err := seam.Packets(teamstore.ScopeAll, "") + if err != nil { + t.Fatal(err) + } + for _, q := range list { + if q.ID == p.ID && q.Waiting() { + t.Fatalf("the press did not decide the packet: %+v", q) + } + } +} + +// flushTeams writes the lab's in-memory edits to its profile. +func flushTeams(t *testing.T, a *app) { + t.Helper() + if cmd := a.teamsWrite(); cmd != nil { + drive(t, a, runCmd(cmd)...) + } +} + +// teamsHostedLab is the lab with harbor's manager made of the conversation in +// front, so the pane hosts it. +func teamsHostedLab(t *testing.T) (a *app, harbor, orbit string) { + t.Helper() + a, harbor, orbit = teamsPlaceLabIDs(t) + for _, tab := range a.tabList() { + if tab.key == a.frontTabKey() { + if err := a.teamMakeManager(harbor, tab); err != nil { + t.Fatal(err) + } + } + } + drive(t, a, key("alt+1")) + drive(t, a, key("alt+2")) + if !a.teamsHosting() { + t.Fatalf("the pane does not host harbor's manager:\n%s", teamsFrameText(a)) + } + return a, harbor, orbit +} + +// THE PANE IS THE MANAGER'S REAL CONVERSATION: the bar still says teams, the +// rail stands on the left, the composer says whom it talks to, and a letter +// typed lands in the manager's own box. +func TestTeamsHostsTheManagersRealConversation(t *testing.T) { + a, _, _ := teamsHostedLab(t) + lines := strings.Split(teamsFrameText(a), "\n") + if len(lines) != a.height { + t.Fatalf("the hosted frame has %d rows, want %d", len(lines), a.height) + } + if !strings.Contains(lines[navRow], "teams") { + t.Fatalf("the nav does not say teams:\n%s", strings.Join(lines, "\n")) + } + w, _ := a.size() + if w != a.width-a.tp.railW { + t.Fatalf("the hosted conversation is %d wide, want %d", w, a.width-a.tp.railW) + } + text := strings.Join(lines, "\n") + for _, want := range []string{"All teams", "harbor", "orbit", "Settings", "Close…"} { + if !strings.Contains(text, want) { + t.Fatalf("the hosted page lost %q:\n%s", want, text) + } + } + drive(t, a, key("h"), key("i")) + if got := a.input.String(); got != "hi" { + t.Fatalf("typing on the hosted page put %q in the manager's box:\n%s", got, teamsFrameText(a)) + } + if !a.at(pageTeams) { + t.Fatalf("typing left the page for %q", a.page.word()) + } + // alt+↓ puts the keyboard on the page's buttons, and esc gives it back. + drive(t, a, tea.KeyPressMsg{Code: tea.KeyDown, Mod: tea.ModAlt}) + if !a.tp.focus { + t.Fatal("alt+↓ did not put the keyboard on the page") + } + drive(t, a, key("esc")) + if a.tp.focus || !a.at(pageTeams) { + t.Fatalf("esc did not give the keyboard back (focus %v, page %q)", a.tp.focus, a.page.word()) + } + // And tab still walks the places. + drive(t, a, key("tab")) + if a.at(pageTeams) { + t.Fatal("tab on the hosted page did not walk on") + } +} + +// ── the team's card ───────────────────────────────────────────────────────── + +// THE CARD SAYS WHERE EVERY VALUE COMES FROM: an inherited one dim with +// `· from Settings` or `· from <team>`, an override in ink with `reset`, and +// reset gives the value back to what it inherits. +func TestTeamsCardShowsProvenanceAndResets(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + five := 5.0 + if err := a.teamEdit(func(f *teamstore.File) error { + return f.SetSettings(harbor, func(s *teamstore.Settings) { s.CapUSDDay = &five }) + }); err != nil { + t.Fatal(err) + } + drive(t, a, runCmd(a.teamSheetOpen(orbit, teamSheetSettings))...) + if !a.tsheet.on { + t.Fatal("the card did not open") + } + text := teamsFrameText(a) + for _, want := range []string{"from Settings", "from harbor", "$5.00 a day"} { + if !strings.Contains(text, want) { + t.Fatalf("the card lost %q:\n%s", want, text) + } + } + if strings.Contains(text, "reset") { + t.Fatalf("a card with no override offers reset:\n%s", text) + } + a.teamSheetSave(tsDepth, "2") + if got, _ := a.teamByID(orbit); got.Settings.DepthLimit == nil || *got.Settings.DepthLimit != 2 { + t.Fatalf("the depth was not kept on orbit: %+v", got.Settings) + } + if text = teamsFrameText(a); !strings.Contains(text, "reset") || !strings.Contains(text, "2 levels") { + t.Fatalf("an override does not offer reset:\n%s", text) + } + a.teamSheetDo(tsDepth + tsReset) + if got, _ := a.teamByID(orbit); got.Settings.DepthLimit != nil { + t.Fatalf("reset left the override: %+v", got.Settings) + } + // A value out of its band is refused in the card's own words. + a.teamSheetSave(tsShare, "140") + if a.tsheet.err == "" { + t.Fatal("a share of 140% was taken") + } +} + +// ── closing ───────────────────────────────────────────────────────────────── + +// NOTHING RUNNING IS ONE CLOSE AND AN UNDO; the team moves to Closed and Undo +// puts it back. +func TestTeamsCloseWithNothingRunningIsOneClickAndUndo(t *testing.T) { + a, _, orbit := teamsPlaceLabIDs(t) + drive(t, a, runCmd(a.teamsCloseAsk(orbit))...) + if a.tsheet.on { + t.Fatal("a quiet team asked before closing") + } + if got, _ := a.teamByID(orbit); !got.Closed() { + t.Fatal("orbit did not close") + } + text := teamsFrameText(a) + if !strings.Contains(text, "Undo") || !strings.Contains(text, "Closed · 1") { + t.Fatalf("the close offers no Undo or no Closed fold:\n%s", text) + } + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActUndo, "")))...) + if got, _ := a.teamByID(orbit); got.Closed() { + t.Fatal("Undo did not reopen orbit") + } +} + +// SOMETHING RUNNING PUTS UP THE CARD: `Close now` first when no manager runs +// the team, `Wrap up first` first when one does, and Cancel changes nothing. +func TestTeamsCloseCardOffersWrapUpNowAndCancel(t *testing.T) { + a, harbor, _ := teamsPlaceLabIDs(t) + a.state = stateWorking + drive(t, a, runCmd(a.teamsCloseAsk(harbor))...) + if !a.tsheet.on || a.tsheet.mode != teamSheetClose || a.tsheet.cursor != tsCloseNow { + t.Fatalf("the card for a team with no manager: %+v", a.tsheet) + } + text := teamsFrameText(a) + if strings.Contains(text, "Wrap up first") || !strings.Contains(text, "Close now") || !strings.Contains(text, "Cancel") { + t.Fatalf("the card with no manager:\n%s", text) + } + a.teamSheetKey(key("esc")) + if got, _ := a.teamByID(harbor); a.tsheet.on || got.Closed() { + t.Fatal("Cancel closed the team or left the card up") + } + for _, tab := range a.tabList() { + if tab.key == a.frontTabKey() { + if err := a.teamMakeManager(harbor, tab); err != nil { + t.Fatal(err) + } + } + } + drive(t, a, runCmd(a.teamsCloseAsk(harbor))...) + if !a.tsheet.on || a.tsheet.cursor != tsWrapUp { + t.Fatalf("a managed team's card does not lead with Wrap up first: %+v", a.tsheet) + } + drive(t, a, runCmd(a.teamSheetDo(tsWrapUp))...) + if got, _ := a.teamByID(harbor); got.Closed() { + t.Fatal("Wrap up first closed the team at once") + } + if !strings.Contains(a.tp.msg, "wrap up") { + t.Fatalf("the wrap-up said nothing: %q", a.tp.msg) + } + drive(t, a, runCmd(a.teamsCloseAsk(harbor))...) + drive(t, a, runCmd(a.teamSheetDo(tsCloseNow))...) + if got, _ := a.teamByID(harbor); !got.Closed() { + t.Fatal("Close now did not close the team") + } +} + +// THE CLOSED FOLD shows a closed team's report, members and dates with +// Reopen and Delete…, and a team under a closed parent offers to reopen the +// parent too. +func TestTeamsClosedFoldReopensWithItsParent(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + drive(t, a, runCmd(a.teamsCloseAsk(harbor))...) + if got, _ := a.teamByID(orbit); !got.Closed() { + t.Fatal("closing the parent left the sub-team open") + } + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActClosedFold, "")))...) + drive(t, a, runCmd(a.teamsSelect(orbit))...) + text := teamsFrameText(a) + for _, want := range []string{"Reopen harbor too", "Delete…", "closed"} { + if !strings.Contains(text, want) { + t.Fatalf("the closed sub-team lost %q:\n%s", want, text) + } + } + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActReopenParent, orbit)))...) + for _, id := range []string{harbor, orbit} { + if got, _ := a.teamByID(id); got.Closed() { + t.Fatalf("%s is still closed", got.Name) + } + } +} + +// ── members ───────────────────────────────────────────────────────────────── + +// A MEMBER THIS WINDOW DOES NOT HOLD IS RESUMED BEHIND, in its own tab, and +// the person stays where they are. +func TestTeamsMemberPressResumesItBehind(t *testing.T) { + a, harbor, _ := teamsPlaceLabIDs(t) + far := "/tmp/lab/far-away.jsonl" + if err := a.teamEdit(func(f *teamstore.File) error { + return f.AddMember(harbor, teamstore.Member{Key: a.convKey(far), File: far, Where: "/tmp/lab", Word: "far", Handle: "far"}) + }); err != nil { + t.Fatal(err) + } + opened := "" + a.open = func(where, file string) (Conversation, error) { + opened = file + return Conversation{Agent: &fakeAgent{model: "m"}, Workspace: where, SessionFile: file}, nil + } + front := a.frontTabKey() + // An idle member is not on the header; the members card lists it, with + // `Resume` for one this window does not hold, and never says `not open`. + drive(t, a, runCmd(a.teamsDo(teamsTargetOf(t, a, teamsActCrew, harbor)))...) + text := teamsFrameText(a) + if !strings.Contains(text, "@far") || !strings.Contains(text, "Resume") || strings.Contains(text, "not open") { + t.Fatalf("the members card does not list the member this window does not hold:\n%s", text) + } + var member teamsCrewRow + for _, r := range a.teamCrewRows() { + if r.key == a.convKey(far) { + member = r + } + } + if member.key == "" { + t.Fatalf("no row for @far:\n%s", teamsFrameText(a)) + } + drive(t, a, runCmd(a.teamCrewGo(member))...) + if opened != far { + t.Fatalf("the press opened %q", opened) + } + if a.frontTabKey() != front || !a.at(pageTeams) { + t.Fatalf("the resume moved the person: front %q page %q", a.frontTabKey(), a.page.word()) + } + if !a.trafficHeld(a.convKey(far)) { + t.Fatal("the member is not held behind") + } +} + +// ── over --host ───────────────────────────────────────────────────────────── + +// OVER --host THE SETTINGS TEAMS TAB SAYS WHOSE DEFAULTS THE TEAMS READ and +// does not edit this machine's. +func TestTeamsSettingsTabOverHostIsReadOnlyAndSaysWhose(t *testing.T) { + a := placeApp(t) + a.host = "spark" + drive(t, a, key(placeChord(pageSettings))) + for i, title := range settingTabs { + if title == tabTeams { + a.sheet.tab = i + } + } + a.sheet.build() + if note := a.sheet.footNote(); !strings.Contains(note, "on spark") { + t.Fatalf("the Teams tab over --host says %q", note) + } + before := a.sheet.items[a.sheet.cursor].row.Value() + drive(t, a, key("enter")) + if a.sheet.edit != nil || !strings.Contains(a.sheet.msg, "spark") { + t.Fatalf("a Teams row took an edit over --host (msg %q)", a.sheet.msg) + } + if after := a.sheet.items[a.sheet.cursor].row.Value(); after != before { + t.Fatalf("the row changed from %q to %q", before, after) + } + a.host = "" + a.sheet.host = "" + if note := a.sheet.footNote(); !strings.Contains(note, "a team can override any of these on its card") { + t.Fatalf("the Teams tab says %q", note) + } +} + +// ── organize ──────────────────────────────────────────────────────────────── + +// ORGANIZE OFFERS TO CLOSE THE QUIET TEAMS, ticked like every suggestion, +// never on its own, and Undo reopens them. +func TestOrganizeOffersToCloseQuietTeamsWithUndo(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + old := a.now().Add(-10 * 24 * time.Hour) + if err := a.teamEdit(func(f *teamstore.File) error { + for i := range f.Teams { + f.Teams[i].Made = old + } + return nil + }); err != nil { + t.Fatal(err) + } + flushTeams(t, a) + _ = a.openWall() + a.wallSetTeam("") + drive(t, a, runCmd(a.wallOrganizeOpen())...) + var quiet *orgProp + for i := range a.wall.org.props { + if a.wall.org.props[i].team == orgCloseRow { + quiet = &a.wall.org.props[i] + } + } + if quiet == nil || len(quiet.closes) != 2 || quiet.name != "Close 2 quiet teams" { + t.Fatalf("Organize did not offer the quiet teams: %+v", a.wall.org.props) + } + // Its row is its sentence whole, then the teams: no colour dot and no + // second count, and not cut to a team name's width. + a.width, a.height = 110, 30 + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + if !strings.Contains(frame, "☑ Close 2 quiet teams harbor, orbit") { + t.Fatalf("the quiet-teams row reads:\n%s", frame) + } + for _, id := range []string{harbor, orbit} { + if got, _ := a.teamByID(id); got.Closed() { + t.Fatal("a suggestion closed a team before Apply") + } + } + a.wallOrganizeApply() + for _, id := range []string{harbor, orbit} { + if got, _ := a.teamByID(id); !got.Closed() { + t.Fatalf("Apply left %s open", got.Name) + } + } + a.wallOrganizeUndo() + for _, id := range []string{harbor, orbit} { + if got, _ := a.teamByID(id); got.Closed() { + t.Fatalf("Undo left %s closed", got.Name) + } + } +} + +// ── the session's contract (DESIGN.md 8.8) ────────────────────────────────── + +// WRAP UP FIRST IS THE ONE REQUEST LINE in the team's Traffic, which the +// manager's session reads; the team stays open until its report is accepted, +// and accepting it closes the team on its report. +func TestTeamsWrapUpAsksTheManagerAndTheReportCloses(t *testing.T) { + a, harbor, _ := teamsHostedLab(t) + flushTeams(t, a) + a.state = stateWorking + drive(t, a, runCmd(a.teamsCloseAsk(harbor))...) + if a.tsheet.cursor != tsWrapUp { + t.Fatalf("the card does not lead with Wrap up first: %+v", a.tsheet) + } + drive(t, a, runCmd(a.teamSheetDo(tsWrapUp))...) + log, err := teamstore.ReadTraffic(a.profileDir, harbor, "", 20) + if err != nil { + t.Fatal(err) + } + asked := false + for _, e := range log { + asked = asked || teamstore.IsWrapUp(e) + } + if !asked { + t.Fatalf("no wrap-up request in harbor's Traffic: %+v", log) + } + a.state = stateIdle + seam := a.teamsSeam() + p, err := seam.Raise(teamstore.Packet{Team: teamstore.Person, Origin: harbor, Kind: teamstore.PacketClosing, + RaisedBy: teamstore.FromManager, Question: "close harbor?", + Options: []teamstore.Option{{ID: teamstore.OptionClose, Label: "Close", Consequence: "the team closes on this report"}, + {ID: teamstore.OptionKeepGoing, Label: "Keep going", Consequence: "the team goes on"}}, + Recommendation: &teamstore.Recommendation{Option: teamstore.OptionClose, Reason: "everything is committed"}, + Report: &teamstore.ClosingReport{Done: "the parser ships", Left: "the docs", SpendUSD: 1.5}}) + if err != nil { + t.Fatal(err) + } + drive(t, a, runCmd(a.teamsRead(false))...) + text := teamsFrameText(a) + for _, want := range []string{"close harbor?", "the parser ships", "the docs", "Keep going"} { + if !strings.Contains(text, want) { + t.Fatalf("the closing report lost %q:\n%s", want, text) + } + } + var closeBtn teamsTarget + for _, tg := range a.tp.targets { + if tg.act == teamsActOption && tg.arg == p.ID && tg.opt == teamstore.OptionClose { + closeBtn = tg + } + } + drive(t, a, runCmd(a.teamsDo(closeBtn))...) + if got, _ := a.teamByID(harbor); !got.Closed() || got.Report != p.ID { + t.Fatalf("accepting the report did not close harbor on it: %+v", got) + } +} + +// A CAP PACKET SAYS ITS FIGURES, and `Raise to $X` is the decision alone: the +// session lifts the day's ceiling, so the team's own cap is not rewritten. +func TestTeamsCapPacketSaysItsFiguresAndRaisingWritesNoSetting(t *testing.T) { + a, harbor, _ := teamsPlaceLabIDs(t) + flushTeams(t, a) + p, err := a.teamsSeam().Raise(teamstore.Packet{Team: teamstore.Person, Origin: harbor, Kind: teamstore.PacketCap, + RaisedBy: teamstore.FromManager, Question: "harbor reached its $5 cap today", + Options: []teamstore.Option{{ID: teamstore.OptionRaiseCap, Label: "Raise to $10", Consequence: "harbor may spend $10 today"}, + {ID: teamstore.OptionStopToday, Label: "Stop for today", Consequence: "nothing new starts until tomorrow"}}, + Recommendation: &teamstore.Recommendation{Option: teamstore.OptionStopToday, Reason: "the day is nearly done"}, + Cap: &teamstore.CapFacts{Team: harbor, Day: teamstore.Today(), CapUSD: 5, SpentUSD: 5.2, RaiseTo: 10}}) + if err != nil { + t.Fatal(err) + } + drive(t, a, runCmd(a.teamsRead(false))...) + text := teamsFrameText(a) + for _, want := range []string{"spent $5.20 of $5.00 today", "Raise to $10", "Stop for today"} { + if !strings.Contains(text, want) { + t.Fatalf("the cap card lost %q:\n%s", want, text) + } + } + var raise teamsTarget + for _, tg := range a.tp.targets { + if tg.act == teamsActOption && tg.arg == p.ID && tg.opt == teamstore.OptionRaiseCap { + raise = tg + } + } + drive(t, a, runCmd(a.teamsDo(raise))...) + got, err := teamstore.PacketByID(a.profileDir, p.ID) + if err != nil || got.Decision != teamstore.OptionRaiseCap || got.DecidedBy != teamstore.Person { + t.Fatalf("the raise was not decided by the person: %+v %v", got, err) + } + if team, _ := a.teamByID(harbor); team.Settings.CapUSDDay != nil { + t.Fatalf("the raise rewrote harbor's cap: %+v", team.Settings) + } +} + +// WAKE IS ON THE CARD with where it comes from, and a shared member says whose +// manager it reports to. +func TestTeamsCardShowsWakeAndASharedMemberSaysWhoseItIs(t *testing.T) { + a, harbor, orbit := teamsHostedLab(t) + drive(t, a, runCmd(a.teamSheetOpen(harbor, teamSheetSettings))...) + if text := teamsFrameText(a); !strings.Contains(text, "team messages wake") { + t.Fatalf("the card has no wake row:\n%s", text) + } + a.teamSheetDo(tsWake) + if got, _ := a.teamByID(harbor); got.Settings.Wake == nil { + t.Fatal("the wake row did not override") + } + a.tsheet = teamSheet{} + // orbit's member, made a member of harbor too, keeps orbit as its home. + o, _ := a.teamByID(orbit) + m := o.Members[0] + if err := a.teamEdit(func(f *teamstore.File) error { + if err := f.AddMember(harbor, teamstore.Member{Key: m.Key, File: m.File, Where: m.Where, Word: m.Word, Handle: m.Handle}); err != nil { + return err + } + if err := f.AddMember(orbit, teamstore.Member{Key: "orbit-boss", Handle: "oboss", Word: "orbit's boss"}); err != nil { + return err + } + if err := f.SetManager(orbit, "orbit-boss"); err != nil { + return err + } + return f.SetHome(m.Key, orbit) + }); err != nil { + t.Fatal(err) + } + a.tp.top = teamsTopCache{} + // It says so on the members card, as a quiet tag whose hint names the + // manager, never as prose on the header. + if text := teamsFrameText(a); strings.Contains(text, "reports to orbit") { + t.Fatalf("the header still says whose the shared member is in prose:\n%s", text) + } + drive(t, a, runCmd(a.teamCrewOpen(harbor))...) + if text := teamsFrameText(a); !strings.Contains(text, "also in orbit") { + t.Fatalf("the members card does not tag the shared member:\n%s", text) + } + for i, r := range a.teamCrewRows() { + if r.key == m.Key { + a.tcrew.cursor = i + } + } + if hint := a.teamCrewHint(); !strings.Contains(hint, "reports to orbit's manager") { + t.Fatalf("the shared member's hint does not say whose it is: %q", hint) + } +} + +// BESIDE THE MANAGER THE INBOX LEAVES THE CONVERSATION ROOM. Three packets on +// a laptop's 34 rows used to take the whole pane, leaving the manager's chat +// one row; now the newest card is whole, the older ones fold to one line each +// that still says whose they are, and a press unfolds one. Each card leads +// with whose it is: the needs-you `?`, never the manager's mark. +func TestTeamsHostedInboxLeavesTheConversationRoom(t *testing.T) { + a, harbor, _ := teamsHostedLab(t) + a.width, a.height = 110, 34 + flushTeams(t, a) + seam := a.teamsSeam() + raise := func(kind, q string) teamstore.Packet { + p, err := seam.Raise(teamstore.Packet{Team: teamstore.Person, Origin: harbor, Kind: kind, RaisedBy: "boss", Question: q, + Options: []teamstore.Option{{ID: "a", Label: "One way", Consequence: "this happens"}, {ID: "b", Label: "The other", Consequence: "that happens"}}, + Recommendation: &teamstore.Recommendation{Option: "b", Reason: "it is cheaper"}}) + if err != nil { + t.Fatal(err) + } + return p + } + first := raise(teamstore.PacketQuestion, "Ship on Friday or Monday?") + raise(teamstore.PacketConflict, "Which parser wins?") + raise(teamstore.PacketQuestion, "Keep the old field names?") + drive(t, a, runCmd(a.teamsRead(false))...) + a.teamsSync() + if top := a.teamsHostTopHeight(); top > a.height/2 { + t.Fatalf("the inbox takes %d of %d rows over the manager's chat:\n%s", top, a.height, teamsFrameText(a)) + } + text := teamsFrameText(a) + if !strings.Contains(text, "Keep the old field names?") || !strings.Contains(text, "The other") { + t.Fatalf("the newest card is not whole:\n%s", text) + } + lines := strings.Split(text, "\n") + folded := 0 + for _, l := range lines { + if strings.Contains(l, "▸ question · Ship on Friday") || strings.Contains(l, "▸ conflict · Which parser") { + folded++ + if !strings.Contains(l, "waiting on you") { + t.Fatalf("a folded card does not say it waits on you: %q", l) + } + } + if strings.Contains(l, teamManagerGlyph+" question") || strings.Contains(l, teamManagerGlyph+" conflict") { + t.Fatalf("a card waiting on the person leads with the manager's mark: %q", l) + } + } + if folded != 2 { + t.Fatalf("%d cards folded, want 2:\n%s", folded, text) + } + if !strings.Contains(text, "? question · raised by @boss") { + t.Fatalf("the whole card does not lead with the needs-you mark:\n%s", text) + } + // A press on a folded card unfolds it and keeps the budget. + var fold teamsTarget + for _, tg := range a.tp.targets { + if tg.act == teamsActOption && tg.arg == first.ID && tg.opt == "" { + fold = tg + } + } + drive(t, a, runCmd(a.teamsDo(fold))...) + if text := teamsFrameText(a); !strings.Contains(text, "One way") || !strings.Contains(text, "Ship on Friday or Monday?") { + t.Fatalf("the press did not unfold the oldest card:\n%s", text) + } + if top := a.teamsHostTopHeight(); top > a.height/2 { + t.Fatalf("an unfolded card let the inbox take %d of %d rows", top, a.height) + } +} + +// THE MEMBERS CARD COUNTS WHAT THE HEADER COUNTS: `◆ Manager 1 member` on the +// header is `◆ Manager · 1 member` on the card, never `2 members`. +func TestTeamsMembersCardCountsLikeTheHeader(t *testing.T) { + a, harbor, _ := teamsHostedLab(t) + head := teamsFrameText(a) + if !strings.Contains(head, "1 member") { + t.Fatalf("the header's count:\n%s", head) + } + drive(t, a, runCmd(a.teamCrewOpen(harbor))...) + if text := teamsFrameText(a); !strings.Contains(text, "harbor · "+teamManagerGlyph+" Manager · 1 member") { + t.Fatalf("the card's title does not count like the header:\n%s", text) + } +} + +// A TEAM'S CARD STANDS OVER THE PANE, so the rail beside it still says which +// team is selected. +func TestTeamsCardsStandOverThePane(t *testing.T) { + a, harbor, _ := teamsPlaceLabIDs(t) + a.width, a.height = 110, 34 + a.teamsSync() + drive(t, a, runCmd(a.teamSheetOpen(harbor, teamSheetSettings))...) + teamsFrameText(a) + if rail := teamsRailCols(a.width); a.tsheet.rect.x0 < rail { + t.Fatalf("the settings card starts at %d, over the rail's %d columns:\n%s", a.tsheet.rect.x0, rail, teamsFrameText(a)) + } +} diff --git a/internal/tui3/teamspagedraw.go b/internal/tui3/teamspagedraw.go new file mode 100644 index 0000000000..aa4514a65b --- /dev/null +++ b/internal/tui3/teamspagedraw.go @@ -0,0 +1,1031 @@ +package tui3 + +import ( + "strings" + "time" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── DRAWING THE TEAMS PAGE (teamspage.go says what it is) ────────────────── +// +// Every function here reads memory and nothing else, and records where each +// pressable thing landed ([teamsTarget]) so the pointer and the keyboard act on +// what was drawn. A target is lit by name ([teamsRef]): the pointer's ground +// when it is under the pointer, the cursor's when the keyboard is on it. + +// teamsRailCols is the rail's columns at width, its separator column +// included, and 0 under [teamsRailFloor]. +func teamsRailCols(width int) int { + if width < teamsRailFloor { + return 0 + } + return min(max(width/5, teamsRailMin), teamsRailMax) +} + +// teamsDraw collects the targets of one frame as it is drawn. +type teamsDraw struct { + a *app + targets []teamsTarget +} + +// lit reports whether the target named r wears a ground, and which. +func (d *teamsDraw) lit(r teamsRef) (hot, cur bool) { + tp := &d.a.tp + cur = tp.focus && tp.cur == r + hot = tp.hot == r + return hot, cur +} + +// button paints one word button: the word with a cell of air either side, on +// the pointer's ground or the cursor's, and records it at x0 on row y. +func (d *teamsDraw) button(word string, t teamsTarget, ink func(string) string) (string, int) { + pal := d.a.pal + chip := " " + word + " " + w := ansi.StringWidth(chip) + t.x1 = t.x0 + w + d.targets = append(d.targets, t) + hot, cur := d.lit(t.ref()) + switch { + case cur: + return pal.selected(pal.bold(pal.ink(chip)), w), w + case hot: + return pal.cursor(pal.ink(chip), w), w + } + return ink(chip), w +} + +// row paints a whole-row target of width cells: its text, grounded when lit. +func (d *teamsDraw) row(text string, width int, t teamsTarget, selected bool) string { + pal := d.a.pal + t.x1 = t.x0 + width + d.targets = append(d.targets, t) + text = fit(text, width) + text += strings.Repeat(" ", max(width-ansi.StringWidth(text), 0)) + hot, cur := d.lit(t.ref()) + switch { + case cur: + return pal.cursor(text, width) + case selected: + return pal.selected(text, width) + case hot: + return pal.cursor(text, width) + } + return text +} + +// shift moves the targets recorded from index from by dx and dy. +func (d *teamsDraw) shift(from, dx, dy int) { + for i := from; i < len(d.targets); i++ { + d.targets[i].x0 += dx + d.targets[i].x1 += dx + d.targets[i].y += dy + } +} + +// pad is s padded or cut to exactly width cells. +func teamsPad(s string, width int) string { + if width <= 0 { + return "" + } + s = fit(s, width) + return s + strings.Repeat(" ", max(width-ansi.StringWidth(s), 0)) +} + +// ── THE RAIL ──────────────────────────────────────────────────────────────── + +// teamsRail is the rail, height rows of width cells (the separator not +// included), with its targets on rows counted from its first. +func (a *app) teamsRail(d *teamsDraw, width, height int) []string { + pal := a.pal + rows := a.teamsRailRows() + // THE CLOSED FOLD STANDS AT THE FOOT, where a person looks for what is put + // away; everything above it is the tree and its two doors. + split := len(rows) + for i, r := range rows { + if r.kind == railRowClosed { + split = i - 1 + break + } + } + headRows, tailRows := rows[:split], rows[split:] + if len(headRows)+len(tailRows) > height { + tailRows = tailRows[:max(0, min(len(tailRows), height-len(headRows)))] + } + out := make([]string, 0, height) + topSaid := false + paint := func(r teamsRailRow, y int) string { + switch r.kind { + case railRowAll: + return a.teamsRailAll(d, width, y) + case railRowTeam: + t, _ := a.teamByID(r.id) + return a.teamsRailTeam(d, t, r.depth, width, y) + case railRowNew: + return a.teamsRailNew(d, width, y, false) + case railRowNewIn: + return a.teamsRailNew(d, width, y, true) + case railRowBlank: + // DURING A TEAM DRAG THE FIRST BLANK UNDER THE TREE SAYS WHAT IT IS: + // the top level, where a drop on the empty rail puts the team. + if a.tdrag.on && !a.tdrag.member && !topSaid { + topSaid = true + word := " " + a.linearMark("↳", "->") + " Top level" + if a.teamDropLit(teamMoveTop) { + return a.pal.cursor(teamsPad(a.pal.ink(word), width), width) + } + return teamsPad(a.pal.dim(word), width) + } + case railRowOrganize: + return d.row(" "+a.teamsSpark()+" Organize", width, teamsTarget{act: teamsActOrganize, y: y, + hint: "Suggest teams for your conversations, and close quiet ones" + hintSegment + "o"}, false) + case railRowClosed: + fold := bandFoldGlyph + if a.tp.closedOpen { + fold = a.linearMark("▾", "v") + } + word := " " + fold + " Closed " + a.teamsDot() + " " + itoa(len(a.teamsClosed())) + hint := "Show the closed teams" + if a.tp.closedOpen { + hint = "Fold the closed teams away" + } + return d.row(pal.muted(word), width, teamsTarget{act: teamsActClosedFold, y: y, hint: hint + hintSegment + "enter"}, false) + case railRowClosedTeam: + t, _ := a.teamByID(r.id) + return d.row(" "+pal.dim(t.Name), width, teamsTarget{act: teamsActSelect, id: t.ID, y: y, + hint: t.Name + " closed" + hintSegment + "its report, members, Reopen and Delete"}, a.tp.sel == t.ID) + } + return strings.Repeat(" ", width) + } + for _, r := range headRows { + out = append(out, paint(r, len(out))) + } + for len(out)+len(tailRows) < height { + out = append(out, strings.Repeat(" ", width)) + } + for _, r := range tailRows { + out = append(out, paint(r, len(out))) + } + return out[:min(len(out), height)] +} + +// teamsDot is the middle dot in this terminal's glyphs. +func (a *app) teamsDot() string { return a.linearMark("·", "-") } + +// teamsSpark is Organize's mark. +func (a *app) teamsSpark() string { + spark, _ := wallOrgMarks(a.pal) + return spark +} + +// teamsRailAll is the `All teams` row: the root team when there is one, and +// otherwise a row over the top level carrying `+ Manager`, the optional +// global manager. +func (a *app) teamsRailAll(d *teamsDraw, width, y int) string { + pal := a.pal + if root, ok := a.teamsRoot(); ok { + return a.teamsRailTeam(d, root, 0, width, y) + } + word := teamManagerSlotWord + bw := ansi.StringWidth(word) + 2 + left := width - bw + selected := a.tp.sel == teamsAllRow + name := d.row(" "+pal.ink(teamstore.RootName), left, teamsTarget{act: teamsActSelect, id: teamsAllRow, y: y, + hint: "Every team, and what waits on you from any of them" + hintSegment + "enter"}, selected) + if left < 12 { + return teamsPad(name, width) + } + btn, _ := d.button(word, teamsTarget{act: teamsActRootManager, x0: left, y: y, + hint: "Start a manager over every team: you talk to it, it talks to theirs" + hintSegment + "m"}, pal.muted) + return name + btn +} + +// teamsRailTeam is one team's row: indent, colour dot, name, and at most one +// mark at the right. A team that is doing nothing draws no mark. +func (a *app) teamsRailTeam(d *teamsDraw, t team, depth, width, y int) string { + pal := a.pal + mark, markW := "", 0 + if n := a.teamsNeeds(t); n > 0 { + word := "? " + itoa(n) + mark, markW = pal.ask(word), ansi.StringWidth(word) + } else if a.teamsWorking(t) { + word := a.linearMark("⠿", "*") + mark, markW = pal.dim(word), ansi.StringWidth(word) + } + name := t.Name + if t.Root { + name = teamstore.RootName + } + lead := " " + strings.Repeat(" ", depth) + room := width - ansi.StringWidth(lead) - 2 - markW - 2 + if room < 3 { + room = 3 + } + if ansi.StringWidth(name) > room { + name = ansi.Truncate(name, room, a.linearMark("…", "~")) + } + // A TEAM PICKED WITH space wears the wall's own picked mark in place of + // its dot, so the rail says which teams one `Move into…` will move. + dot := a.tabTeamDot(t) + if a.tp.picked[t.ID] { + dot = pal.accent(wallGlyphsFor(pal.ascii).marked) + } + text := lead + dot + " " + pal.ink(name) + if t.Manager != "" { + text += " " + pal.dim(a.teamManagerMark()) + } + if mark != "" { + gap := width - ansi.StringWidth(text) - markW - 1 + text += strings.Repeat(" ", max(gap, 1)) + mark + } + hint := t.Name + if t.Manager != "" { + hint += hintSegment + "talk to its manager here" + } else { + hint += hintSegment + "no manager yet" + } + if !t.Root { + hint += hintSegment + "m move into…" + hintSegment + "space pick" + hintSegment + "drag to move" + } + tg := teamsTarget{act: teamsActSelect, id: t.ID, y: y, hint: hint + hintSegment + "enter"} + // DURING A DRAG only a row that takes the drop is grounded, and the row + // being dragged is dim, so the person sees what moves and where it can go. + if dr := a.tdrag; dr.on { + tg.x1 = tg.x0 + width + d.targets = append(d.targets, tg) + switch { + case a.teamDropLit(t.ID): + return pal.cursor(teamsPad(text, width), width) + case !dr.member && (dr.id == t.ID || a.tp.picked[dr.id] && a.tp.picked[t.ID]): + return teamsPad(pal.dim(ansi.Strip(text)), width) + } + return teamsPad(text, width) + } + return d.row(text, width, tg, a.tp.sel == t.ID) +} + +// teamsRailNew is the rail's `+ New team`, which with a team chosen reads +// `+ New team in harbor` and makes the new team inside it. On a rail too narrow +// for that on one row it is two, `+ New team` and `in harbor` under it, each a +// press on the same thing (second says which row this is); a name is never cut +// to make it fit. A chosen team that cannot take one more level dims it and +// says why. +func (a *app) teamsRailNew(d *teamsDraw, width, y int, second bool) string { + pal := a.pal + t, ok := a.teamsSelected() + if !ok || t.Closed() || t.Root { + return d.row(" + "+teamsNewTeamWord, width, teamsTarget{act: teamsActNewTeam, y: y, + hint: "Make a team of the conversation in front" + hintSegment + "n"}, false) + } + words, split := a.teamsRailNewWords() + tg := teamsTarget{act: teamsActNewTeam, id: t.ID, y: y, + hint: "Make a team inside " + t.Name + " of the conversation in front" + hintSegment + "n"} + switch { + case split && second: + words = " in " + t.Name + tg.opt = "in" + case split: + words = " + " + teamsNewTeamWord + } + if ok, why := a.teamsCanNest(t.ID); !ok { + tg.hint = why + return d.row(pal.dim(words), width, tg, false) + } + return d.row(words, width, tg, false) +} + +// teamsRailNewWords is `+ New team in harbor` for the chosen team, and whether +// the rail is too narrow to hold it on one row. +func (a *app) teamsRailNewWords() (string, bool) { + t, ok := a.teamsSelected() + if !ok || t.Closed() || t.Root { + return " + " + teamsNewTeamWord, false + } + words := " + " + teamsNewTeamWord + " in " + t.Name + return words, a.tp.railW > 0 && ansi.StringWidth(words) > a.tp.railW-2 +} + +// ── THE PANE'S HEAD: HEADER, MEMBERS, INBOX ───────────────────────────────── + +// teamsTopCache is the hosted pane's head rows as last drawn, and what they +// were drawn from, so the rows and the height the conversation is laid out +// under are one answer between frames. +type teamsTopCache struct { + key teamsTopKey + rows []string + targets []teamsTarget + ok bool +} + +// teamsTopKey is everything the head rows are drawn from that can move +// without the page hearing of it. +type teamsTopKey struct { + width, edits int + height int + stamp, sel string + cur, hot teamsRef + focus bool + sig uint64 + minute int64 + answering string + answer string + expand string + ascii, linear bool + undoing bool + moving string + dragging bool +} + +// teamsTopSig is a digest of the members' states this window can see change +// on its own: each held member's signal. It allocates nothing. +func (a *app) teamsTopSig(t team) uint64 { + var h uint64 = 14695981039346656037 + front := a.frontTabKey() + for _, m := range t.Members { + s := uint64(0) + if a.trafficHeld(m.Key) { + s = uint64(a.tabSignalFor(m.Key, m.Key == front)) + 1 + } + h = (h ^ s) * 1099511628211 + } + return h +} + +// teamsTop is the pane's head for the selection, width cells wide: the header +// row, the members, and the inbox. Targets are recorded on rows counted from +// its first and columns from the pane's. +func (a *app) teamsTop(d *teamsDraw, width int) []string { + pal := a.pal + t, ok := a.teamsSelected() + // A MOVE WAITING ON THE PERSON, OR A CLOSE OR A MOVE JUST MADE, is said + // first, over whichever team is shown now (teammove.go, teamclose.go). + out := a.teamsNoticeRows(d, width, 0) + if len(out) > 0 { + // Air between the notice and the team it is not about. + out = append(out, "") + } + if !ok { + if a.tp.sel == teamsAllRow { + out = append(out, " "+pal.bold(pal.ink(teamstore.RootName))) + out = append(out, a.teamsInboxRows(d, width, len(out))...) + } + return out + } + out = append(out, a.teamsHeader(d, t, width, len(out))) + if t.Closed() { + return out + } + // THE MEMBERS ARE ON THE HEADER (teamcrew.go): the ones doing something + // as chips, everyone else one word that opens the members card. + out = append(out, a.teamsNoManagerRows(d, t, width, len(out))...) + if !a.teamsCanDelegate() && !a.teamsOff() && a.hosted() { + out = append(out, "", " "+pal.dim(fit(teamsHostedWord, width-2))) + } + out = append(out, a.teamsPromptRows(d, t, width, len(out))...) + out = append(out, a.teamsInboxRows(d, width, len(out))...) + return out +} + +// teamsSpendWords is today's spend against the cap that applies: `$1.20 +// today` with no cap, `$1.20 of $5 today` with the team's own, and the pool +// owner's figure named when the cap is inherited, because a cap is a pool and +// `$1.20 of $5` beside a sub-team would read as a second $5. "" with nothing +// read yet. +func (a *app) teamsSpendWords(t team) string { + if !a.tp.defaultsOK { + return "" + } + owner, e := a.teamsPool(t) + s, ok := a.tp.spend[owner] + if !ok { + return "" + } + if e.CapUSDDay <= 0 { + // Nothing spent and no cap is nothing to say: an idle team draws no + // figure. + if s.USD <= 0 { + return "" + } + return dollars(s.USD) + " today" + } + words := dollars(s.USD) + " of " + teamsMoney(e.CapUSDDay) + " today" + if owner != t.ID { + if o, ok := a.teamByID(owner); ok { + name := o.Name + if o.Root { + name = teamstore.RootName + } + words += " " + a.teamsDot() + " " + name + "'s cap" + } + } + return words +} + +// teamsClosedWords is a closed team's dates: when it was made and closed. +func (a *app) teamsClosedWords(t team) string { + words := "closed" + if !t.ClosedAt.IsZero() { + words += " " + t.ClosedAt.Local().Format("2 Jan") + } + if !t.Made.IsZero() { + words = "opened " + t.Made.Local().Format("2 Jan") + " " + a.teamsDot() + " " + words + } + return words +} + +// teamsParentClosed is the closed team above t that keeps it closed, false +// when reopening t alone would work. +func (a *app) teamsParentClosed(t team) (team, bool) { + for _, up := range a.teamAncestors(t.ID) { + if up.Closed() { + return up, true + } + } + return team{}, false +} + +// teamsMembersRows is the members, every one whether this window has it open +// or not: its handle, what it is doing, and when it last moved, each a door. A +// press opens a member this window holds, and resumes one it does not behind +// the page, never moving the person's focus. +func (a *app) teamsMembersRows(d *teamsDraw, t team, width, y int) []string { + pal := a.pal + var pieces []string + var targets []teamsTarget + now := a.now() + for _, m := range t.Members { + if m.Key == t.Manager { + continue + } + st := a.teamsMember(m) + name := m.Word + if m.Handle != "" { + name = "@" + m.Handle + } + if strings.TrimSpace(name) == "" { + continue + } + name = fitConversationTitle(name, 24) + word := pal.ink(name) + " " + switch { + case st.asking: + word += pal.ask(st.word) + case st.word == "running" || strings.HasPrefix(st.word, "busy for "): + word += pal.muted(st.word) + default: + word += pal.dim(st.word) + } + plain := name + " " + st.word + if age := sinceAt(st.at, now); age != "" && st.word != "running" && !strings.HasPrefix(st.word, "busy for ") { + word += " " + pal.dim(age) + plain += " " + age + } + hint := name + " " + st.word + if st.open && a.trafficHeld(m.Key) { + hint += hintSegment + "click opens it" + } else { + hint += hintSegment + "click resumes it behind, in its own tab" + } + pieces = append(pieces, word) + targets = append(targets, teamsTarget{act: teamsActMember, id: t.ID, arg: m.Key, x1: ansi.StringWidth(plain), hint: hint}) + } + if len(pieces) == 0 { + return []string{" " + pal.dim("no members yet")} + } + var out []string + line, x := " ", 1 + sep := " " + a.teamsDot() + " " + for i, p := range pieces { + w := targets[i].x1 + if x > 1 && x+ansi.StringWidth(sep)+w > width-1 { + out = append(out, line) + line, x = " ", 1 + } + if x > 1 { + line += pal.dim(sep) + x += ansi.StringWidth(sep) + } + tg := targets[i] + tg.x0, tg.x1, tg.y = x, x+w, y+len(out) + d.targets = append(d.targets, tg) + hot, cur := d.lit(tg.ref()) + switch { + case cur: + p = pal.selected(p, 0) + case hot: + p = pal.cursor(p, 0) + } + line += p + x += w + } + return append(out, line) +} + +// ── THE INBOX ─────────────────────────────────────────────────────────────── + +// teamsPromptRows is the members' permission prompts, each a card with the +// answers the member's session offered: the person's own gate, answered through +// home's own door ([app.sendAnswer]). A manager never answers these. +func (a *app) teamsPromptRows(d *teamsDraw, t team, width, y int) []string { + pal := a.pal + var out []string + now := time.Now() + for _, row := range a.teamsPrompts(t) { + question, _ := answerable(row, now) + who := "@" + a.teamsHandleOf(t, row.Transcript) + head := question.Text + if question.Full != nil && strings.TrimSpace(question.Full.Head) != "" { + head = question.Full.Head + } + out = append(out, "") + out = append(out, " "+pal.ask("? "+who+" asks")+pal.dim(" "+a.teamsDot()+" ")+pal.ink(fit(switcherFirstLine(head), width-ansi.StringWidth(who)-12))) + if _, sent := a.answerSent(row, question); sent { + out = append(out, " "+pal.dim(answerWaitingWord)) + continue + } + line, x := " ", 2 + for _, chip := range answerChips(question) { + s, w := d.button(chip.label, teamsTarget{act: teamsActPrompt, id: t.ID, arg: row.Transcript, opt: chip.key, + x0: x, y: y + len(out), hint: chip.label + " for " + who + hintSegment + "your own gate; a manager never answers it"}, pal.ink) + if x+w > width { + break + } + line += s + " " + x += w + 1 + } + out = append(out, line) + } + return out +} + +// teamsHandleOf is the handle, or failing that the name, of the member whose +// transcript is file. +func (a *app) teamsHandleOf(t team, file string) string { + for _, m := range t.Members { + if strings.TrimSpace(m.File) == strings.TrimSpace(file) { + if m.Handle != "" { + return m.Handle + } + return m.Word + } + } + return "member" +} + +// teamsInboxRows is the packets waiting on the person or on this team's +// manager, one card each, newest last, each beyond the last three folded to +// one line a press unfolds. +// +// BESIDE THE MANAGER THE INBOX HAS A HEIGHT. While the pane hosts the +// manager's conversation, the cards are rows pinned over it, so three whole +// cards on a laptop's 34 rows left the conversation one row: the person could +// decide packets and could no longer read or steer the manager, which is what +// the page is for. So hosted, the cards may take about a third of the +// frame: the newest (or the one a press unfolded) is always whole, older ones +// stay whole while they fit, and the rest are one line each, as the fourth +// card always was. Unhosted, nothing else shares the pane and the old rule +// stands. +func (a *app) teamsInboxRows(d *teamsDraw, width, y int) []string { + pal := a.pal + if !a.teamsCanDelegate() { + return nil + } + packets := a.teamsInbox() + whole := make([]bool, len(packets)) + for i := range packets { + whole[i] = i >= len(packets)-teamsInboxWhole || a.tp.expand == packets[i].ID + } + if a.teamsHosting() && len(packets) > 1 { + budget := max(a.height/3-y, teamsInboxFloor) + // Measured on a scratch draw so the real one records only the targets + // it draws. + height := func(p teamstore.Packet) int { + return len(a.teamsCard(&teamsDraw{a: a}, p, width, 0)) + 1 + } + used := 0 + order := make([]int, 0, len(packets)) + for i := len(packets) - 1; i >= 0; i-- { + if a.tp.expand == packets[i].ID { + order = append([]int{i}, order...) + continue + } + order = append(order, i) + } + for n, i := range order { + if !whole[i] { + used++ + continue + } + h := height(packets[i]) + if n > 0 && used+h > budget && a.tp.expand != packets[i].ID { + whole[i] = false + used++ + continue + } + used += h + } + } + var out []string + for i, p := range packets { + if !whole[i] { + // One blank line over a run of folded lines, not one each. + if i == 0 || whole[i-1] { + out = append(out, "") + } + line := " " + pal.muted(a.linearMark("▸", ">")+" "+p.Kind+" "+a.teamsDot()+" ") + pal.ink(p.Question) + if p.Team == teamstore.Person { + line = teamsPad(line, width-ansi.StringWidth(teamsFoldWaiting)-1) + pal.ask(teamsFoldWaiting) + } + out = append(out, d.row(line, width, teamsTarget{act: teamsActOption, arg: p.ID, opt: "", y: y + len(out), + hint: "Unfold this card" + hintSegment + "enter"}, false)) + continue + } + out = append(out, "") + out = append(out, a.teamsCard(d, p, width, y+len(out))...) + } + return out +} + +// teamsInboxFloor is the fewest rows the hosted inbox is given however short +// the frame: one card's head, question and a couple of options. +const teamsInboxFloor = 8 + +// teamsFoldWaiting is a folded card's right edge when it waits on the person: +// the same needs-you word its whole card carries, so folding a card never +// hides that it is the person's to answer. +const teamsFoldWaiting = "waiting on you" + +// teamsCard is one decision packet as a card: +// +// ? conflict · raised by @web waiting on you +// which shape does the signup form send? +// @web the form posts JSON +// @api the endpoint takes form data +// JSON @api changes the handler; the form stays recommended +// form data @web rewrites the submit; the handler stays +// Your own answer… +// +// The options are word buttons with their consequence dim beside them; the +// recommended one says so; a packet waiting on a manager is dim and says whose, +// and the person may still decide it (authority: the person first). +// +// THE LEAD MARK SAYS WHOSE IT IS, never what a manager is. A card waiting on +// the person opens with the needs-you `?` the rail and the tabs already use; +// one waiting on a manager opens with the manager's mark. Every card used to +// open with the manager's mark, so `◆ question · raised by @boss` read as the +// manager's question. +func (a *app) teamsCard(d *teamsDraw, p teamstore.Packet, width, y int) []string { + pal := a.pal + mine := p.Team == teamstore.Person + var out []string + kind := p.Kind + if p.Kind == teamstore.PacketClosing && p.Report != nil && p.Report.Incomplete { + kind += " " + a.teamsDot() + " wrap-up incomplete" + } + lead := a.teamManagerMark() + if mine { + lead = "?" + } + head := kind + if by := strings.TrimSpace(p.RaisedBy); by != "" { + switch by { + case teamstore.FromManager: + by = a.teamManagerMark() + " manager" + case teamstore.Person: + default: + by = "@" + by + } + if by != teamstore.Person { + head += " " + a.teamsDot() + " raised by " + by + } + } + if t, ok := a.teamByID(p.Origin); ok && p.Origin != a.tp.sel { + head += " " + a.teamsDot() + " " + t.Name + } + waiting := teamsFoldWaiting + right := pal.ask(waiting) + if !mine { + name := p.Team + if t, ok := a.teamByID(p.Team); ok { + name = t.Name + } + waiting = "waiting on " + a.teamManagerMark() + " " + name + right = pal.dim(waiting) + } + headInk, leadInk := pal.muted, pal.muted + if mine { + headInk, leadInk = pal.ink, pal.ask + } + room := width - ansi.StringWidth(waiting) - 3 - ansi.StringWidth(lead) - 1 + line := " " + leadInk(lead) + " " + headInk(fit(head, room)) + line = teamsPad(line, width-ansi.StringWidth(waiting)-1) + right + out = append(out, line) + for _, l := range wrap(p.Question, max(width-3, 8)) { + out = append(out, " "+pal.ink(l)) + } + for _, party := range p.Parties { + who := party.Handle + if who == "" { + who = "member" + } + who = "@" + strings.TrimPrefix(who, "@") + ctx := strings.Join(strings.Fields(party.Context), " ") + out = append(out, " "+pal.muted(teamsPad(who, 10))+pal.dim(fit(ctx, max(width-14, 8)))) + } + // A CAP PACKET SAYS ITS FIGURES (DESIGN.md 8.8): what the pool spent of + // its cap today, and which team's pool that is. Its two options, + // `Raise to $X` and `Stop for today`, are the person's alone; the session + // reads a raise back from these same figures. + if c := p.Cap; c != nil { + pool := c.Team + if t, ok := a.teamByID(c.Team); ok { + pool = t.Name + } + said := "spent " + dollars(c.SpentUSD) + " of " + dollars(c.CapUSD) + " today " + a.teamsDot() + " " + pool + "'s cap" + out = append(out, " "+pal.dim(fit(said, max(width-4, 8)))) + } + if r := p.Report; r != nil { + add := func(label, text string) { + text = strings.TrimSpace(text) + if text == "" { + return + } + out = append(out, " "+pal.muted(teamsPad(label, 7))+pal.dim(fit(text, max(width-11, 8)))) + } + add("done", r.Done) + add("left", r.Left) + add("files", strings.Join(r.Files, ", ")) + if r.SpendUSD > 0 { + add("spent", dollars(r.SpendUSD)) + } + } + labelW := 0 + for _, o := range p.Options { + labelW = max(labelW, ansi.StringWidth(o.Label)+2) + } + labelW = min(labelW, max(width/2, 12)) + rec := "" + if p.Recommendation != nil { + rec = p.Recommendation.Option + } + for _, o := range p.Options { + word := o.Label + if ansi.StringWidth(word) > labelW-2 { + word = ansi.Truncate(word, labelW-2, a.linearMark("…", "~")) + } + hint := o.Label + hintSegment + o.Consequence + s, w := d.button(word, teamsTarget{act: teamsActOption, arg: p.ID, opt: o.ID, x0: 1, y: y + len(out), hint: hint}, pal.ink) + rest := strings.Repeat(" ", max(labelW-w, 0)) + " " + pal.dim(o.Consequence) + if o.ID == rec { + // THE RECOMMENDED OPTION IS MARKED ON ITS OWN ROW, and its reason + // is a line of its own under the options, where it can be read + // whole at any width. + rest += " " + pal.muted(a.linearMark(a.icon(tokens.GSettled), "*")+" recommended") + } + out = append(out, fit(" "+s+rest, width)) + } + if p.Recommendation != nil { + if reason := strings.TrimSpace(p.Recommendation.Reason); reason != "" { + for _, l := range wrap("recommended because "+reason, max(width-4, 8)) { + out = append(out, " "+pal.dim(l)) + } + } + } + if a.tp.answering == p.ID { + box, _, _ := draftBlock(&a.tp.answer, pal, width-4, 1, "your own answer, then enter", "") + for _, l := range box { + out = append(out, " "+l) + } + out = append(out, " "+pal.dim("enter decides with your words "+a.teamsDot()+" esc puts it away")) + } else { + s, _ := d.button("Your own answer"+a.linearMark("…", "..."), teamsTarget{act: teamsActOwnAnswer, arg: p.ID, x0: 1, y: y + len(out), + hint: "Decide it in your own words" + hintSegment + "enter"}, pal.muted) + out = append(out, " "+s) + } + return out +} + +// ── THE PANE'S BODY WHEN THE MANAGER IS NOT IN IT ─────────────────────────── + +// teamsPaneRest is what the pane draws under its head when it hosts no +// conversation: `+ Manager` for a team without one, the manager being brought +// in front, a closed team's report, or the `All teams` row's offer. +func (a *app) teamsPaneRest(d *teamsDraw, width, y int) []string { + pal := a.pal + t, ok := a.teamsSelected() + var out []string + switch { + case a.teamsOff(): + out = append(out, "", " "+pal.dim(fit(teamHostedWord, width-2))) + case !ok && a.tp.sel == teamsAllRow: + out = append(out, "", " "+pal.dim(fit("a manager over every team: you talk to it, and it talks to each team's own", width-2))) + s, _ := d.button(teamManagerSlotWord, teamsTarget{act: teamsActRootManager, x0: 1, y: y + len(out) + 1, + hint: "Start the manager of every team" + hintSegment + "m"}, pal.ink) + out = append(out, "", " "+s) + case !ok: + case t.Closed(): + out = append(out, a.teamsClosedRows(d, t, width, y)...) + case t.Manager == "": + // Its offer is drawn under the members ([app.teamsNoManagerRows]). + default: + // The manager on its way in, or why it is not (teamsopen.go). + out = append(out, a.teamsOpeningRows(d, t, width, y+len(out))...) + } + return out +} + +// teamsNoManagerRows is a team without a manager's one offer, under its +// members and above anything waiting, so a long inbox never pushes it off the +// pane: `+ Manager` and what a manager is, wrapped beside it. +func (a *app) teamsNoManagerRows(d *teamsDraw, t team, width, y int) []string { + if t.Manager != "" || t.Closed() || t.Root || a.teamsOff() { + return nil + } + pal := a.pal + s, w := d.button(teamManagerSlotWord, teamsTarget{act: teamsActManager, id: t.ID, x0: 1, y: y + 1, + hint: "Start " + t.Name + "'s manager: a conversation that runs the team for you" + hintSegment + "m"}, pal.ink) + lead := 1 + w + 2 + said := wrap(teamsNoManagerWord, max(width-lead, 8)) + out := []string{""} + for i, l := range said { + if i == 0 { + out = append(out, " "+s+" "+pal.dim(l)) + continue + } + out = append(out, strings.Repeat(" ", lead)+pal.dim(l)) + } + return out +} + +// teamsClosedRows is a closed team's view: its closing report when there is +// one, and its members, each still a door to its conversation. +func (a *app) teamsClosedRows(d *teamsDraw, t team, width, y int) []string { + pal := a.pal + var out []string + var report *teamstore.Packet + for i, p := range a.tp.history[t.ID] { + if p.ID == t.Report || (t.Report == "" && p.Kind == teamstore.PacketClosing) { + report = &a.tp.history[t.ID][i] + } + } + out = append(out, "") + switch { + case report != nil && report.Report != nil: + out = append(out, " "+pal.muted("closing report")) + r := report.Report + add := func(label, text string) { + if text = strings.TrimSpace(text); text != "" { + for i, l := range wrap(text, max(width-11, 8)) { + if i == 0 { + out = append(out, " "+pal.muted(teamsPad(label, 7))+pal.ink(l)) + } else { + out = append(out, " "+pal.ink(l)) + } + } + } + } + add("done", r.Done) + add("left", r.Left) + add("files", strings.Join(r.Files, ", ")) + if r.SpendUSD > 0 { + add("spent", dollars(r.SpendUSD)) + } + case !a.teamsCanReadHistory(): + out = append(out, " "+pal.dim(fit("its closing report is kept where the team ran, and is not readable over this connection", width-2))) + default: + out = append(out, " "+pal.dim("closed without a report")) + } + out = append(out, "", " "+pal.muted("members")) + members := a.teamsMembersRows(d, t, width, y+len(out)) + return append(out, members...) +} + +// teamsEmpty is the page with no teams at all: what a team is, and the two +// ways to make one. +func (a *app) teamsEmpty(d *teamsDraw, width, height int) []string { + pal := a.pal + room := min(width-4, 72) + lead := max((width-room)/2, 2) + pad := strings.Repeat(" ", lead) + var out []string + lines := wrap(teamsExplainWord, room) + top := max((height-len(lines)-4)/3, 1) + for range top { + out = append(out, "") + } + for _, l := range lines { + out = append(out, pad+pal.ink(l)) + } + out = append(out, "") + y := len(out) + s1, w1 := d.button(a.teamsSpark()+" "+teamsOrganizeWord, teamsTarget{act: teamsActOrganize, x0: lead, y: y, + hint: "Suggest teams; nothing changes until you apply" + hintSegment + "o"}, pal.ink) + s2, _ := d.button("+ "+teamsNewTeamWord, teamsTarget{act: teamsActNewTeam, x0: lead + w1 + 2, y: y, + hint: "Make a team of the conversation in front" + hintSegment + "n"}, pal.ink) + out = append(out, pad+s1+" "+s2) + return out +} + +// ── THE WHOLE PAGE WHEN IT HOSTS NO CONVERSATION ──────────────────────────── + +// teamsBody is the page's body inside the shared place frame: the rail and the +// pane side by side, or the explainer alone with no teams. Its targets are +// recorded in frame cells. +func (a *app) teamsBody(width, room int) []placeRow { + d := &teamsDraw{a: a} + a.teamsSettle() + var lines []string + if !a.teamsAny() { + lines = a.teamsEmpty(d, width, room) + for i := range d.targets { + d.targets[i].line = d.targets[i].y + } + } else { + railW := teamsRailCols(width) + paneW := width - railW + var rail []string + if railW > 0 { + rail = a.teamsRail(d, railW-1, room) + for i := range d.targets { + d.targets[i].line = d.targets[i].y + } + } else { + // TOO NARROW FOR TWO COLUMNS, the rail stands over the pane as one + // list, and the arrows walk the two as one. + lines = a.teamsRail(d, width, len(a.teamsRailRows())) + lines = append(lines, a.pal.dim(rule(width))) + for i := range d.targets { + d.targets[i].line = d.targets[i].y + } + } + top := len(lines) + mark := len(d.targets) + pane := a.teamsTop(d, paneW-1) + pane = append(pane, a.teamsPaneRest(d, paneW-1, len(pane))...) + for i := mark; i < len(d.targets); i++ { + d.targets[i].line = top + d.targets[i].y + } + // THE PANE SCROLLS TO KEEP THE CURSOR ON IT: a long inbox moves up + // under a cursor walking down it, rather than walking it off the frame. + if vis := room - top; len(pane) > vis && vis > 0 { + off := 0 + for _, t := range d.targets[mark:] { + if t.ref() == a.tp.cur && t.y >= vis { + off = min(t.y-vis+1, len(pane)-vis) + } + } + if off > 0 { + pane = pane[off:] + d.shift(mark, 0, -off) + } + } + d.shift(mark, railW, top) + for i := mark; i < len(d.targets) && railW > 0; i++ { + d.targets[i].pane = true + } + sep := a.pal.dim(a.linearMark("│", "|")) + for i := 0; i < room-top; i++ { + left := "" + if railW > 0 { + left = strings.Repeat(" ", railW-1) + if i < len(rail) { + left = rail[i] + } + left += sep + } + right := "" + if i < len(pane) { + right = pane[i] + } + lines = append(lines, left+teamsPad(right, paneW)) + } + } + // Only what was drawn can be pressed. + kept := d.targets[:0] + for _, t := range d.targets { + if t.y >= 0 && t.y < room { + kept = append(kept, t) + } + } + d.targets = kept + d.shift(0, 0, placeHeadRows) + a.tp.targets = d.targets + // A CURSOR WHOSE BUTTON IS GONE (a team closed, a card decided) comes home + // to the selected team's row for the next frame, rather than standing on + // nothing. + if a.tp.focus && len(d.targets) > 0 && a.teamsCursorIndex() < 0 { + a.teamsCursorHome() + } + rows := make([]placeRow, 0, room) + for i := 0; i < room; i++ { + text := "" + if i < len(lines) { + text = lines[i] + } + rows = append(rows, placeRow{text: text}) + } + return rows +} diff --git a/internal/tui3/teamspagehost.go b/internal/tui3/teamspagehost.go new file mode 100644 index 0000000000..e3ac00e9f6 --- /dev/null +++ b/internal/tui3/teamspagehost.go @@ -0,0 +1,495 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" +) + +// ── THE MANAGER'S REAL CONVERSATION, HOSTED ON THE TEAMS PAGE ─────────────── +// +// The ruling (c-2) is that the right pane of the teams page IS the selected +// team's manager conversation, the full chat: typing steers it, its prompts are +// answered in it, its Traffic rail is there. Not a render of it: the same +// conversation, with every key and every press it would have had. +// +// SO THE PAGE DOES NOT DRAW A CONVERSATION; IT LENDS ONE A RECTANGLE. While the +// pane hosts the manager ([app.teamsHosting]), the conversation's own geometry +// is the terminal less the rail on the left: [app.size] answers the narrower +// width, so every layout, scroll and hit test the conversation makes resolves +// against the cells it is really drawn in. The frame is the conversation's own +// ([app.chatFrameLines]) with two changes: the head's rows are the places' +// head at the full width (so the bar still says `teams`), and the page's header, +// members and inbox are pinned rows between the head and the transcript, +// charged in [app.topHeight] exactly as the task strip is, so the scrolling +// knows they are there. The rail is joined on the left of every row under the +// head. +// +// EVERY KEY AND POINTER EVENT THE PAGE DOES NOT TAKE IS HANDED TO THE +// CONVERSATION as if no place were standing ([app.teamsRoute]): the page is +// set aside for the length of that one message, the pointer's column is moved +// into the conversation's own cells, and the conversation answers exactly as +// it does on its own screen. The page keeps `tab`, the digits and the map (the +// place grammar), `alt+↑↓` (the page's buttons), and presses on its own rows. +// +// THE MANAGER IS BROUGHT IN FRONT when its team is selected +// ([app.teamsBringManager]), and that is the one move of the front this page +// makes: choosing a team is choosing whom to talk to. The conversation that was +// in front stays open behind. + +// teamsHosting reports whether the pane hosts the manager now: the page is +// standing (or a message is being handed to the conversation), the selected +// team's manager is the conversation in front, and no surface that takes the +// whole frame is up over it. It is asked by [app.size] on every layout, so it +// reads a handful of fields and allocates nothing. +func (a *app) teamsHosting() bool { + return a.tp.host != "" && (a.at(pageTeams) || a.tp.forwarding) && !a.wall.on && !a.setup.open && + !a.railTaskPlanOn && !a.workTabOn && !a.pasteEdit.open && a.tp.host == a.frontTabKey() +} + +// teamsHostRail is the rail's columns while the pane hosts the manager, its +// separator included, and 0 when it does not. +func (a *app) teamsHostRail() int { + if !a.teamsHosting() { + return 0 + } + return a.tp.railW +} + +// teamsSync settles the page after every message: the selection, the manager +// the pane hosts, and the rail's width. It reads memory only, and costs one +// comparison on every other place. When the selected team's manager is not in +// front and nothing has tried to bring it, it starts that attempt and hands +// back its command (teamsopen.go), so no road to this state leaves the pane +// saying `opening` with nothing behind the word. +func (a *app) teamsSync() tea.Cmd { + if !a.at(pageTeams) { + a.tp.host = "" + return nil + } + a.teamsSettle() + host := "" + var bring tea.Cmd + if t, ok := a.teamsSelected(); ok && !t.Closed() && t.Manager != "" && !a.teamsOff() { + if t.Manager == a.frontTabKey() { + host = t.Manager + if a.tp.open.key != t.Manager || !a.tp.open.done { + a.tp.open = teamsOpen{key: t.Manager, gen: a.tp.open.gen, done: true} + } + } else if !a.tp.forwarding { + bring = a.teamsKeepManager(t) + } + } + if host != a.tp.host { + a.tp.host = host + a.tp.top = teamsTopCache{} + a.touch() + } + if host == "" { + a.tp.focus = true + } + a.tp.railW = teamsRailCols(a.width) + return bring +} + +// ── THE FRAME ─────────────────────────────────────────────────────────────── + +// teamsHostTopHeight is the page's pinned rows over the hosted transcript, +// charged in [app.topHeight]. Zero when the pane hosts nothing. +func (a *app) teamsHostTopHeight() int { + if !a.teamsHosting() { + return 0 + } + width, _ := a.size() + return len(a.teamsHostTop(width)) +} + +// teamsHostTop is the page's header, members and inbox as rows over the hosted +// transcript, kept between frames while nothing they are drawn from moved. +// Their targets are recorded in frame cells. +func (a *app) teamsHostTop(width int) []string { + t, _ := a.teamsSelected() + key := teamsTopKey{ + width: width, height: a.height, edits: a.traffic.edits, stamp: a.traffic.stamp, sel: a.tp.sel, + cur: a.tp.cur, hot: a.tp.hot, focus: a.tp.focus, sig: a.teamsTopSig(t), + minute: a.now().Unix() / 60, answering: a.tp.answering, answer: string(a.tp.answer.value), + expand: a.tp.expand, ascii: a.pal.ascii, linear: a.linear, undoing: a.teamsUndoing(), + moving: a.teamMoveSig(), dragging: a.tdrag.on, + } + if c := &a.tp.top; c.ok && c.key == key { + return c.rows + } + d := &teamsDraw{a: a} + rows := a.teamsTop(d, width) + rows = append(rows, a.pal.dim(rule(width))) + for i := range rows { + rows[i] = teamsPad(rows[i], width) + } + a.tp.top = teamsTopCache{key: key, rows: rows, targets: d.targets, ok: true} + return rows +} + +// teamsNoticeRows is the pane's first rows: a move waiting on `Move` or +// `Cancel`, else the newest of a move and a close with its Undo, else nothing. +// One Undo at a time, so `u` and the button always mean the same thing. +func (a *app) teamsNoticeRows(d *teamsDraw, width, y int) []string { + if p := a.tmove.pend; len(p.ids) > 0 && p.from == teamMoveFromPage { + return a.teamsMoveRows(d, width, y) + } + if a.teamsUndoMoveNewer() { + return a.teamsMoveRows(d, width, y) + } + return a.teamsUndoRow(d, width, y) +} + +// teamsUndoMoveNewer reports whether the Undo on offer is a move's rather than a +// close's. +func (a *app) teamsUndoMoveNewer() bool { + if !a.teamMoveUndoing() || a.tmove.undo.from != teamMoveFromPage { + return false + } + return !a.teamsUndoing() || a.tmove.undo.at.After(a.tp.undo.at) +} + +// teamsUndoAny is `u` and the Undo button: the move or the close on offer. +func (a *app) teamsUndoAny() tea.Cmd { + if a.teamMoveUndoing() && (a.teamsUndoMoveNewer() || !a.teamsUndoing()) { + return a.teamMoveUndo() + } + return a.teamsUndoClose() +} + +// teamsUndoRow is the one row that offers Undo for a close, while it is offered. +func (a *app) teamsUndoRow(d *teamsDraw, width, y int) []string { + if !a.teamsUndoing() { + return nil + } + pal := a.pal + word := " " + pal.dim(a.tp.undo.name+" is closed") + " " + s, _ := d.button("Undo", teamsTarget{act: teamsActUndo, x0: ansi.StringWidth(word), y: y, + hint: "Reopen " + a.tp.undo.name + " and its tabs" + hintSegment + "u"}, pal.ink) + return []string{word + s} +} + +// teamsHostFrame is the hosted page's whole frame, and false when the pane +// hosts nothing (the shared place frame draws the page then). +func (a *app) teamsHostFrame() ([]string, []placeHit, int, int, bool) { + if !a.teamsHosting() { + return nil, nil, 0, 0, false + } + width, height := max(a.width, 8), max(a.height, 1) + railW := a.tp.railW + paneW, _ := a.size() + // THE CONVERSATION'S OWN FRAME, laid out in its own cells: the page is set + // aside for the draw so every surface inside it answers as it does in the + // conversation. + a.tp.forwarding, a.page = true, pageNone + chat, caretX, caretY := a.chatFrameLines(paneW, height) + headN := a.tabsHeight(paneW) + a.headSealHeight(paneW) + topAt := a.headHeight() + a.stripHeight() + a.tp.forwarding, a.page = false, pageTeams + // THE HEAD IS THE PLACES' HEAD, AT THE FULL WIDTH, drawn exactly as every + // place draws it, so the nav says where the person is standing. + was := a.pal + a.pal = was.onPlaces() + a.pal.placeRows = true + a.tabRow = -1 + head := []string(nil) + if headN > 0 { + // THE PLACE'S HEAD HAS NO STRIP. The pane under it is the manager's + // conversation; the strip is that conversation's row when it is in + // front on its own, not while the teams place is the page. + head = a.headRows(width, "", a.pal) + for len(head) < headN { + head = append(head, "") + } + head = head[:headN] + } + a.pal = was + d := &teamsDraw{a: a} + var rail []string + if railW > 0 { + rail = a.teamsRail(d, railW-1, height-headN) + d.shift(0, 0, headN) + } + // The pane's own rows were recorded as they were drawn; they are moved into + // frame cells here. + for _, t := range a.tp.top.targets { + t.x0 += railW + t.x1 += railW + t.y += topAt + t.pane = railW > 0 + d.targets = append(d.targets, t) + } + for i := range d.targets { + d.targets[i].line = d.targets[i].y + } + a.tp.targets = d.targets + sep := a.pal.dim(a.linearMark("│", "|")) + lines := make([]string, 0, height) + lines = append(lines, head...) + for i := headN; i < height; i++ { + row := "" + if i < len(chat) { + row = chat[i] + } + left := "" + if railW > 0 { + left = strings.Repeat(" ", railW-1) + if r := i - headN; r < len(rail) { + left = rail[r] + } + left += sep + } + lines = append(lines, left+row) + } + // A reply is read once its transcript is on screen, as in the conversation. + delete(a.unreadChats, a.frontTabKey()) + return lines, nil, caretX + railW, caretY, true +} + +// ── THE KEYS AND THE POINTER ──────────────────────────────────────────────── + +// teamsRoute takes what the page keeps of a message and hands the rest to the +// conversation it hosts. It is read at the top of [app.route], and answers +// false at once on every other place and with a card or a menu up. +func (a *app) teamsRoute(msg tea.Msg) (tea.Cmd, bool) { + if !a.at(pageTeams) || a.tp.forwarding || a.tsheet.on || a.teamMenu.on || a.wall.on || a.tmove.on { + return nil, false + } + switch m := msg.(type) { + case tea.KeyPressMsg: + return a.teamsRouteKey(m) + case tea.MouseClickMsg: + return a.teamsRouteMouse(m, m.Mouse()) + case tea.MouseReleaseMsg: + return a.teamsRouteMouse(m, m.Mouse()) + case tea.MouseMotionMsg: + return a.teamsRouteMouse(m, m.Mouse()) + case tea.MouseWheelMsg: + return a.teamsRouteMouse(m, m.Mouse()) + } + return nil, false +} + +// teamsRouteKey is a key on the page. The page's own keys are read when it has +// the keyboard; a hosted page hands everything else to the composer. +func (a *app) teamsRouteKey(msg tea.KeyPressMsg) (tea.Cmd, bool) { + key := msg.String() + if key == "ctrl+c" { + return nil, false + } + if key == "u" && (a.teamsUndoing() || a.teamMoveUndoing()) && a.teamsHasKeys() { + return a.teamsUndoAny(), true + } + // A DRAG IS DROPPED BY esc, and nothing happens (teamdrag.go). + if key == "esc" && a.tdrag.press { + a.teamDragCancel() + return nil, true + } + // THE MEMBERS CARD has the keyboard while it is up (teamcrew.go). + if a.tcrew.on { + return a.teamCrewKey(msg), true + } + // A MOVE WAITING ON THE PERSON is answered by esc too. + if key == "esc" && len(a.tmove.pend.ids) > 0 && a.tmove.pend.from == teamMoveFromPage { + a.teamMoveCancel() + return nil, true + } + if !a.teamsHosting() { + // The shared place grammar and the page's own keys ([placeTeams.key]). + return nil, false + } + switch key { + case "alt+up", "alt+down": + a.tp.focus = true + if a.teamsCursorIndex() < 0 { + a.teamsCursorHome() + } else if key == "alt+up" { + a.teamsWalk(0, -1) + } else { + a.teamsWalk(0, 1) + } + a.tp.top = teamsTopCache{} + a.touch() + return nil, true + case "tab", "shift+tab": + if a.menu.open || a.comp.open { + return a.teamsForward(msg), true + } + return a.walkPage(key == "shift+tab"), true + case placeMapKey: + a.mapShowing = !a.mapShowing + a.touch() + return nil, true + } + if cmd, took := a.placeJumpKey(msg); took { + return cmd, true + } + if a.tp.answering != "" { + return a.teamsAnswerKey(msg), true + } + if a.tp.focus { + if cmd, took := a.teamsKey(msg); took { + a.tp.top = teamsTopCache{} + return cmd, true + } + // ANY OTHER KEY GOES BACK TO THE COMPOSER, and types there: a person + // who starts a sentence has stopped choosing a button. + a.tp.focus = false + a.tp.top = teamsTopCache{} + } + return a.teamsForward(msg), true +} + +// teamsRouteMouse is a pointer event on the page: the rail and the page's own +// rows answer, the head is the router's, and everything over the hosted +// conversation is handed to it with its column moved into its own cells. +func (a *app) teamsRouteMouse(msg tea.Msg, m tea.Mouse) (tea.Cmd, bool) { + hosted := a.teamsHosting() + // THE MEMBERS CARD, AND A DRAG, TAKE THE POINTER FIRST (teamcrew.go, + // teamdrag.go): a drag that started on the card goes on over the rail. + if a.tdrag.press { + switch msg.(type) { + case tea.MouseMotionMsg: + a.teamDragMotion(m.X, m.Y, m.Button == tea.MouseLeft) + return nil, true + case tea.MouseReleaseMsg: + cmd, _ := a.teamDragRelease() + return cmd, true + case tea.MouseClickMsg: + // A second press with the first never let go: the first is over. + a.teamDragCancel() + } + } + if a.tcrew.on { + if cmd, took := a.teamCrewMouse(msg, m); took { + return cmd, true + } + if _, click := msg.(tea.MouseClickMsg); click { + return nil, true + } + } + if m.Y < placeHeadRows && a.tabRow >= 0 { + if !hosted { + return nil, false + } + // The bar and the rest of the head are the router's, as on every place. + return nil, false + } + if t, ok := a.teamsTargetAt(m.X, m.Y); ok { + switch msg.(type) { + case tea.MouseClickMsg: + if m.Button == tea.MouseLeft { + a.tp.hot = t.ref() + // A TEAM ROW OR A MEMBER CHIP MAY BE DRAGGED (teamdrag.go). A team + // row selects on the press, as it always has; a member's door + // waits for the release, so a drag from it never opens it. + if a.teamDraggable(t) { + member := t.act == teamsActMember + id := t.id + a.teamDragPress(m.X, m.Y, member, id, t.arg, t, member) + if member { + return nil, true + } + } + return a.teamsDo(t), true + } + case tea.MouseMotionMsg: + a.teamsHover(m.X, m.Y) + return nil, true + } + } + if _, isMotion := msg.(tea.MouseMotionMsg); isMotion && a.tp.hot != (teamsRef{}) { + a.tp.hot = teamsRef{} + a.tp.top = teamsTopCache{} + a.touch() + } + if !hosted { + if _, click := msg.(tea.MouseClickMsg); click { + return nil, true + } + return nil, false + } + railW := a.tp.railW + if m.X < railW { + return nil, true + } + topAt := a.headHeight() + a.stripHeight() + if m.Y >= topAt && m.Y < topAt+a.teamsHostTopHeight() { + return nil, true + } + // THE CONVERSATION'S OWN CELLS: the column moved by the rail, and the + // conversation answers as it does on its own screen. + m.X -= railW + switch msg.(type) { + case tea.MouseClickMsg: + return a.teamsForward(tea.MouseClickMsg(m)), true + case tea.MouseReleaseMsg: + return a.teamsForward(tea.MouseReleaseMsg(m)), true + case tea.MouseMotionMsg: + return a.teamsForward(tea.MouseMotionMsg(m)), true + case tea.MouseWheelMsg: + return a.teamsForward(tea.MouseWheelMsg(m)), true + } + return nil, false +} + +// teamsForward hands one message to the hosted conversation as if no place were +// standing, and puts the page back after it unless the message itself went +// somewhere else (a place, a page, another conversation's own screen). +// +// A MESSAGE THAT PUT ANOTHER CONVERSATION IN FRONT TAKES THE PERSON TO IT. A +// press on a Traffic row goes to that member through the chat surface's own +// door ([app.trafficPress], [app.trafficGo]), and the member is what the person +// asked to see: the page steps down for it exactly as a press on a member row +// does ([app.teamsMemberGo]), rather than standing over a conversation it does +// not host with the manager's pane saying `opening`. +func (a *app) teamsForward(msg tea.Msg) tea.Cmd { + front := a.frontTabKey() + a.tp.forwarding, a.page = true, pageNone + _, cmd := a.route(msg) + a.tp.forwarding = false + if !a.pageShowing() { + a.page = pageTeams + if a.frontTabKey() != front { + a.leavePlace() + } + } else if !a.at(pageTeams) { + // The message walked to another place; this one closes as it would + // have under the router. + placeTeams{}.close(a) + } + return cmd +} + +// teamsPageHint is what the hint line says over the page's own rows while the +// pane hosts the conversation, and the page's two keys otherwise. +func (a *app) teamsPageHint() string { + if !a.teamsHosting() { + return "" + } + words := a.teamsTargetHint() + if words != "" && a.tp.focus { + words += hintSegment + "esc back to the box" + } + return words +} + +// teamsComposerWord is the composer's `to` while the pane hosts the manager: +// `to ◆ harbor manager`, which says which team the words go to as well as who. +func (a *app) teamsComposerWord() string { + if !a.teamsHosting() { + return "" + } + t, ok := a.teamsSelected() + if !ok { + return "" + } + name := t.Name + if t.Root { + name = "all teams" + } + return "to " + a.teamManagerMark() + " " + name + " manager" +} diff --git a/internal/tui3/teamsread_test.go b/internal/tui3/teamsread_test.go new file mode 100644 index 0000000000..29fe7fc80f --- /dev/null +++ b/internal/tui3/teamsread_test.go @@ -0,0 +1,147 @@ +package tui3 + +import ( + "path/filepath" + "strings" + "testing" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── HOW THE TEAMS PAGE READS (teamspage.go's [app.teamsRead]) ─────────────── + +// A TEAM CHOSEN WHILE A READ IS OUT IS READ, NOT DROPPED. The beat's read left +// with harbor selected; orbit is chosen before it answers, and orbit's spend is +// on the page when everything has landed, with no second beat. The choice's +// read used to be dropped because one was out, and a team chosen in that window +// showed no spend until the next beat, or ever on a page whose clock was still. +func TestTeamsAChoiceWhileAReadIsOutIsReadNotDropped(t *testing.T) { + a, harbor, orbit := teamsPlaceLabIDs(t) + if a.tp.sel != harbor { + t.Fatalf("the lab opened on %q, want harbor", a.tp.sel) + } + if _, read := a.tp.spend[orbit]; read { + t.Fatal("the lab already read orbit's spend") + } + beat := a.teamsRead(true) + if beat == nil { + t.Fatal("the beat's read was not made") + } + choice := a.teamsSelect(orbit) + drive(t, a, runCmd(beat)...) + drive(t, a, runCmd(choice)...) + if _, read := a.tp.spend[orbit]; !read { + t.Fatalf("orbit was chosen while a read was out and its spend was never read: %+v", a.tp.spend) + } + if a.tp.reading || a.tp.again { + t.Fatalf("a read is still out or owed after everything landed (reading %v, again %v)", a.tp.reading, a.tp.again) + } +} + +// A READ ASKS ABOUT THE OPEN TEAMS' MEMBERS AND NO OTHER CONVERSATION. On this +// machine's disk the rows are read by name through the page's door, never by a +// walk of every session under the root; over a connection they are the +// members' rows out of the world the window holds, and the page keeps nothing +// else. +func TestTeamsReadAsksAboutTheMembersAlone(t *testing.T) { + a, _, _ := teamsPlaceLabIDs(t) + members := map[string]bool{} + for _, tm := range a.wall.teams { + if tm.Closed() { + continue + } + for _, m := range tm.Members { + members[filepath.Clean(m.File)] = true + } + } + if len(members) == 0 { + t.Fatal("the lab has no members") + } + stranger := filepath.Join(t.TempDir(), "-work-else", "aaaa000000000009", "transcript.jsonl") + + // This machine's disk. + a.world = nil + var calls int + var asked []string + a.teamsDisk.rows = func(files []string) map[string]session.SessionRow { + calls++ + asked = append(asked, files...) + out := map[string]session.SessionRow{} + for _, f := range files { + out[f] = session.SessionRow{Transcript: f} + } + return out + } + drive(t, a, runCmd(a.teamsRead(true))...) + if calls != 1 { + t.Fatalf("one read asked the rows door %d times", calls) + } + if len(asked) != len(members) { + t.Fatalf("the read asked about %d conversations, want the %d members: %q", len(asked), len(members), asked) + } + for _, f := range asked { + if !members[f] { + t.Fatalf("the read asked about %q, which is no open team's member", f) + } + } + if len(a.tp.world) != len(members) { + t.Fatalf("the page holds %d rows, want the %d members'", len(a.tp.world), len(members)) + } + + // Over a connection: the world the window holds, cut to the members. + var rows []session.SessionRow + for f := range members { + rows = append(rows, session.SessionRow{Transcript: f, Title: "member"}) + } + rows = append(rows, session.SessionRow{Transcript: stranger, Title: "stranger"}) + a.world = func() (session.World, bool) { + return session.World{Projects: []session.Project{{Sessions: rows}}}, true + } + calls = 0 + a.tp.world = nil + drive(t, a, runCmd(a.teamsRead(true))...) + if calls != 0 { + t.Fatal("a window with a world door read this machine's disk") + } + if _, kept := a.tp.world[stranger]; kept || len(a.tp.world) != len(members) { + t.Fatalf("the page kept %d rows over a connection, want the %d members' alone", len(a.tp.world), len(members)) + } +} + +// THE FIRST FRAME IS DRAWN FROM MEMORY AND THE READ FILLS IT IN PLACE. The +// page's rail and the selected team's header are on the frame the opening +// draws, before any read has answered, with no word or mark saying it is +// loading; and the read landing moves none of those rows. +func TestTeamsFirstFrameIsDrawnBeforeAnyReadAndTheReadMovesNothing(t *testing.T) { + a, harbor, orbit := menuApp(t) + a.profileDir = t.TempDir() + if err := a.teamEdit(func(f *teamstore.File) error { return f.SetParent(orbit, harbor) }); err != nil { + t.Fatal(err) + } + flushTeams(t, a) + a.width, a.height = 120, 24 + cmd := a.showPage(pageTeams) + before := strings.Split(teamsFrameText(a), "\n") + text := strings.Join(before, "\n") + for _, want := range []string{"All teams", "harbor", "orbit", "Settings", "Close"} { + if !strings.Contains(text, want) { + t.Fatalf("the first frame, drawn before any read, lacks %q:\n%s", want, text) + } + } + for _, loading := range []string{"loading", "reading", "⠋", "⠙", "⠹"} { + if strings.Contains(text, loading) { + t.Fatalf("the first frame says %q while the read is out:\n%s", loading, text) + } + } + drive(t, a, runCmd(cmd)...) + after := strings.Split(teamsFrameText(a), "\n") + if len(after) != len(before) { + t.Fatalf("the read changed the frame's height from %d to %d", len(before), len(after)) + } + for y := range before { + if before[y] != after[y] { + t.Fatalf("the read moved row %d:\nbefore %q\nafter %q", y, before[y], after[y]) + } + } +} diff --git a/internal/tui3/teamthread.go b/internal/tui3/teamthread.go new file mode 100644 index 0000000000..3a0466af08 --- /dev/null +++ b/internal/tui3/teamthread.go @@ -0,0 +1,133 @@ +package tui3 + +import ( + "strings" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE TRAFFIC'S THREADS (teamrail.go says what the Traffic is) ────────── +// +// The Traffic is threads (internal/teams' thread.go): a message and what +// answered it, the thread that moved last first, and inside each one in the +// order it happened. The side column draws each as one row of work +// (sidetraffic.go) and the thread cards in the manager's conversation draw +// each answer under its question (teamthreadcard.go); both read the answers +// through [replyLines]. +// +// ONE QUESTION IS ONE THREAD, NOT TWELVE ROWS. The wake that started a member +// is not a line: it is why the member reads `working…` until it answers. A +// member's finishing is not a line: it is the `✓` on its reply, or its own line +// when it said nothing. A failure is `✗`, and a member asking the person is +// the state `asking`. + +// trafficOpenKey is an entry's key in the thread cards' record of what is laid +// out in full. +func trafficOpenKey(teamID, id string) string { return teamID + "/" + id } + +// trafficReply is one member's line under a thread: its words, or the state +// its turn is in. +type trafficReply struct { + who string + entry teamstore.Entry // the reply whose words the line carries, if any + said bool + state string // finished, failed, asking, working, or "" for none + note string // what the state says, when it says anything + last teamstore.Entry +} + +// replyLines folds a thread's answers into one line per reply, with the +// events folded into them (see the file's comment). +func replyLines(th teamstore.Thread) []trafficReply { + var lines []trafficReply + latest := map[string]int{} + lineOf := func(who string) (*trafficReply, bool) { + if i, ok := latest[who]; ok { + return &lines[i], true + } + return nil, false + } + push := func(r trafficReply) { + latest[r.who] = len(lines) + lines = append(lines, r) + } + for _, e := range th.Replies { + switch { + case e.Kind == teamstore.KindYou || e.From == teamstore.FromYou: + continue + case e.Wake(): + who := strings.TrimPrefix(strings.TrimPrefix(strings.TrimSpace(e.Text), "woke "), "@") + if e.From != teamstore.FromManager { + continue // a member waking the manager is the manager's business + } + if l, ok := lineOf(who); ok && l.state == "working" { + l.last = e + continue + } + push(trafficReply{who: who, state: "working", last: e}) + case e.Kind == teamstore.KindEvent: + who := e.From + if who == teamstore.FromSystem || who == teamstore.FromManager { + who = e.To + } + state := e.State + note := strings.Join(strings.Fields(e.Text), " ") + switch state { + case teamstore.StateFinished, teamstore.StateFailed, teamstore.StateAsking: + default: + state = "note" + } + if l, ok := lineOf(who); ok && (l.state == "working" || (l.said && l.state == "")) { + l.state, l.note, l.last = state, note, e + continue + } + push(trafficReply{who: who, state: state, note: note, last: e}) + case e.Kind == teamstore.KindNote || e.Kind == teamstore.KindDirective || e.Kind == teamstore.KindAnswer || e.Kind == teamstore.KindQuestion: + if l, ok := lineOf(e.From); ok && l.state == "working" && !l.said { + l.entry, l.said, l.state, l.last = e, true, "", e + continue + } + push(trafficReply{who: e.From, entry: e, said: true, last: e}) + } + } + return lines +} + +// trafficThreads is team t's cached entries that the rail draws, as threads, +// newest activity first. +func (a *app) trafficThreads(t team) []teamstore.Thread { + rows := a.traffic.rows[t.ID] + shown := make([]teamstore.Entry, 0, len(rows)) + for _, e := range rows { + if !trafficShown(e) { + continue + } + // A MANAGER'S ANSWER NAMES THE QUESTION IT ANSWERS in Reply, the + // field it was written with before threads; it threads under it. + if e.Kind == teamstore.KindAnswer && e.Answers == "" { + e.Answers = e.Reply + } + shown = append(shown, e) + } + return teamstore.Threads(shown) +} + +// teamMemberHint is what the hint line says with the pointer on a member's +// handle: `Open @web · web frontend · click`, or Resume when this window does +// not hold it. +func (a *app) teamMemberHint(m teamMember) string { + verb := "Resume" + if tabsHold(a.tabList(), m.Key) || a.teamHeldOpen(m.Key) { + verb = "Open" + } + words := verb + " @" + m.Handle + if title := strings.TrimSpace(m.Word); title != "" { + if ansi.StringWidth(title) > teamLinkHintTitle { + title = strings.TrimRight(ansi.Truncate(title, teamLinkHintTitle-1, ""), " ") + a.linearMark("…", "...") + } + words += hintSegment + title + } + return words + hintSegment + "click" +} diff --git a/internal/tui3/teamthread_test.go b/internal/tui3/teamthread_test.go new file mode 100644 index 0000000000..e2c66bbe5a --- /dev/null +++ b/internal/tui3/teamthread_test.go @@ -0,0 +1,335 @@ +package tui3 + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// railLines is the side column on the next frame, plain, one string a frame +// row, so an index into it is a screen row. +func railLines(t *testing.T, a *app) []string { + t.Helper() + frame, _, _ := a.frame() + cols := a.railWidth() + if cols <= railGripCols { + t.Fatalf("the side column is not a column: %d", cols) + } + // A ROW IS AS LONG AS WHAT IS ON IT, so a short row of the column is cut + // from where the column starts to wherever it ends. + var out []string + for _, r := range strings.Split(ansi.Strip(frame), "\n") { + cells := []rune(r) + cell := "" + if len(cells) > a.width-cols { + cell = string(cells[a.width-cols : min(len(cells), a.width)]) + } + out = append(out, strings.TrimRight(cell, " ")) + } + return out +} + +// railRowOf is the first frame row whose column cells hold want, -1 for none. +func railRowOf(rows []string, want string) int { + for y, r := range rows { + if strings.Contains(r, want) { + return y + } + } + return -1 +} + +// sidePainted is the side column's rows as the frame paints them, ANSI and +// all, so an assertion about ink reads the ink. +func sidePainted(a *app) string { + return strings.Join(a.railRows(a.viewHeight()), "\n") +} + +// sideClick presses and lets go at a screen cell, as a hand does. +func sideClick(t *testing.T, a *app, x, y int) { + t.Helper() + drive(t, a, tea.MouseClickMsg{X: x, Y: y, Button: tea.MouseLeft}) + drive(t, a, tea.MouseReleaseMsg{X: x, Y: y, Button: tea.MouseLeft}) +} + +// sideRowDoor is the screen cell of the door on row key that does act kind, +// failing the test when the row is not drawn or has no such door. +func sideRowDoor(t *testing.T, a *app, key string, kind int) (int, int) { + t.Helper() + view, _ := a.railDrawnView(a.viewHeight()) + for i, line := range view { + if line.side == nil || line.side.key != key { + continue + } + for _, d := range line.side.doors { + if d.act.kind == kind { + return a.railLeft() + ansi.StringWidth(railSeam) + d.span.from, a.topHeight() + i + } + } + t.Fatalf("row %q has no door that does act %d: %+v", key, kind, line.side.doors) + } + t.Fatalf("the column does not draw row %q", key) + return 0, 0 +} + +// threadScenario is the owner's measured afternoon: an older note, then one +// question to three members as ONE entry, each member woken on it, three +// replies, two finishings and the manager woken by them, all linked the way +// the session writes them. It hands back the question's id. +func threadScenario(t *testing.T, a *app, harbor, price, rail string) string { + t.Helper() + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: teamstore.FromManager, To: price, Text: "an older aside"}) + q, err := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, + To: teamstore.ToSeveral, Handles: []string{price, rail, "review"}, Text: "Please provide a brief status update on your part"}) + if err != nil { + t.Fatal(err) + } + for _, h := range []string{price, rail, "review"} { + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindEvent, From: teamstore.FromManager, To: h, State: teamstore.StateRunning, Text: "woke @" + h, Answers: q}) + } + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "Status update: prices are scraped and cached", Answers: q}, + teamstore.Entry{Kind: teamstore.KindEvent, From: price, To: teamstore.ToManager, State: teamstore.StateFinished, Text: "finished", Answers: q}, + teamstore.Entry{Kind: teamstore.KindEvent, From: price, To: teamstore.ToManager, State: teamstore.StateRunning, Text: "woke ◆ (with @review)"}, + teamstore.Entry{Kind: teamstore.KindNote, From: "review", To: teamstore.ToManager, Text: "Status update: two findings, both minor", Answers: q}, + teamstore.Entry{Kind: teamstore.KindEvent, From: "review", To: teamstore.ToManager, State: teamstore.StateFinished, Text: "finished", Answers: q}, + ) + trafficReadNow(t, a) + return q +} + +// ONE QUESTION TO THREE MEMBERS IS ONE ROW OF WORK, at the top. The row names +// whom it went to and what it asked, says the state its answers leave it in +// and how many messages it holds, and folds its replies behind ▸. Laid open, +// each member is one `↳` line with its finishing folded in as ✓, a member +// woken with nothing said yet reads working…, and no wake or finishing is a +// line of its own. The chatter older than it is the one General row under it. +func TestTrafficThreadOneQuestionIsOneWorkRow(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 180, 40 + price, _ := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q := threadScenario(t, a, harbor, price, rail) + rows := railLines(t, a) + joined := strings.Join(rows, "\n") + head := railRowOf(rows, sideTrafficWord) + top := railRowOf(rows, "@"+price+" +2 Pleas") + if head < 0 || top != head+1 { + t.Fatalf("the question's row is not straight under the header (%d, %d):\n%s", head, top, joined) + } + // AT THE COLUMN'S WIDEST THE COUNT GIVES WAY TO THE WORDS, and the hint + // line says it. + if !strings.Contains(rows[top], "running "+glyphShut) { + t.Fatalf("the row does not say its state and its fold:\n%s", joined) + } + if hint := a.sideRowOf("thread/" + q).hint; !strings.Contains(hint, "running · 3 msgs") { + t.Fatalf("the row's hint does not say its state and its messages: %q", hint) + } + general := railRowOf(rows, "General") + if general != top+1 || !strings.Contains(rows[general], "1 msg "+glyphShut) { + t.Fatalf("the older chatter is not one General row under the work:\n%s", joined) + } + for _, never := range []string{"woke", "finished", "Status update", "an older aside"} { + if strings.Contains(joined, never) { + t.Fatalf("%q is drawn on a folded column:\n%s", never, joined) + } + } + + x, y := sideRowDoor(t, a, "thread/"+q, sideActThread) + sideClick(t, a, x, y) + rows = railLines(t, a) + joined = strings.Join(rows, "\n") + want := []string{ + "↳ ", + "@" + price + " → " + teamManagerGlyph + " ✓ Status update", + "@" + rail + " → " + teamManagerGlyph + " working…", + "@review → " + teamManagerGlyph + " ✓ Status update", + } + for i, w := range want[1:] { + if r := rows[top+1+i]; !strings.Contains(r, want[0]) || !strings.Contains(r, w) { + t.Fatalf("reply %d reads %q, want %q:\n%s", i, r, w, joined) + } + } + for _, never := range []string{"woke", ": finished", ": ✓ finished"} { + if strings.Contains(joined, never) { + t.Fatalf("%q is drawn as a line of its own:\n%s", never, joined) + } + } + // EVERY KIND OF ROW KEEPS ITS AGE: the work, each reply, and General. + for _, at := range []int{top, top + 1, top + 2, top + 3, railRowOf(rows, "General")} { + if at < 0 || !rowEndsWithAge(rows[at]) { + t.Fatalf("row %d has no age:\n%s", at, joined) + } + } + if !strings.Contains(rows[top], glyphOpen) || railRowOf(rows, "General") != top+4 { + t.Fatalf("the open row does not say it is open, or General moved off its place:\n%s", joined) + } + // AND THE SAME DOOR FOLDS IT AGAIN. + x, y = sideRowDoor(t, a, "thread/"+q, sideActThread) + sideClick(t, a, x, y) + if joined := strings.Join(railLines(t, a), "\n"); strings.Contains(joined, "Status update") { + t.Fatalf("the second press did not fold the replies:\n%s", joined) + } +} + +// A MEMBER ASKING IS THE BAND'S ONE AMBER ROW, and its thread says asking; a +// failure after it is a ✗ in ordinary ink and nothing on the column is amber. +// An old finishing that answers nothing is chatter, under General. +func TestTrafficThreadAnAskIsTheBandAndAFailureIsInk(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 180, 40 + price, _ := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindEvent, From: rail, To: teamstore.ToManager, State: teamstore.StateFinished, Text: "finished"}) + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "run the migration"}) + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindEvent, From: price, To: teamstore.ToManager, State: teamstore.StateAsking, Text: "asks: may I run it on prod?", Answers: q}) + trafficReadNow(t, a) + rows := railLines(t, a) + joined := strings.Join(rows, "\n") + head := railRowOf(rows, sideTrafficWord) + ask := railRowOf(rows, "@"+price+" → "+teamManagerGlyph+" may I run") + if head < 0 || ask != head+1 { + t.Fatalf("the ask is not the band's row under the header (%d, %d):\n%s", head, ask, joined) + } + if !strings.HasSuffix(strings.TrimRight(rows[ask], " "), "now") || strings.Contains(rows[ask], "asks:") { + t.Fatalf("the band row lost its age or kept the old asks lead: %q", rows[ask]) + } + for _, r := range a.side.last { + if strings.HasPrefix(r.key, "ask/") && (!strings.Contains(r.hint, "Open ") || !strings.Contains(r.hint, "now")) { + t.Fatalf("the band's hint does not open the message at its age: %q", r.hint) + } + } + work := railRowOf(rows, teamManagerGlyph+" → @"+price) + if work <= ask || !strings.Contains(rows[work], "asking") || !strings.Contains(rows[work], "run the") { + t.Fatalf("the thread does not say it is asking, under the band:\n%s", joined) + } + if general := railRowOf(rows, "General"); general <= work { + t.Fatalf("the old finishing is not chatter under the work:\n%s", joined) + } + probe := a.pal.ask("x") + warm := probe[:strings.Index(probe, "x")] + amber := func() int { + n := 0 + for _, r := range strings.Split(sidePainted(a), "\n") { + if warm != "" && strings.Contains(r, warm) { + n++ + } + } + return n + } + if warm != "" && amber() != 1 { + t.Fatalf("%d rows carry the needs-you amber, want the band's one", amber()) + } + + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindEvent, From: price, To: teamstore.ToManager, State: teamstore.StateFailed, Text: "the migration failed: lock timeout", Answers: q}) + trafficReadNow(t, a) + rows = railLines(t, a) + joined = strings.Join(rows, "\n") + if strings.Contains(joined, "asks: may I run") { + t.Fatalf("an answered ask is still in the band:\n%s", joined) + } + work = railRowOf(rows, teamManagerGlyph+" → @"+price) + if work < 0 || !strings.Contains(rows[work], "failed") || !strings.Contains(rows[work], "run the") { + t.Fatalf("the thread does not say it failed:\n%s", joined) + } + if warm != "" && amber() != 0 { + t.Fatalf("a failure is painted amber on %d rows", amber()) + } + x, y := sideRowDoor(t, a, "thread/"+q, sideActThread) + sideClick(t, a, x, y) + if rows := railLines(t, a); railRowOf(rows, "@"+price+" → "+teamManagerGlyph+" "+tokens.GlyphFailed+" the migration") < 0 { + t.Fatalf("the failure did not fold into the member's line:\n%s", strings.Join(rows, "\n")) + } +} + +// EVERY ROW IS ONE LINE AND THE HINT SAYS IT WHOLE. A long reply is cut with +// an ellipsis in the column and said in full on the hint line; enter on a +// thread with the column holding the keyboard lays it open and folds it, and +// neither moves the conversation in front. +func TestTrafficThreadRowsAreOneLineAndEnterFoldsThem(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 180, 40 + price, _ := trafficHandle(t, a, harbor, "openrouter") + long := "Status update: " + strings.Repeat("the scrape is cached and every price is checked twice ", 3) + "END" + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "status?"}) + reply, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: long, Answers: q}) + trafficReadNow(t, a) + front := a.frontTabKey() + + drive(t, a, altT()) + if !a.railHold { + t.Fatal("alt+t did not give the column the keyboard") + } + _ = railLines(t, a) // the loop draws a frame before any key reaches it + a.railWhere = railSpot{key: "thread/" + q} + drive(t, a, key("enter")) + rows := railLines(t, a) + y := railRowOf(rows, "@"+price+" → "+teamManagerGlyph+" Status update") + if y < 0 || strings.Contains(strings.Join(rows, "\n"), "END") || !strings.Contains(rows[y], "…") { + t.Fatalf("enter did not lay the reply open as one cut line:\n%s", strings.Join(rows, "\n")) + } + if a.frontTabKey() != front || !a.railHold { + t.Fatal("laying the thread open moved the focus or took the keyboard back") + } + x, ry := sideRowOn(t, a, "reply/"+reply) + a.setHover(x, ry) + if words := a.dockHoverWords(); !strings.Contains(words, "END") { + t.Fatalf("the hint line does not say the reply whole: %q", words) + } + a.dropHover() + a.railWhere = railSpot{key: "thread/" + q} + drive(t, a, key("enter")) + if joined := strings.Join(railLines(t, a), "\n"); strings.Contains(joined, "Status update") { + t.Fatalf("the second enter did not fold the thread:\n%s", joined) + } +} + +// A HANDLE ON THE COLUMN IS A LINK, inked as the chat inks one, and a press on +// it opens its member at the message; an address that is nobody's is plain +// words. +func TestTrafficThreadHandlesAreLinks(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 180, 40 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q := threadScenario(t, a, harbor, price, rail) + a.sideToggleThread(sideThreadKey(harbor, q)) + _ = railLines(t, a) + painted := sidePainted(a) + if !strings.Contains(painted, teamLinkInk(a.pal, "@"+price)) { + t.Fatal("a handle is not inked as a chat link is") + } + if strings.Contains(painted, teamLinkInk(a.pal, "@review")) { + t.Fatal("an address that is nobody's is inked as a link") + } + links := 0 + for _, row := range a.side.last { + for _, d := range row.doors { + if d.act.kind == sideActJump { + links++ + if d.act.key == "" || d.act.entry == "" { + t.Fatalf("a link opens nobody or nowhere: %+v", d) + } + } + } + } + if links < 3 { + t.Fatalf("%d handle links drawn", links) + } + x, y := sideRowDoor(t, a, "thread/"+q, sideActJump) + a.setHover(x, y) + if words := a.dockHoverWords(); !strings.Contains(words, "@"+price) || !strings.Contains(words, "click") { + t.Fatalf("the handle's hint says %q", words) + } + a.dropHover() + sideClick(t, a, x, y) + if a.frontTabKey() != priceKey { + t.Fatalf("the handle went to %q, want %q", a.frontTabKey(), priceKey) + } +} diff --git a/internal/tui3/teamthreadcard.go b/internal/tui3/teamthreadcard.go new file mode 100644 index 0000000000..ccb273df86 --- /dev/null +++ b/internal/tui3/teamthreadcard.go @@ -0,0 +1,419 @@ +package tui3 + +import ( + "encoding/json" + "strings" + + "github.com/charmbracelet/x/ansi" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── A THREAD IN THE CONVERSATION ──────────────────────────────────────────── +// +// The rail is where a person reads the team at a glance (teamthread.go). The +// manager's own conversation is where it asked, so that is where the question +// keeps its answers: a manager's `team_send` row is a thread card, +// +// ├─▶ team_send ◆ to @agent @checking @review · do ✓ +// │ │ Please provide a brief status update on your part +// │ ├ @checking ✓ Status update: the lexer is in +// │ └ @review working… +// +// the message quoted under the call and each member's answer attached under it +// in muted ink as it lands, one line each. A handle is a link, as everywhere in +// a chat (teamlink.go); a press on the words lays them out in full and a second +// folds them, and under the pointer the hint line says them whole. A press on +// the call's own line still opens the call, which is what every tool row does. +// +// THE MEMBER'S CHAT MIRRORS IT. A manager's line delivered to a member is +// already a quoted card (teamcard.go); under it the member's own answers to +// that line are attached the same way, so a person opening the member reads +// the question and what it said back in one place. +// +// AND THE MANAGER IS NOT TOLD IT TWICE. A member's reply reaches the manager's +// model as a delivery note, which replays as a team card of its own. A reply +// already under its question's card is left out of that card, and a card left +// with nothing is one dim line saying who answered and where to read it. The +// model's transcript is unchanged; only the drawing folds. +// +// THE CARDS DRAW MEMORY. Everything is read from the Traffic cache the rail's +// clock keeps (teamtraffic.go), keyed by that cache's version, so a frame reads +// no disk and a card grows the frame after a reply is read. + +// threadMemo is what one thread card last drew and every fact that decided it. +type threadMemo struct { + // args is the call's arguments the target and root were read from. + args string + target string + to []string + text string + kind string + // team and root name the thread's first message once it is found in the + // cache; found says it was. + team, root string + found bool + stamp threadStamp + rows []threadRow +} + +// threadStamp is everything a card's rows are drawn from beside the entry. +type threadStamp struct { + version, opened, room int + hot string + ascii bool + front string +} + +// threadRow is one row of a card and the message a press on it opens. +type threadRow struct { + text string + open string +} + +// threadCardLines is how many lines of a manager's message a folded card +// quotes. +const threadCardLines = 3 + +// teamSendArgs reads a team_send call's arguments once per change. +func (m *threadMemo) teamSendArgs(args string) { + if m.args == args && m.args != "" { + return + } + m.args = args + var parsed struct { + To string `json:"to"` + Text string `json:"text"` + Kind string `json:"kind"` + } + _ = json.Unmarshal([]byte(args), &parsed) + m.to = m.to[:0] + for _, w := range strings.FieldsFunc(strings.ToLower(parsed.To), func(r rune) bool { return r == ' ' || r == ',' || r == ';' }) { + if w = strings.TrimPrefix(w, "@"); w != "" { + m.to = append(m.to, w) + } + } + m.text, m.kind = strings.TrimSpace(parsed.Text), parsed.Kind + m.found, m.target = false, "" +} + +// teamSendTarget is a team_send row's sentence: `◆ to @a @b · do`, the handles +// the call named and whether it was a directive. "" when the arguments say +// nothing. +func (a *app) teamSendTarget(e *entry) string { + if e.detail.Args == "" { + return "" + } + if e.thread == nil { + e.thread = &threadMemo{} + } + m := e.thread + m.teamSendArgs(e.detail.Args) + if m.target != "" { + return m.target + } + if len(m.to) == 0 { + return "" + } + var b strings.Builder + b.WriteString(a.teamManagerMark() + " to") + for _, h := range m.to { + if h == teamstore.ToEveryone { + b.WriteString(" everyone") + continue + } + b.WriteString(" @" + h) + } + tag := "fyi" + if m.kind == teamstore.KindDirective { + tag = "do" + } + b.WriteString(" · " + tag) + m.target = b.String() + return m.target +} + +// teamSendFind looks for a team_send call's message in the Traffic cache: by +// the number its answer carries, or, for an answer from before numbers, by its +// words. It is asked again only when the cache moved. +func (a *app) teamSendFind(e *entry, m *threadMemo) { + if m.found { + return + } + id := "" + if at := strings.LastIndex(e.detail.Output, "(#"); at >= 0 { + end := strings.IndexByte(e.detail.Output[at:], ')') + if end > 0 { + id, _ = teamstore.ThreadID(e.detail.Output[at+1 : at+end]) + } + } + for teamID, rows := range a.traffic.rows { + for i := len(rows) - 1; i >= 0; i-- { + r := rows[i] + if r.From != teamstore.FromManager || (r.Kind != teamstore.KindNote && r.Kind != teamstore.KindDirective) { + continue + } + if (id != "" && r.ID == id && strings.TrimSpace(r.Text) == m.text) || (id == "" && strings.TrimSpace(r.Text) == m.text) { + m.team, m.root, m.found = teamID, r.ID, true + return + } + } + } +} + +// threadOf is the thread in rows that begins with root: root and everything +// that answers it, directly or through another answer. +func threadOf(rows []teamstore.Entry, root string) (teamstore.Thread, bool) { + var th teamstore.Thread + in := map[string]bool{} + for _, r := range rows { + switch { + case r.ID == root: + th.Root, th.Latest = r, r.ID + in[r.ID] = true + case r.Answers != "" && in[r.Answers] && trafficShown(r): + th.Replies = append(th.Replies, r) + th.Latest = r.ID + in[r.ID] = true + } + } + return th, th.Root.ID != "" +} + +// teamSendCard is the card a team_send row hangs, room wide, and false for a +// row that hangs none. i is the row's entry, for the pointer. +func (a *app) teamSendCard(e *entry, i, room int) ([]threadRow, bool) { + if e.tool != "team_send" || e.status == toolForming || e.detail.Args == "" { + return nil, false + } + if e.thread == nil { + e.thread = &threadMemo{} + } + m := e.thread + m.teamSendArgs(e.detail.Args) + if m.text == "" { + return nil, false + } + stamp := a.threadStampOf(i, room) + if m.rows != nil && m.stamp == stamp { + return m.rows, true + } + a.teamSendFind(e, m) + pal := a.pal + bar := a.linearMark("│", "|") + " " + key := "" + if m.found { + key = trafficOpenKey(m.team, m.root) + } + hot := func(open string) bool { + return open != "" && a.hot.kind == hoverThread && a.hot.entry == i && a.hot.key == open + } + var rows []threadRow + words := wrap(m.text, max(room-2, 8)) + if !a.traffic.open[key] && len(words) > threadCardLines { + words = append(words[:threadCardLines-1:threadCardLines-1], ansi.Truncate(words[threadCardLines-1], max(room-3, 4), "")+a.linearMark("…", "...")) + } + for _, w := range words { + text := pal.ink(w) + if hot(key) { + text = pal.cursor(pal.ink(w), 0) + } + rows = append(rows, threadRow{text: pal.dim(bar) + text, open: key}) + } + if m.found { + if th, ok := threadOf(a.traffic.rows[m.team], m.root); ok { + rows = append(rows, a.threadReplyRows(m.team, th, "", room, hot)...) + } + } + m.rows, m.stamp = rows, stamp + return rows, true +} + +// threadStampOf is the facts beside the entry a card at i, room wide, is drawn +// from. +func (a *app) threadStampOf(i, room int) threadStamp { + s := threadStamp{version: a.traffic.version, opened: a.traffic.opened, room: room, ascii: a.pal.ascii, front: a.frontTabKey()} + if a.hot.kind == hoverThread && a.hot.entry == i { + s.hot = a.hot.key + } + return s +} + +// threadReplyRows is a thread's answers as a card draws them, in muted ink, +// one line each: every member's, or only self's when self is a handle. +func (a *app) threadReplyRows(teamID string, th teamstore.Thread, self string, room int, hot func(string) bool) []threadRow { + pal := a.pal + lines := replyLines(th) + if self != "" { + kept := lines[:0:0] + for _, r := range lines { + if r.who == self { + kept = append(kept, r) + } + } + lines = kept + } + var rows []threadRow + for n, r := range lines { + glyph, under := a.linearMark("├ ", "|-"), a.linearMark("│ ", "| ") + if n == len(lines)-1 { + glyph, under = a.linearMark("└ ", "`-"), " " + } + who := "@" + r.who + if r.who == teamstore.FromManager { + who = a.teamManagerMark() + " manager" + } + lead := pal.dim(glyph) + pal.muted(who) + " " + leadW := ansi.StringWidth(glyph + who + " ") + mark := "" + switch r.state { + case teamstore.StateFinished: + mark = a.linearMark(a.icon(tokens.GSettled), "ok") + " " + case teamstore.StateFailed: + mark = a.linearMark(a.icon(tokens.GFailed), "x") + " " + } + var text, open string + paint := pal.muted + switch { + case r.state == teamstore.StateAsking: + text, paint = "asking: "+strings.TrimPrefix(r.note, "asks: "), pal.ask + open = trafficOpenKey(teamID, r.last.ID) + case r.said: + text = strings.TrimSpace(r.entry.Text) + open = trafficOpenKey(teamID, r.entry.ID) + case r.state == "working": + text, paint = "working"+a.linearMark("…", "..."), pal.dim + default: + text = r.state + if r.note != "" && r.note != r.state { + text += " · " + r.note + } + } + room := max(room-leadW-ansi.StringWidth(mark), 8) + paintHot := func(s string) string { + if hot(open) { + return pal.cursor(paint(s), 0) + } + return paint(s) + } + if open != "" && a.traffic.open[open] { + for k, w := range wrap(text, room) { + if k == 0 { + rows = append(rows, threadRow{text: lead + pal.muted(mark) + paintHot(w), open: open}) + continue + } + rows = append(rows, threadRow{text: pal.dim(under) + strings.Repeat(" ", max(leadW-ansi.StringWidth(under), 0)) + paintHot(w), open: open}) + } + continue + } + flat := strings.Join(strings.Fields(text), " ") + if ansi.StringWidth(flat) > room { + flat = ansi.Truncate(flat, room-1, "") + a.linearMark("…", "~") + } + rows = append(rows, threadRow{text: lead + pal.muted(mark) + paintHot(flat), open: open}) + } + return rows +} + +// threadHoverWords is what the hint line says with the pointer on a thread +// card's words: the message whole, and what a press does. "" anywhere else. +func (a *app) threadHoverWords() string { + if a.hot.kind != hoverThread || a.hot.key == "" { + return "" + } + teamID, id, _ := strings.Cut(a.hot.key, "/") + for _, r := range a.traffic.rows[teamID] { + if r.ID != id { + continue + } + text := strings.Join(strings.Fields(r.Text), " ") + if a.traffic.open[a.hot.key] { + return "click folds it" + } + return text + hintSegment + "click shows it all" + } + return "" +} + +// ── the team note's side ──────────────────────────────────────────────────── + +// teamNoteStamp reports whether a team note's cached rows are stale because +// the Traffic under it moved: its thread lines draw answers from the cache. +func (a *app) teamNoteStale(e *entry, width int) bool { + if e.kind != entryTeam || len(e.team) == 0 || !a.wall.loaded { + return false + } + stamp := threadStamp{version: a.traffic.version, opened: a.traffic.opened, room: width, ascii: a.pal.ascii, front: a.frontTabKey()} + if e.thread == nil { + e.thread = &threadMemo{} + } + if e.thread.stamp == stamp { + return false + } + e.thread.stamp = stamp + return true +} + +// teamNoteTeam is the managed team this conversation is in that a note's team +// name names, false for none. +func (a *app) teamNoteTeam(name string) (team, bool) { + front := a.frontTabKey() + for _, t := range a.wall.teams { + if t.Manager != "" && teamHolds(t, front) && (name == "" || t.Name == name) { + return t, true + } + } + return team{}, false +} + +// teamNoteReplyShown reports whether a member's line delivered to the manager +// is an answer already drawn under its question's card in the manager's own +// conversation: the manager's message it answers is in the cache. +func (a *app) teamNoteReplyShown(t team, from, text string) bool { + rows := a.traffic.rows[t.ID] + text = strings.TrimSpace(text) + for i := len(rows) - 1; i >= 0; i-- { + r := rows[i] + if r.From != from || r.Kind != teamstore.KindNote || r.Answers == "" { + continue + } + said := strings.TrimSpace(r.Text) + if said != text && !(strings.HasSuffix(text, "…") && strings.HasPrefix(said, strings.TrimSuffix(text, "…"))) { + continue + } + up := r.Answers + for hop := 0; hop < 16 && up != ""; hop++ { + found := false + for j := i - 1; j >= 0; j-- { + if rows[j].ID == up { + if rows[j].From == teamstore.FromManager { + return true + } + up, found = rows[j].Answers, true + break + } + } + if !found { + return false + } + } + return false + } + return false +} + +// teamNoteSelf is this conversation's handle in the team a note came from, "" +// when it has none there or is its manager. +func (a *app) teamNoteSelf(name string) (team, string) { + front := a.frontTabKey() + for _, t := range a.wall.teams { + if t.Manager == "" || t.Manager == front || (name != "" && t.Name != name) { + continue + } + if m, ok := t.Member(front); ok && m.Handle != "" { + return t, m.Handle + } + } + return team{}, "" +} diff --git a/internal/tui3/teamthreadcard_test.go b/internal/tui3/teamthreadcard_test.go new file mode 100644 index 0000000000..674c51b554 --- /dev/null +++ b/internal/tui3/teamthreadcard_test.go @@ -0,0 +1,206 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// bodyRows is the conversation's rows as the frame lays them out, with the +// screen row each lands on. +func bodyRows(a *app) ([]row, int) { + a.touch() + body, _ := a.window(a.bodyWidth(), a.viewHeight()) + return body, a.bodyTop() +} + +// bodyText is those rows, plain. +func bodyText(a *app) string { + body, _ := bodyRows(a) + var out []string + for _, r := range body { + out = append(out, ansi.Strip(r.text)) + } + return strings.Join(out, "\n") +} + +// sendRow puts a manager's finished team_send call on the conversation. +func sendRow(a *app, args, output string) { + a.entries = append(a.entries, entry{kind: entryTool, tool: "team_send", status: toolOK, settled: true, + text: "team_send", detail: toolDetail{Args: args, Output: output}}) + a.touch() +} + +// THE MANAGER'S QUESTION IS A THREAD CARD THAT GROWS. The team_send row says +// who it went to and that it was a directive, quotes the words under it, and +// each member's answer is attached under it, muted, as it is read; the +// finishing folds into the answer's line. +func TestThreadCardGrowsAsRepliesLand(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.railAway = true + price, _ := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, + To: teamstore.ToSeveral, Handles: []string{price, rail}, Text: "status please"}) + trafficReadNow(t, a) + sendRow(a, `{"to":"@`+price+` @`+rail+`","text":"status please","kind":"directive"}`, "Sent a directive to @"+price+", @"+rail+" ("+teamstore.ThreadNumber(q)+").") + text := bodyText(a) + if !strings.Contains(text, teamManagerGlyph+" to @"+price+" @"+rail+" · do") || !strings.Contains(text, "│ status please") { + t.Fatalf("the call is not a thread card:\n%s", text) + } + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "prices are cached", Answers: q}) + trafficReadNow(t, a) + if text := bodyText(a); !strings.Contains(text, "└ @"+price+" prices are cached") { + t.Fatalf("the first answer is not under the card:\n%s", text) + } + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindEvent, From: price, To: teamstore.ToManager, State: teamstore.StateFinished, Text: "finished", Answers: q}, + teamstore.Entry{Kind: teamstore.KindNote, From: rail, To: teamstore.ToManager, Text: "scope model is done", Answers: q}) + trafficReadNow(t, a) + text = bodyText(a) + if !strings.Contains(text, "├ @"+price+" ✓ prices are cached") || !strings.Contains(text, "└ @"+rail+" scope model is done") { + t.Fatalf("the card did not grow with the second answer and the finishing:\n%s", text) + } + // Muted: the answer's words are not in the ink the question is in. + body, _ := bodyRows(a) + for _, r := range body { + if strings.Contains(ansi.Strip(r.text), "scope model is done") && strings.Contains(r.text, a.pal.ink("scope model is done")) { + t.Fatalf("an answer is drawn in full ink: %q", r.text) + } + } +} + +// A PRESS ON AN ANSWER'S WORDS LAYS THEM OUT, AND A SECOND FOLDS THEM; the +// hint line says them whole; a handle on the card is a link. +func TestThreadCardAnswerExpandsOnPress(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.railAway = true + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "status?"}) + long := strings.Repeat("every price is checked twice and cached for an hour ", 6) + "END" + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: long, Answers: q}) + trafficReadNow(t, a) + sendRow(a, `{"to":"`+price+`","text":"status?","kind":"directive"}`, "Sent a directive to @"+price+" ("+teamstore.ThreadNumber(q)+").") + if strings.Contains(bodyText(a), "END") { + t.Fatal("the answer is drawn whole before a press") + } + body, top := bodyRows(a) + y, x := -1, 0 + for i, r := range body { + if r.hit == hitThread && strings.Contains(ansi.Strip(r.text), "every price") { + y = top + i + x = strings.Index(ansi.Strip(r.text), "every price") + 2 + for _, l := range r.links { + if l.member != priceKey { + t.Fatalf("the card's handle opens %q", l.member) + } + } + if len(r.links) != 1 { + t.Fatalf("the answer's handle is not a link: %+v", r.links) + } + } + } + if y < 0 { + t.Fatalf("no answer row answers a press:\n%s", bodyText(a)) + } + drive(t, a, motionTo(x, y)) + if words := a.dockHoverWords(); !strings.Contains(words, "END") { + t.Fatalf("the hint line over the answer says %q", words) + } + front := a.frontTabKey() + spend(t, a, a.press(x, y)) + if !strings.Contains(bodyText(a), "END") || a.frontTabKey() != front { + t.Fatalf("the press did not lay the answer out in place:\n%s", bodyText(a)) + } + spend(t, a, a.press(x, y)) + if strings.Contains(bodyText(a), "END") { + t.Fatalf("the second press did not fold it:\n%s", bodyText(a)) + } +} + +// THE MANAGER IS NOT SHOWN AN ANSWER TWICE. A delivery note whose every line +// is an answer already under its card is one dim line naming who answered; a +// line that answers nothing is still drawn. +func TestThreadCardFoldsTheDeliveredAnswers(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + a.railAway = true + price, _ := trafficHandle(t, a, harbor, "openrouter") + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "status?"}) + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "prices are cached", Answers: q}) + trafficReadNow(t, a) + sendRow(a, `{"to":"`+price+`","text":"status?","kind":"directive"}`, "Sent ("+teamstore.ThreadNumber(q)+").") + note := "Your team's replies started this turn; the person did not speak.\n\nTeam traffic in \"harbor\", which you manage. These are your members' messages, not the person's words:\nfrom @" + price + ": prices are cached\n(rule)" + a.entries = append(a.entries, entry{kind: entryTeam, text: note, settled: true, + team: []session.TeamLine{{Team: "harbor", From: price, Kind: teamstore.KindNote, Text: "prices are cached"}}}) + text := bodyText(a) + if strings.Count(text, "prices are cached") != 1 || !strings.Contains(text, "@"+price+" answered · in the thread above") { + t.Fatalf("the delivered answer is drawn twice, or its line is missing:\n%s", text) + } + a.entries = append(a.entries, entry{kind: entryTeam, text: note, settled: true, + team: []session.TeamLine{{Team: "harbor", From: price, Kind: teamstore.KindNote, Text: "an aside nobody asked for"}}}) + if text := bodyText(a); !strings.Contains(text, "an aside nobody asked for") { + t.Fatalf("a line that answers nothing was folded:\n%s", text) + } +} + +// THE MEMBER'S CHAT MIRRORS IT: the manager's line as the quoted card, and the +// member's own answer to it under it, muted. +func TestThreadCardMemberMirror(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, + To: teamstore.ToSeveral, Handles: []string{price, rail}, Text: "status please"}) + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindNote, From: rail, To: teamstore.ToManager, Text: "not price's answer", Answers: q}, + teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "prices are cached", Answers: q}) + trafficReadNow(t, a) + spend(t, a, a.trafficGo(priceKey)) + if a.frontTabKey() != priceKey { + t.Fatalf("the member is not in front") + } + trafficReadNow(t, a) + note := "Team traffic in \"harbor\" for you (@" + price + "). These are the team's messages, not the person's words:\n◆ directive from manager " + teamstore.ThreadNumber(q) + ": status please\n(rule)" + a.entries = append(a.entries, entry{kind: entryTeam, text: note, settled: true, + team: []session.TeamLine{{Team: "harbor", From: teamstore.FromManager, Kind: teamstore.KindDirective, Text: "status please", Thread: q}}}) + text := bodyText(a) + card := strings.Index(text, "│ status please") + mine := strings.Index(text, "└ @"+price+" prices are cached") + if card < 0 || mine < card || strings.Contains(text, "not price's answer") { + t.Fatalf("the member's chat does not mirror its answer under the manager's line:\n%s", text) + } +} + +// A MANAGER'S STEPS ARE SAID AS TEAM WORK. Its fold read `▾ team_send 1 call +// … 1 call`: the tool's own name where the work goes, and the count twice. +func TestTeamToolCaptionsSayTheWork(t *testing.T) { + send := func(to string) entry { + return entry{kind: entryTool, tool: "team_send", status: toolOK, detail: toolDetail{Args: `{"to":"` + to + `","text":"status?"}`}} + } + if got := composeCaption([]entry{send("@scrape model")}, 0, 1); got != "messaging @scrape @model" { + t.Fatalf("one team_send is captioned %q", got) + } + if got := captionPast(composeCaption([]entry{send("everyone")}, 0, 1)); got != "messaged everyone" { + t.Fatalf("a finished broadcast is captioned %q", got) + } + if got := composeCaption([]entry{send("scrape"), send("model")}, 0, 2); got != "sending 2 messages" { + t.Fatalf("two sends are captioned %q", got) + } + start := entry{kind: entryTool, tool: "team_start", status: toolOK, detail: toolDetail{Args: `{"handle":"lexer","brief":"x"}`}} + if got := composeCaption([]entry{start}, 0, 1); got != "starting @lexer" { + t.Fatalf("a start is captioned %q", got) + } + for _, e := range []entry{send("a"), start} { + if got := composeCaption([]entry{e}, 0, 1); strings.Contains(got, "team_") { + t.Fatalf("a caption names the tool: %q", got) + } + } +} diff --git a/internal/tui3/teamtraffic.go b/internal/tui3/teamtraffic.go new file mode 100644 index 0000000000..6054c49ef2 --- /dev/null +++ b/internal/tui3/teamtraffic.go @@ -0,0 +1,537 @@ +package tui3 + +import ( + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── TRAFFIC: WHAT PASSES BETWEEN A TEAM'S MANAGER AND ITS MEMBERS ─────────── +// +// The Traffic log (internal/teams' traffic.go) is the only channel between this +// interface and the team tools a model calls (internal/session): the manager's +// notes and directives, the members' posts, and the two acts the manager asks +// for, stop and start. This file is the interface's side of it, the clock, the +// read and the acts; teamrail.go draws it. +// +// THE READ IS OFF THE LOOP, AND A QUIET SECOND COSTS A STAT. A clock of its own +// ([trafficEvery]) runs while this window holds a conversation in a team that +// HAS A MANAGER, and at no other time: a team without one writes no Traffic +// worth reading here. Each turn of the clock asks, beside the door line +// ([app.besideLine]), for each held team's log after the cursor this window +// holds and for the teams file only if its stamp moved ([TeamsSeam]); the +// seam stats before it reads (internal/teams' [teamstore.Watch]), so a quiet +// log is answered with nothing from one stat, and over --host with a frame of +// a few bytes. What came back is folded into a cache on the loop, the clock is +// set for its next turn there, and when nothing was new the loop touches +// nothing and tells the frame it may draw what it drew before (view.go's still +// frame). After [trafficIdleTurns] quiet turns the clock slows to +// [trafficEveryIdle], and anything that moves brings it back. THE FRAME DRAWS +// THE CACHE AND NOTHING ELSE (framedisk_law_test.go). The same turn picks up +// the teams file when another process changed it, and gives a member its +// title when it joined before it had one ([teamstore.DeriveHandle] through the +// store's tidy, written as an ordinary edit, [app.teamEdit]). +// +// OVER --host THE CLOCK READS THE ENGINE'S LOG. The session writes its Traffic +// into the profile of the machine it runs on, and the --host door's seam asks +// that machine (internal/remote's Teams.Traffic), so the rail is the team's +// own. An engine without those doors hands no seam, and then there is no clock +// at all ([app.teamsOff]): a rail read from this window's profile would be an +// empty log drawn as if it were the team's. +// +// THE ACTS ARE DONE ONCE, AND ONLY NEW ONES. A stop addressed to a +// conversation this window holds ends that conversation's current turn, as the +// person's own stop does; a start is done by the window that holds the team's +// manager, which opens a conversation in the team's folder BEHIND the one in +// front and puts it in the team under the handle the manager chose. It never +// comes forward and it is never sent the brief as the person's words: the +// brief is the manager's, it reaches the member through the same Traffic +// delivery every other line of the manager's does, and the member's first turn +// is started by the session on seeing itself started (internal/session's +// team_wake.go). Each act is done once per entry id, remembered in memory, and +// a window opening reads the log from its TAIL, so what was asked before it +// opened is history on its rail and is never done again. + +const ( + // trafficEvery is how often the log is looked at while this window holds a + // conversation in a managed team, and trafficEveryIdle how often once + // trafficIdleTurns looks in a row found nothing. + trafficEvery = time.Second + trafficEveryIdle = 5 * time.Second + trafficIdleTurns = 10 + // trafficKeep is how many entries a team's cache holds, and how many a + // first look reads from the tail. + trafficKeep = 200 + // trafficPage is the most one read pages forward; a longer backlog is read + // on the turns after. + trafficPage = 200 + // trafficFromStart is the cursor for a log that was empty at the first + // look: every entry after it is new. + trafficFromStart = "000000000000" +) + +// trafficState is the cache, the clock and the rail's own state. +type trafficState struct { + // ticking says the clock is turning (a trafficTickMsg or the read it + // started is on its way), and reading that a read is out, so a turn of the + // clock never starts a second one beside it. idle counts the turns in a row + // that found nothing. + ticking bool + reading bool + idle int + // cursor is each team's last entry id read, by team id; a team with none + // has not been looked at yet, and its first read is the tail. + cursor map[string]string + // rows is each team's cached entries, oldest first, at most trafficKeep. + rows map[string][]teamstore.Entry + // done is every stop and start acted on, by team id and entry id. + done map[string]bool + // stamp is the teams file's stamp when it was last read or written here + // (internal/teams' stamp.go), which is what a turn asks the seam to answer + // "same" to. edits counts this window's own edits and wrote the edits the + // last write covered, so a read that crossed an edit, or came back while one + // was still unwritten, does not put the list from before it back. + stamp string + edits int + wrote int + // seen is, per team, the newest entry the person has had in front of them + // on the side column's Traffic, which is what its word and the closed edge + // count past (sidecol.go). + seen map[string]string + // jump is a jump to a message waiting for its conversation to open, and + // landing the message lifted after one (teamjump.go). + jump trafficJumpTo + landing trafficLanding + // open is every message the person laid out in full under a thread card, + // by team and entry id (teamthreadcard.go), and opened counts the presses + // that changed it, which is what the cards key on. Memory only, and this + // window's. + open map[string]bool + opened int + // version counts the reads that changed any team's cache, which is what a + // thread card in the conversation keys on (teamthreadcard.go). + version int +} + +// trafficTickMsg is one turn of the Traffic clock coming round. +type trafficTickMsg struct{} + +// trafficJob is one team's read: after the cursor, or the tail on a first look. +type trafficJob struct { + id string + after string + first bool +} + +// trafficGot is what one team's read found. +type trafficGot struct { + trafficJob + entries []teamstore.Entry + err error +} + +// trafficTitle is a member that joined with no title and has one now. +type trafficTitle struct{ team, key, word string } + +// ── THE CLOCK AND THE READ ────────────────────────────────────────────────── + +// trafficHeld reports whether this window holds key: in front or behind. +func (a *app) trafficHeld(key string) bool { + return key != "" && (key == a.frontTabKey() || a.behind[key] != nil) +} + +// trafficTeamWanted reports whether team t is worth reading: it has a manager +// and this window holds one of its conversations. It allocates nothing. +func (a *app) trafficTeamWanted(t team) bool { + if t.Manager == "" { + return false + } + for _, m := range t.Members { + if a.trafficHeld(m.Key) { + return true + } + } + return false +} + +// trafficWanted reports whether any team is worth reading, which is when the +// clock runs. It allocates nothing: it is asked after every message. +func (a *app) trafficWanted() bool { + if !a.wall.loaded || len(a.wall.teams) == 0 || a.teamsOff() { + return false + } + for _, t := range a.wall.teams { + if a.trafficTeamWanted(t) { + return true + } + } + return false +} + +// trafficArm starts the clock when there is something to read and it is not +// already turning. It is asked after every message ([app.Update]), so a team +// made, a member joined or a manager opened starts it without each of those +// doors having to know. Its first turn reads at once; the read's fold sets the +// turn after it ([app.trafficTake]). +func (a *app) trafficArm() tea.Cmd { + if a.traffic.ticking || !a.trafficWanted() { + return nil + } + a.traffic.ticking = true + a.traffic.idle = 0 + return a.trafficReadOf(a.trafficIDs(), true) +} + +// trafficIDs is every managed team this window holds a conversation in. +func (a *app) trafficIDs() []string { + var ids []string + for _, t := range a.wall.teams { + if a.trafficTeamWanted(t) { + ids = append(ids, t.ID) + } + } + return ids +} + +// trafficNext is the clock's next turn: a timer and nothing else. The read is +// started on the loop when it comes round ([app.trafficTick]), so it carries +// the cursors as they are then. +func (a *app) trafficNext() tea.Cmd { + every := trafficEvery + if a.traffic.idle >= trafficIdleTurns { + every = trafficEveryIdle + } + return surfaceTick(every, func(time.Time) tea.Msg { return trafficTickMsg{} }) +} + +// trafficTick is a turn of the clock: read, and come round again from the +// read's fold, while there is anything to read. It stops itself when there is +// not, and [app.trafficArm] starts it again. The turn itself changes nothing a +// frame draws, so it is always quiet; the read's fold says whether anything +// moved. +func (a *app) trafficTick(trafficTickMsg) (cmd tea.Cmd, quiet bool) { + if !a.trafficWanted() { + a.traffic.ticking = false + return nil, true + } + return a.trafficReadOf(a.trafficIDs(), true), true +} + +// trafficTitles is every member that joined with no title and whose tab has +// one now. It reads memory, and allocates only when there is one. +func (a *app) trafficTitles() []trafficTitle { + var titles []trafficTitle + for _, t := range a.wall.teams { + if !a.trafficTeamWanted(t) { + continue + } + for _, m := range t.Members { + if strings.TrimSpace(m.Word) != "" { + continue + } + for _, tab := range a.chatTabs { + if tab.key == m.Key && !tab.start && !tab.work && strings.TrimSpace(tab.word) != "" { + titles = append(titles, trafficTitle{team: t.ID, key: m.Key, word: tab.word}) + break + } + } + } + } + return titles +} + +// trafficRead reads every managed team this window holds a conversation in, +// the teams file with them, once, without setting the clock. It is a test's. +func (a *app) trafficRead() tea.Cmd { return a.trafficReadOf(a.trafficIDs(), false) } + +// trafficReadOf reads the logs of teams ids after their cursors, and the teams +// file when its stamp moved, through the seam, beside the door line, and folds +// what it found in ([app.trafficTake]). tick says this read is a turn of the +// clock, whose fold sets the next one; a turn that finds a read already out +// leaves the answer to it and only comes round again. +func (a *app) trafficReadOf(ids []string, tick bool) tea.Cmd { + if titles := a.trafficTitles(); len(titles) > 0 { + // A member that joined before it had a title takes its tab's name, + // and with it a handle, as an ordinary edit: [app.teamEdit] gives every + // member this window has a tab for its tab's name on the way, and the + // write is made after this message ([app.teamsWrite]). + _ = a.teamEdit(func(*teamstore.File) error { return nil }) + } + if a.traffic.reading || !a.wall.loaded { + if tick { + return a.trafficNext() + } + return nil + } + var jobs []trafficJob + for _, id := range ids { + after, seen := a.traffic.cursor[id] + jobs = append(jobs, trafficJob{id: id, after: after, first: !seen}) + } + a.traffic.reading = true + seam, reserved, stamp, edits := a.teamsSeam(), teamReservedHues(a.pal), a.traffic.stamp, a.traffic.edits + return a.besideLine(func() func(bool) tea.Cmd { + got := make([]trafficGot, len(jobs)) + for i, j := range jobs { + after, limit := j.after, trafficPage + if j.first { + after, limit = "", trafficKeep + } + entries, err := seam.Traffic(j.id, after, limit) + got[i] = trafficGot{trafficJob: j, entries: entries, err: err} + } + fresh, at, same, err := seam.ReadSince(stamp, reserved) + if err != nil || same { + fresh, at = nil, stamp + } + return func(bool) tea.Cmd { return a.trafficTake(got, fresh, at, edits, tick) } + }) +} + +// trafficTake folds one read in, on the loop: the teams file when it changed +// and nothing was edited here since the read began or is still unwritten, each +// team's new entries onto its cache, and the stops and starts among them done. +// A read that found nothing new leaves the frame before it standing. A turn of +// the clock sets the next one here, slower after a run of quiet ones. +func (a *app) trafficTake(got []trafficGot, fresh []team, at string, edits int, tick bool) tea.Cmd { + a.traffic.reading = false + changed := false + if edits == a.traffic.edits && a.traffic.wrote == a.traffic.edits { + if fresh != nil { + a.teamAdopt(teamsClone(fresh)) + changed = true + } + a.traffic.stamp = at + } + if a.traffic.cursor == nil { + a.traffic.cursor, a.traffic.rows, a.traffic.done = map[string]string{}, map[string][]teamstore.Entry{}, map[string]bool{} + } + var acts []tea.Cmd + for _, g := range got { + if g.err != nil { + continue + } + if cur, seen := a.traffic.cursor[g.id]; g.first == seen || (!g.first && cur != g.after) { + // Another read got here first; this one's view of the cursor is + // stale, and taking it would add its entries twice. + continue + } + if len(g.entries) == 0 { + if g.first { + a.traffic.cursor[g.id] = trafficFromStart + } + continue + } + a.traffic.cursor[g.id] = g.entries[len(g.entries)-1].ID + rows := append(a.traffic.rows[g.id], g.entries...) + if len(rows) > trafficKeep { + rows = append([]teamstore.Entry(nil), rows[len(rows)-trafficKeep:]...) + } + a.traffic.rows[g.id] = rows + changed = true + if g.first { + // A first look is history: what was asked before this window + // opened was asked of another window, or of none, and doing it now + // would do it twice or late. It is history the person has not been + // shown, but it is not news either, so the edge counts nothing + // for it. + if _, ok := a.traffic.seen[g.id]; !ok { + if a.traffic.seen == nil { + a.traffic.seen = map[string]string{} + } + a.traffic.seen[g.id] = a.traffic.cursor[g.id] + } + continue + } + for _, e := range g.entries { + if cmd := a.trafficAct(g.id, e); cmd != nil { + acts = append(acts, cmd) + } + } + } + if changed { + a.traffic.version++ + a.touch() + } else if len(acts) == 0 { + a.ptr.still = a.drawn + } + if tick { + if changed { + a.traffic.idle = 0 + } else { + a.traffic.idle++ + } + if a.trafficWanted() { + acts = append(acts, a.trafficNext()) + } else { + a.traffic.ticking = false + } + } + return tea.Batch(acts...) +} + +// ── THE ACTS ──────────────────────────────────────────────────────────────── + +// trafficAct does what one new entry asks of this window, once per entry id: a +// stop for a conversation it holds, a start when it holds the team's manager. +func (a *app) trafficAct(teamID string, e teamstore.Entry) tea.Cmd { + if e.Kind != teamstore.KindStop && e.Kind != teamstore.KindStart { + return nil + } + done := teamID + "/" + e.ID + if a.traffic.done[done] { + return nil + } + t, ok := a.teamByID(teamID) + if !ok { + return nil + } + switch e.Kind { + case teamstore.KindStop: + key := trafficMemberKey(t, e.To, e.Member) + if !a.trafficHeld(key) { + return nil + } + a.traffic.done[done] = true + a.trafficStop(key) + return nil + case teamstore.KindStart: + if t.Manager == "" || !a.trafficHeld(t.Manager) { + return nil + } + a.traffic.done[done] = true + return a.trafficStart(t, e) + } + return nil +} + +// trafficMemberKey is the member an entry addresses: by the conversation key +// it carries when it carries one the team holds, and otherwise by its handle. +func trafficMemberKey(t team, handle, key string) string { + if key != "" && t.Holds(key) { + return key + } + if m, ok := t.ByHandle(handle); ok { + return m.Key + } + return "" +} + +// trafficStop is the manager's stop for a conversation this window holds. It +// is the person's own stop and nothing more: the current turn ends, and what +// is queued behind it is left alone. +func (a *app) trafficStop(key string) { + if key == a.frontTabKey() { + if a.state != stateWorking { + return + } + a.interruptTurn() + a.note(a.teamManagerMark() + " the manager stopped this turn") + return + } + if held := a.behind[key]; held != nil && held.conv.Agent != nil { + held.conv.Agent.Interrupt() + } +} + +// trafficStart is the manager's start: a new conversation in the team's +// folder, opened BEHIND the one in front and never brought forward, in the +// team under the handle the manager chose. +// +// NOTHING A MANAGER DOES MOVES THE PERSON'S FOCUS. Whoever is in front stays +// in front and keeps the keyboard: a start that took the front would send the +// next words somebody was typing to the manager into a conversation they have +// never seen. The new member arrives as a tab at the end of the team's run, +// named by its handle (`@lexer`) until it has a title, and its working mark is +// the only thing that stirs. +// +// THE BRIEF IS NOT SENT FROM HERE. It is the manager's line in the Traffic, +// and the member reads it there as the manager's, at its first step; the +// session starts that first turn itself once it sees it has been made a +// member (internal/session's team_wake.go). +// +// The conversation is opened on the door line, off the loop, because opening +// one is a call to the engine; what comes back is held and joined here. +func (a *app) trafficStart(t team, e teamstore.Entry) tea.Cmd { + handle := strings.TrimSpace(e.To) + switch { + case a.shared: + a.trafficStartRefused(handle, oneConversationWord) + return nil + case a.start == nil || !a.canStart(): + a.trafficStartRefused(handle, newUnavailableWord) + return nil + } + start, where, id := a.start, a.teamWhere(t), t.ID + return a.besideLine(func() func(bool) tea.Cmd { + conv, err := start(where) + return func(bool) tea.Cmd { return a.trafficStarted(id, handle, conv, err) } + }) +} + +// trafficStartRefused says, beside the manager, why a start was not done. +func (a *app) trafficStartRefused(handle, why string) { + a.note(a.teamManagerMark() + " could not start @" + handle + ": " + why) +} + +// trafficStarted is the start's conversation back from the engine: held +// behind, joined to the team under its handle, and said beside the manager. +func (a *app) trafficStarted(id, handle string, conv Conversation, err error) tea.Cmd { + if err != nil || conv.Agent == nil { + why := "the conversation did not open" + if err != nil { + why = err.Error() + } + a.trafficStartRefused(handle, why) + return nil + } + t, ok := a.teamByID(id) + if !ok { + // The team went while the conversation was opening. It is held all the + // same, as any other conversation this window opened. + t = team{} + } + key := a.convKey(conv.SessionFile) + cmd := a.stow(conv, nil) + a.trafficBehindTop(key) + a.chatTabBar = tabBar{} + if t.ID != "" { + m := teamMember{Key: key, File: conv.SessionFile, Where: conv.Workspace, Handle: handle} + if err := a.teamEdit(func(f *teamstore.File) error { + if err := f.AddMember(t.ID, m); err != nil { + return err + } + if got, _ := f.Teams[teamIndex(f.Teams, t.ID)].Member(m.Key); got.Handle != handle && teamstore.ValidHandle(handle) == nil { + _ = f.SetHandle(t.ID, m.Key, handle) + } + return nil + }); err != nil { + a.note("@" + handle + " is in " + t.Name + " for this window, but " + err.Error()) + } + } + if t.Manager != "" && t.Manager == a.frontTabKey() { + a.note(a.teamManagerMark() + " started @" + handle + " · its tab is on the strip") + } + a.touch() + return cmd +} + +// trafficBehindTop keeps a conversation opened behind from becoming the one +// `tab` goes back to. The keeper put it on top of the previous-stack as it +// does every conversation it takes ([app.rememberOpen]); a start is not +// somewhere the person has been, so it goes under the two they have. +func (a *app) trafficBehindTop(key string) { + n := len(a.prev) + if key == "" || n < 2 || a.prev[n-1] != key { + return + } + if n == 2 { + a.prev[0], a.prev[1] = key, a.prev[0] + return + } + a.prev[n-1], a.prev[n-2] = a.prev[n-2], a.prev[n-3] + a.prev[n-3] = key +} diff --git a/internal/tui3/teamtraffic_test.go b/internal/tui3/teamtraffic_test.go new file mode 100644 index 0000000000..38df49333b --- /dev/null +++ b/internal/tui3/teamtraffic_test.go @@ -0,0 +1,517 @@ +package tui3 + +import ( + "fmt" + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// trafficApp is the strip's three conversations as one team, harbor, on a +// profile of the test's own, with the conversation in front its manager and +// the two behind it its members. older and newer are the agents behind. +func trafficApp(t *testing.T) (a *app, harbor string, older, newer *fakeAgent) { + t.Helper() + a, older, newer = tabApp(t) + a.profileDir = t.TempDir() + var err error + if harbor, err = a.teamMake("harbor", a.tabList()); err != nil { + t.Fatal(err) + } + a.teamActivate(harbor) + front := a.frontTabKey() + for _, tab := range a.tabList() { + if tab.key == front { + if err := a.teamMakeManager(harbor, tab); err != nil { + t.Fatal(err) + } + } + } + teamsFlush(t, a) + if got := mustTeam(t, a, harbor); got.Manager != front { + t.Fatalf("the fixture's manager is %q", got.Manager) + } + return a, harbor, older, newer +} + +// trafficHandle is the handle of the member whose tab says word. +func trafficHandle(t *testing.T, a *app, id, word string) (string, string) { + t.Helper() + for _, m := range mustTeam(t, a, id).Members { + if strings.Contains(m.Word, word) { + if m.Handle == "" { + t.Fatalf("member %q has no handle", m.Word) + } + return m.Handle, m.Key + } + } + t.Fatalf("no member says %q: %+v", word, mustTeam(t, a, id).Members) + return "", "" +} + +// trafficAppend writes entries to team id's log, as the team tools do. +func trafficAppend(t *testing.T, a *app, id string, entries ...teamstore.Entry) { + t.Helper() + for _, e := range entries { + if err := teamstore.AppendTraffic(a.profileDir, id, e); err != nil { + t.Fatal(err) + } + } +} + +// trafficReadNow is one turn of the Traffic read, run and folded in. +func trafficReadNow(t *testing.T, a *app) { + t.Helper() + teamsFlush(t, a) + a.traffic.reading = false + spend(t, a, a.trafficRead()) + teamsFlush(t, a) +} + +// THE COLUMN IS THE CACHE, BESIDE THE MANAGER, AND IT OPENS ON THE TRAFFIC. +// With the manager in front on a wide frame the right of the body is the side +// column, its header `Tasks 0 · Traffic N` with the Traffic in front; the +// directive is a row of work, the note that answers nothing is General's; the +// person's own lines are not drawn; the conversation is narrowed by exactly +// the column; the composer says the words go to the manager; and a handle +// pressed goes to its member, where the same column, the same width, shows +// that member's own chat. +func TestTrafficColumnBesideTheManager(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 180, 40 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + rail, _ := trafficHandle(t, a, harbor, "Refactor") + d, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: rail, Text: "take the scope model"}) + trafficAppend(t, a, harbor, + teamstore.Entry{Kind: teamstore.KindNote, From: price, To: rail, Text: "prices are in"}, + teamstore.Entry{Kind: teamstore.KindYou, From: teamstore.FromYou, To: teamstore.ToManager, Text: "my own words"}, + ) + trafficReadNow(t, a) + if got := len(a.traffic.rows[harbor]); got != 3 { + t.Fatalf("the cache holds %d entries", got) + } + if a.sideView() != sideTraffic { + t.Fatal("a manager's column does not open on the Traffic") + } + a.sideToggleThread(sideThreadKey(harbor, sideGeneral)) + rows := railLines(t, a) + joined := strings.Join(rows, "\n") + cols := a.railWidth() + if cols != sideColsFor(a.width) || a.bodyWidth() != a.width-cols { + t.Fatalf("the column takes %d columns and leaves the body %d of %d", cols, a.bodyWidth(), a.width) + } + head := railRowOf(rows, sideTasksWord+" 0"+sideWordSep+sideTrafficWord) + general := railRowOf(rows, "General") + work := railRowOf(rows, "take the scope") + note := railRowOf(rows, "@"+price+" → ") + if head < 0 || !strings.HasSuffix(rows[head], sideHideKey) || general != head+1 || note != general+1 || work <= note { + t.Fatalf("the column does not draw its header, General open with the note, and the work under it (%d, %d, %d, %d):\n%s", head, general, note, work, joined) + } + if strings.Contains(joined, "my own words") { + t.Fatalf("the person's own line is on the column:\n%s", joined) + } + frame, _, _ := a.frame() + if !strings.Contains(ansi.Strip(frame), "to "+teamManagerGlyph+" manager") { + t.Fatalf("the composer does not say where the words go:\n%s", ansi.Strip(frame)) + } + + // Under the pointer the handle names its member, and the row says itself + // whole. + x, y := sideDoorOf(t, a, sideActJump) + a.setHover(x, y) + if a.hot.kind != hoverSide || a.hot.index < 0 { + t.Fatalf("the handle does not answer the pointer: %+v", a.hot) + } + if words := a.dockHoverWords(); !strings.Contains(words, "@") || !strings.Contains(words, "click") { + t.Fatalf("the hint line over the handle says %q", words) + } + wx, wy := sideRowOn(t, a, "thread/"+d) + a.setHover(wx, wy) + if words := a.dockHoverWords(); !strings.Contains(words, "take the scope model") { + t.Fatalf("the hint line over the row says %q", words) + } + a.dropHover() + + // The note's handle goes to the member who wrote it. + px, py := sideRowDoor(t, a, railKeyOfReply(t, a, "prices are"), sideActJump) + sideClick(t, a, px, py) + if a.frontTabKey() != priceKey { + t.Fatalf("the handle went to %q, want %q", a.frontTabKey(), priceKey) + } + // AND IN THE MEMBER'S CHAT THE COLUMN HOLDS STILL: the same width, the + // tasks in front, and its Traffic that member's own messages. + if a.railWidth() != cols || a.bodyWidth() != a.width-cols { + t.Fatalf("the column moved beside a member: %d, was %d", a.railWidth(), cols) + } + if a.sideKind() != sideKindMember || a.sideView() != sideTasks { + t.Fatalf("a member's column is kind %d view %d", a.sideKind(), a.sideView()) + } + a.sideSetView(sideTraffic) + rows = railLines(t, a) + joined = strings.Join(rows, "\n") + if railRowOf(rows, "@"+rail+" prices are in") < 0 || strings.Contains(joined, "take the scope model") { + t.Fatalf("the member's Traffic is not its own messages only:\n%s", joined) + } + // A member of a managed team is told where its words go too. + if got := a.trafficHint(); got != "to @"+price { + t.Fatalf("a member's composer says %q", got) + } +} + +// railKeyOfReply is the key of the drawn row that says words. +func railKeyOfReply(t *testing.T, a *app, words string) string { + t.Helper() + view, _ := a.railDrawnView(a.viewHeight()) + for _, line := range view { + if line.side != nil && strings.Contains(ansi.Strip(line.text), words) { + return line.side.key + } + } + t.Fatalf("no row of the column says %q", words) + return "" +} + +// AT 110 COLUMNS THE COLUMN STANDS. A 110-column laptop terminal is not +// narrow: the one column takes the right, at the width every chat gives it, +// and leaves the conversation its floor. +func TestTrafficColumnStandsAt110(t *testing.T) { + a, _, _, _ := trafficApp(t) + a.width, a.height = 110, 30 + a.welcome.open = false + trafficReadNow(t, a) + if got := a.railWidth(); got != sideColsFor(110) || got < sideColsMin { + t.Fatalf("at 110 the column has %d columns", got) + } + if a.bodyWidth() < sideBodyFloor { + t.Fatalf("the conversation is left %d columns", a.bodyWidth()) + } + if !a.railShowing() || a.railStowed() { + t.Fatal("the column does not stand at 110") + } + rows := railLines(t, a) + if railRowOf(rows, sideTasksWord+" 0"+sideWordSep+sideTrafficWord) < 0 { + t.Fatalf("the header does not carry both words:\n%s", strings.Join(rows, "\n")) + } +} + +// THE COLUMN IS PUT AWAY BY ITS KEY AND BROUGHT BACK BY ITS EDGE OR ITS KEY. +// The header's `alt+l` puts it away and leaves the edge with a count of what +// came in since; the edge's hint says so; alt+l brings it back, and ctrl+g is +// the same key under its older name. +func TestTrafficColumnHidesAndShows(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 160, 40 + price, _ := trafficHandle(t, a, harbor, "openrouter") + trafficReadNow(t, a) + _ = railLines(t, a) + x, y := sideDoorOf(t, a, sideActHide) + sideClick(t, a, x, y) + if !a.railAway || a.railShowing() { + t.Fatal("the header's key did not put the column away") + } + if got := a.railWidth(); got != railGripCols { + t.Fatalf("a hidden column costs %d columns", got) + } + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: price, To: teamstore.ToManager, Text: "done"}) + trafficReadNow(t, a) + frame, _, _ := a.frame() + var edge strings.Builder + for _, r := range strings.Split(ansi.Strip(frame), "\n") { + edge.WriteString(strings.TrimSpace(plainCells(r, a.width-railGripCols, a.width))) + } + if !strings.Contains(edge.String(), "1") { + t.Fatalf("the edge does not count its one new entry: %q", edge.String()) + } + a.hot = hoverAt{kind: hoverRailGrip} + if words := a.dockHoverWords(); !strings.Contains(words, "Show this column") || !strings.Contains(words, trafficKey) || !strings.Contains(words, "1 new") { + t.Fatalf("the edge's hint says %q", words) + } + a.hot = hoverAt{} + if _, took := a.trafficKeyPress(tea.KeyPressMsg{Code: 'l', Mod: tea.ModAlt}); !took || a.railAway { + t.Fatalf("%s did not bring the column back", trafficKey) + } + drive(t, a, ctrlG()) + if !a.railAway { + t.Fatal("ctrl+g is not the same key") + } + drive(t, a, ctrlG()) + if a.railAway || a.railWidth() != sideColsFor(a.width) { + t.Fatal("ctrl+g did not bring the column back") + } +} + +// ON A NARROW FRAME THERE IS NO COLUMN AND NO EDGE, and the key lays the +// column over the frame: the same header, the same rows. esc takes it away, +// and a handle pressed on it goes to its member and takes the overlay with it. +func TestTrafficColumnNarrowIsAnOverlay(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + a.width, a.height = 80, 30 + price, priceKey := trafficHandle(t, a, harbor, "openrouter") + q, _ := teamstore.AppendTrafficID(a.profileDir, harbor, teamstore.Entry{Kind: teamstore.KindDirective, From: teamstore.FromManager, To: price, Text: "scrape the prices"}) + trafficReadNow(t, a) + if a.railWidth() != 0 || a.railStowed() { + t.Fatalf("a narrow frame gave the column %d columns", a.railWidth()) + } + frame, _, _ := a.frame() + if strings.Contains(ansi.Strip(frame), "scrape the prices") { + t.Fatal("the traffic is drawn before the key was pressed") + } + drive(t, a, key(trafficKey)) + if !a.railFull() { + t.Fatal("alt+l did not lay the column over the frame") + } + frame, _, _ = a.frame() + if !strings.Contains(ansi.Strip(frame), "scrape the prices") || !strings.Contains(ansi.Strip(frame), sideTrafficWord) { + t.Fatalf("the overlay does not draw the Traffic:\n%s", ansi.Strip(frame)) + } + drive(t, a, key("esc")) + if a.railFull() { + t.Fatal("esc did not take the overlay away") + } + drive(t, a, key(trafficKey)) + _, _, _ = a.frame() + x, y := sideRowDoor(t, a, "thread/"+q, sideActJump) + sideClick(t, a, x, y) + if a.frontTabKey() != priceKey || a.railFull() { + t.Fatalf("the handle went to %q with the overlay still up: %v", a.frontTabKey(), a.railFull()) + } +} + +// A QUIET TURN OF THE CLOCK READS NOTHING AND DRAWS NOTHING. The turn asks the +// seam, which answers a log that has not moved and a teams file at its stamp +// with nothing; the fold changes nothing, the frame before stands, and the +// clock counts the quiet turn. A log that moved is read on the next turn. +func TestTrafficQuietTickReadsNothing(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + trafficReadNow(t, a) + a.traffic.ticking = true + turn := func() { + t.Helper() + cmd, quiet := a.trafficTick(trafficTickMsg{}) + if !quiet || cmd == nil { + t.Fatalf("a turn of the clock drew (quiet %v) or asked nothing", quiet) + } + door, ok := cmd().(doorMsg) + if !ok { + t.Fatal("the turn's read is not a door beside the line") + } + if next := door.fold(true); next == nil { + t.Fatal("the turn did not set the next one") + } + } + rows, idle := len(a.traffic.rows[harbor]), a.traffic.idle + a.drawn, a.ptr.still = true, false + turn() + if len(a.traffic.rows[harbor]) != rows || a.traffic.idle != idle+1 || !a.ptr.still || a.traffic.reading { + t.Fatalf("a quiet turn changed something (rows %d, idle %d, still %v)", len(a.traffic.rows[harbor]), a.traffic.idle, a.ptr.still) + } + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindNote, From: teamstore.FromManager, To: teamstore.ToRoom, Text: "moved"}) + turn() + if got := a.traffic.rows[harbor]; len(got) != rows+1 || got[len(got)-1].Text != "moved" || a.traffic.idle != 0 { + t.Fatalf("a log that moved was not read: %+v (idle %d)", got, a.traffic.idle) + } + // No manager, no clock. + b, _, _, _ := trafficApp(t) + for i := range b.wall.teams { + b.wall.teams[i].Manager = "" + } + if b.trafficWanted() { + t.Fatal("a team with no manager keeps the clock turning") + } +} + +// A STOP IS DONE ONCE, AND A START IS DONE ONCE, AND A WINDOW OPENING DOES +// NEITHER FOR WHAT CAME BEFORE IT. The manager stops a member this window holds +// behind the manager: that member's turn is stopped, once, however many reads +// go past the entry. The manager starts a member: one conversation opens in the +// team's folder BEHIND the one in front, joins under the manager's handle for +// it, and is sent nothing: the person's focus does not move, `tab` does not go +// to it, and its tab reads `@lexer`. A second window reading the same log from +// its tail does neither. +func TestTrafficStopAndStartAreDoneOnceAndNeverReplayed(t *testing.T) { + a, harbor, older, _ := trafficApp(t) + price, _ := trafficHandle(t, a, harbor, "openrouter") + trafficReadNow(t, a) // the first look: an empty log, read from its start after this + if got := a.traffic.cursor[harbor]; got != trafficFromStart { + t.Fatalf("an empty log's cursor is %q", got) + } + + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindStop, From: teamstore.FromManager, To: price, Text: "stuck in a retry loop"}) + trafficReadNow(t, a) + trafficReadNow(t, a) + if older.stops != 1 { + t.Fatalf("the stop was done %d times", older.stops) + } + // A read that hands the same entries back again changes nothing. + entries, _ := teamstore.ReadTraffic(a.profileDir, harbor, trafficFromStart, 0) + a.trafficTake([]trafficGot{{trafficJob: trafficJob{id: harbor, after: a.traffic.cursor[harbor]}, entries: entries}}, nil, a.traffic.stamp, a.traffic.edits, false) + if older.stops != 1 { + t.Fatalf("a replayed read stopped the member again: %d", older.stops) + } + + n := 0 + var fresh *fakeAgent + a.start = func(workspace string) (Conversation, error) { + n++ + fresh = &fakeAgent{model: "m"} + return Conversation{Agent: fresh, SessionFile: fmt.Sprintf("/tmp/lab/started-%d.jsonl", n), Workspace: workspace}, nil + } + front := a.frontTabKey() + back, _ := a.lastBehind() + a.input.insert("half a sentence to the manager") + trafficAppend(t, a, harbor, teamstore.Entry{Kind: teamstore.KindStart, From: teamstore.FromManager, To: "lexer", Text: "rewrite the lexer"}) + trafficReadNow(t, a) + trafficReadNow(t, a) + if n != 1 { + t.Fatalf("the start opened %d conversations", n) + } + if a.frontTabKey() != front || string(a.input.value) != "half a sentence to the manager" { + t.Fatalf("the start moved the focus: front %q (was %q), box %q", a.frontTabKey(), front, string(a.input.value)) + } + if got, _ := a.lastBehind(); got != back { + t.Fatalf("tab now goes to %q, not %q", got, back) + } + m, ok := mustTeam(t, a, harbor).ByHandle("lexer") + if !ok || a.behind[m.Key] == nil { + t.Fatalf("the started conversation is not @lexer in harbor, held behind: %+v", mustTeam(t, a, harbor).Members) + } + if len(fresh.sent) != 0 { + t.Fatalf("the brief was sent as the person's words: %q", fresh.sent) + } + a.touch() + if row := plain(a.tabsRow(a.width)); !strings.Contains(row, "@lexer") { + t.Fatalf("the new member's tab does not read @lexer: %q", row) + } + teamsFlush(t, a) + disk, _ := loadTeams(a.profileDir, nil) + if got, ok := disk[0].ByHandle("lexer"); !ok || got.Key != m.Key { + t.Fatalf("the new member did not reach the disk: %+v", disk[0].Members) + } + // The column says what the stop and the start were for, under General. + // The route takes the cells the brief used to have, so a cut word is on + // the hint line, whole. + a.width, a.height = 180, 40 + a.sideToggleThread(sideThreadKey(harbor, sideGeneral)) + rows := strings.Join(railLines(t, a), "\n") + if !strings.Contains(rows, teamManagerGlyph+" → @lexer") || !strings.Contains(rows, "started @lexer") || !strings.Contains(rows, "stopped @"+price) { + t.Fatalf("the column drops the stop or the start:\n%s", rows) + } + if hint := a.sideRowOf(railKeyOfReply(t, a, "started @lexer")).hint; !strings.Contains(hint, "rewrite") { + t.Fatalf("the start's brief is not on the hint: %q", hint) + } + if hint := a.sideRowOf(railKeyOfReply(t, a, "stopped @"+price)).hint; !strings.Contains(hint, "stuck") { + t.Fatalf("the stop's reason is not on the hint: %q", hint) + } + + // A second window on the same log, holding the same conversations. + b, _, olderB, _ := trafficApp(t) + b.profileDir = a.profileDir + b.wall.loaded = false + b.teamsEnsure() + b.teamActivate(harbor) + nb := 0 + b.start = func(string) (Conversation, error) { + nb++ + return Conversation{}, fmt.Errorf("no") + } + trafficReadNow(t, b) + trafficReadNow(t, b) + if olderB.stops != 0 || nb != 0 { + t.Fatalf("a window opening did what was asked before it: %d stops, %d starts", olderB.stops, nb) + } + if len(b.traffic.rows[harbor]) != 2 { + t.Fatalf("the history is not in the new window's cache: %+v", b.traffic.rows[harbor]) + } +} + +// THE MANAGER'S PLACE IS PINNED. At 80 columns with a member in front the +// manager's tab is still on the strip, first, and `+ Manager` leaves a strip +// that narrow. +func TestTeamManagerPlaceIsPinnedAt80(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + _, priceKey := trafficHandle(t, a, harbor, "openrouter") + spend(t, a, a.trafficGo(priceKey)) + a.width, a.height = 80, 30 + a.touch() + row := plain(a.tabsRow(a.width)) + if !strings.Contains(row, teamManagerGlyph+" "+teamManagerWord) { + t.Fatalf("the manager's place scrolled off at 80: %q", row) + } + b, _ := managerApp(t) + b.width = 80 + b.touch() + if row := plain(b.tabsRow(b.width)); strings.Contains(row, teamManagerSlotWord) { + t.Fatalf("+ Manager takes a slot at 80: %q", row) + } + b.width = 160 + b.touch() + _ = b.tabsRow(b.width) + slot := stripHitKind(t, b, tabManager) + b.hot = hoverAt{kind: hoverTab, index: slot.span.from} + if words := b.dockHoverWords(); !strings.HasPrefix(words, "Start a manager") { + t.Fatalf("+ Manager explains itself as %q", words) + } +} + +// A TEAM'S NOTE IS A QUOTED CARD. The session's note is read into its lines, +// each headed by who said it to whom, and a directive carries `do`. +func TestTeamAsideReadsAsCards(t *testing.T) { + text := "Team traffic in \"harbor\" for you (@lexer). These are the team's messages, not the person's words:\n" + + "◆ directive from manager: rewrite the lexer\n" + + "from @web to the room: the build is green\n" + + "(The person's own words in this conversation outrank the manager.)" + cards, ok := teamAsideCards(text, teamManagerGlyph) + if !ok || len(cards) != 2 { + t.Fatalf("the note read as %+v", cards) + } + if c := cards[0]; c.from != teamManagerGlyph+" manager" || c.to != "@lexer" || c.tag != "do" || c.text != "rewrite the lexer" { + t.Fatalf("the manager's line read as %+v", c) + } + if c := cards[1]; c.from != "@web" || c.to != "room" { + t.Fatalf("the teammate's line read as %+v", c) + } +} + +// A MEMBER THAT JOINED BEFORE IT HAD A TITLE IS TITLED BY THE READ. Nothing a +// person does has to happen for it: the Traffic read sees the member's tab has +// a name now, writes it through the store, and the member has a handle the +// manager can address it by. +func TestTrafficReadTitlesAMemberThatJoinedUntitled(t *testing.T) { + a, harbor, _, _ := trafficApp(t) + if err := a.teamEdit(func(f *teamstore.File) error { + return f.AddMember(harbor, teamstore.Member{Key: "/tmp/lab/late.jsonl", File: "/tmp/lab/late.jsonl"}) + }); err != nil { + t.Fatal(err) + } + if m, _ := mustTeam(t, a, harbor).Member("/tmp/lab/late.jsonl"); m.Handle != "" { + t.Fatalf("an untitled member has handle %q", m.Handle) + } + a.chatTabs = append(a.chatTabs, chatTab{key: "/tmp/lab/late.jsonl", file: "/tmp/lab/late.jsonl", word: "benchmark sweep"}) + trafficReadNow(t, a) + if m, _ := mustTeam(t, a, harbor).Member("/tmp/lab/late.jsonl"); m.Handle != "benchmark" { + t.Fatalf("the read left the member as %+v", m) + } + teamsFlush(t, a) + disk, _ := loadTeams(a.profileDir, nil) + if m, _ := disk[0].Member("/tmp/lab/late.jsonl"); m.Handle != "benchmark" { + t.Fatalf("the title did not reach the disk: %+v", m) + } +} + +// A REPLAYED BRIEF IS THE MANAGER'S CARD. The session hands the lines it +// delivered on the aside ([session.TeamLine]); the start's reads +// `◆ manager → @lexer` over the quoted brief, never the person's `›`. +func TestAReplayedBriefIsTheManagersCard(t *testing.T) { + a, _, _, _ := trafficApp(t) + text := "Team traffic in \"harbor\" for you (@lexer). These are the team's messages, not the person's words:\n◆ brief from manager: rewrite the lexer" + e := entry{kind: entryTeam, text: text, team: []session.TeamLine{{Team: "harbor", From: teamstore.FromManager, Kind: teamstore.KindStart, Text: "rewrite the lexer"}}} + rows := ansi.Strip(strings.Join(a.teamCardRows(e, 60), "\n")) + if !strings.Contains(rows, teamManagerGlyph+" manager → @lexer") || !strings.Contains(rows, "│ rewrite the lexer") || strings.Contains(rows, "›") { + t.Fatalf("the brief draws as:\n%s", rows) + } +} diff --git a/internal/tui3/title_test.go b/internal/tui3/title_test.go index ce771af131..7652577678 100644 --- a/internal/tui3/title_test.go +++ b/internal/tui3/title_test.go @@ -71,6 +71,7 @@ func TestTheTerminalTitleSaysWhereYouAre(t *testing.T) { func TestEveryPlaceTitlesTheTabWithItsWord(t *testing.T) { want := map[page]string{ pageTasks: "sessions · codeaf", + pageTeams: "teams · codeaf", pageStanding: "standing · codeaf", pageMemory: "memory · codeaf", pageSpend: "spend · codeaf", diff --git a/internal/tui3/toolstat.go b/internal/tui3/toolstat.go index bc0bccc8d7..1ab1036a74 100644 --- a/internal/tui3/toolstat.go +++ b/internal/tui3/toolstat.go @@ -171,6 +171,14 @@ func (a *app) toolTargetOf(e *entry) string { return target } } + // A MANAGER'S MESSAGE IS SAID AS ITS THREAD CARD'S HEAD: who it went to + // and whether it was a directive, the words quoted under it + // (teamthreadcard.go). + if e.tool == "team_send" { + if target := a.teamSendTarget(e); target != "" { + return target + } + } return toolTarget(e.tool, e.detail.Args, e.text) } diff --git a/internal/tui3/toolview.go b/internal/tui3/toolview.go index 1ec049bb39..a3e331feff 100644 --- a/internal/tui3/toolview.go +++ b/internal/tui3/toolview.go @@ -214,6 +214,21 @@ func (a *app) toolRows(d deck, i int, last bool, width int) []row { if forming { bodyHit = hitNone } + // A MANAGER'S MESSAGE HANGS ITS THREAD instead of a preview: the words + // quoted, and each member's answer under them as it lands + // (teamthreadcard.go). Opened, it is an ordinary call again. + if !e.open { + if card, ok := a.teamSendCard(e, i, room); ok { + for _, r := range card { + hit := bodyHit + if r.open != "" && !forming { + hit = hitThread + } + out = append(out, row{text: a.pal.dim(stem) + r.text, entry: i, hit: hit, open: r.open}) + } + return out + } + } out = append(out, a.mediaRows(e, i, width-workIndentCols(width), a.pal.dim(stem))...) body, more := a.toolBlock(e, room, layoutTier(width) == tierPhone) for _, line := range body { diff --git a/internal/tui3/topnav.go b/internal/tui3/topnav.go new file mode 100644 index 0000000000..f2ffb8331c --- /dev/null +++ b/internal/tui3/topnav.go @@ -0,0 +1,511 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" + "github.com/charmbracelet/x/ansi" +) + +// ── THE TOP NAV: THE PLACES, ON THE WORDMARK'S ROW, ON EVERY PAGE ─────────── +// +// >● codeaf home teams chats sessions spend settings 2 want you · $1.20 thu 10:31pm +// >● codeaf home teams chats sessions spend settings 2 ? · $1.20 / $20 +// >● codeaf home teams chats sessions more ▾ 2 ? · $1.20 +// +// The first row of every frame is the product's name, the places a person can +// go, and the machine's pulse on the far end (pulse.go). It is drawn by ONE +// function ([app.navLine]) for a place, a conversation, a room inside one and +// the grid of open tabs, so the words are in the same cells whichever page is +// up and a hand that learned where `spend` is finds it there everywhere. +// +// ── THE LAWS ── +// +// - THE PLACE YOU ARE IN IS LIT IN THE ONE ACCENT and every other word is +// muted. Inside a conversation, or on the grid of its tabs, the place is +// `chats` ([app.navLit]): the strip under the nav is the chats, so the word +// that names them is the one lit over it. +// - EVERY WORD IS A WORD BUTTON: a one-cell pad either side, a ground under +// the pointer that covers the pads too, and a press anywhere on that ground +// goes to the place ([app.navPress]). The pad cells are the target because +// they are drawn as the button; a one-cell miss beside a word is a miss +// people make. Where colour cannot show a ground, the pointer's word wears +// the linear mark `·` in its leading pad, as the strip's tabs do. +// - THE HINT LINE SAYS WHAT A WORD OPENS AND ITS KEY while the pointer rests +// on it ([app.headHint]), so a word is never a lone label a person has to +// press to learn about. +// - THE GAPS ARE FIXED. One cell of inset at each end of the row, [navLead] +// cells between the wordmark and the first button, no cells between two +// buttons (their pads are the air, two blank cells between two words), and +// at least [navTailGap] cells before the pulse. None of them changes with +// the width; what a narrow row gives up is words and clauses, never air. +// +// ── THE WIDTH LADDER ── +// +// A row too narrow for everything gives things up IN THE OWNER'S ORDER +// (2026-09-24): the clock goes first (and the machine's name with it, the +// other fact every terminal title already carries), then the moving count, +// then the words of `2 want you`, which shortens to `2 ?` in the same amber, +// then the allowance behind the day's figure, and only then do the trailing +// places fold into `more ▾`, one word at a time from the right. The day's +// figure goes after every place has folded, and THE COUNT THAT WANTS YOU +// NEVER GOES: it is the one thing on this row a person must not have to go +// looking for, so it outlasts the money and the places (pulse.go). +// The wordmark, the place you are in and the word under the bar's cursor +// never fold, and a place wearing a count keeps its word, because a number is +// this row saying something moved in a room you are not in. +// +// `more ▾` IS A DOOR: a press opens a small menu of exactly the places it +// folded (navmore.go), so a narrow row still reaches every place by pointer as +// well as by `alt+N`. + +// navRow is the row of the frame the nav is drawn on, the first, over the +// strip. The frame records that it drew one in [app.tabRow], which is -1 on a +// frame with no head at all. +const navRow = 0 + +// tabStripRow is the row the chat strip is drawn on: under the nav and over +// the rule, and only while a conversation is in front (head.go). +const tabStripRow = 1 + +const ( + // navInset is the blank cell at each end of the row, the same inset every + // row of the head keeps. + navInset = 1 + // navLead is the air between the wordmark and the first place's button. + // With the button's own pad it reads as three blank cells, which is what + // tells the product's name from the first word a person can press. + navLead = 2 + // navTailGap is the least air between the last button and the pulse, so a + // clause of the pulse never reads as one more place. + navTailGap = 2 +) + +// navMoreWord is the fold's own word, `more ▾`, with the caret every menu on +// this surface wears ([app.tabTeamWord]). +func (a *app) navMoreWord(pal palette) string { + caret := a.linearMark("▾", "v") + if pal.ascii { + caret = "v" + } + return "more " + caret +} + +// navLit is the place the nav lights: the one a person is standing in, and +// `chats` everywhere that is not a place, since every such page is the chats. +func (a *app) navLit() page { + if a.pageShowing() { + return a.page + } + return pageChats +} + +// navMemo is the nav as it was last laid out, reused while nothing it is drawn +// from has changed. THE ROW IS ON EVERY FRAME OF A SCROLL, and the scroll is +// held to an allocation ceiling (inputsmooth_test.go); a row that said the +// same thing for four thousand lines is laid out once. Every field is compared +// as a value, so the check costs nothing. +type navMemo struct { + width int + ink uint64 + page, hover page + bar barCursor + every, moreOn, moreHot bool + facts machineFacts + minute int64 + host string + counts [16]int + profile tokens.Profile + ascii, linear, places bool + accent, muted hue + line string + spans []placeTabSpan + more hudSpan + folded []page +} + +// navMemoKey is the memo's key half for this frame. +func (a *app) navMemoKey(width int, pal palette) navMemo { + m := navMemo{width: width, ink: a.inkState, page: a.page, hover: a.tabHover, bar: a.bar, + every: a.mapShowing, moreOn: a.navMore.on, moreHot: a.navMore.hot, facts: a.machine, + host: a.host, profile: pal.profile, ascii: pal.ascii, linear: a.linear || pal.linear, places: pal.placeRows, + accent: pal.ramp.accent, muted: pal.ramp.muted} + if now := a.now(); !now.IsZero() { + m.minute = now.Unix() / 60 + } + for i, id := range placeOrder { + if i < len(m.counts) { + m.counts[i] = a.placeCount(id) + } + } + return m +} + +func (m navMemo) same(k navMemo) bool { + return m.line != "" && m.width == k.width && m.ink == k.ink && m.page == k.page && m.hover == k.hover && + m.bar == k.bar && m.every == k.every && m.moreOn == k.moreOn && m.moreHot == k.moreHot && + m.facts == k.facts && m.minute == k.minute && m.host == k.host && m.counts == k.counts && + m.profile == k.profile && m.ascii == k.ascii && m.linear == k.linear && m.places == k.places && + m.accent == k.accent && m.muted == k.muted +} + +// navLine is the head's first row: the wordmark, the places, and the pulse, +// exactly `width` cells wide at most. It writes where every button landed +// ([app.tabs], [navMore.span]) as it draws them. +func (a *app) navLine(width int, pal palette) string { + key := a.navMemoKey(width, pal) + if a.navMemo.same(key) { + a.tabs = a.navMemo.spans + a.navMore.span, a.navMore.folded = a.navMemo.more, a.navMemo.folded + return a.navMemo.line + } + line := a.navLay(width, pal) + key.line = line + key.spans = append([]placeTabSpan(nil), a.tabs...) + key.more = a.navMore.span + key.folded = append([]page(nil), a.navMore.folded...) + a.navMemo = key + return line +} + +// navLay does the layout [app.navLine] memoises. +func (a *app) navLay(width int, pal palette) string { + a.tabs = a.tabs[:0] + a.navMore.span, a.navMore.folded = hudSpan{}, a.navMore.folded[:0] + // HOME'S LINE LEAVES ITS COUNTS TO THE PANELS UNDER IT, and every other + // frame's carries them (pulse.go's [pulseBudget]). + mode := pulseWhole + if a.at(pageHome) { + mode = pulseBudget + } + name := strings.Repeat(" ", navInset) + pal.wordmark(width) + lead := ansi.StringWidth(name) + navLead + lit := a.navLit() + shown := barPages(lit, a.mapShowing) + cost := func(id page) int { return ansi.StringWidth(a.barChipWord(id, a.mapShowing)) + tabPadCols } + all := 0 + for _, id := range shown { + all += cost(id) + } + tails := a.navTails(pal, mode) + tailCost := func(tail string) int { + if tail == "" { + return 0 + } + return navTailGap + ansi.StringWidth(tail) + } + // FIRST THE PULSE GIVES UP ITS CLAUSES, every place still on the row. + for _, tail := range tails[:len(tails)-1] { + if lead+all+tailCost(tail)+navInset <= width { + return a.navPaint(width, pal, name, lead, shown, nil, tail) + } + } + // THEN THE TRAILING PLACES FOLD INTO `more ▾`, from the right, with the + // day's figure still on the row, and last of all the figure goes too, + // leaving the count that wants you, which never goes. + keep := func(id page) bool { return id == lit || a.barKeeps(id) || a.placeCount(id) > 0 } + moreCost := ansi.StringWidth(a.navMoreWord(pal)) + tabPadCols + fixed := 0 + var free []page + for _, id := range shown { + if keep(id) { + fixed += cost(id) + } else { + free = append(free, id) + } + } + for _, tail := range []string{tails[len(tails)-2], tails[len(tails)-1]} { + used := fixed + for _, id := range free { + used += cost(id) + } + for n := len(free) - 1; n >= 0; n-- { + used -= cost(free[n]) + if lead+used+moreCost+tailCost(tail)+navInset <= width { + return a.navPaint(width, pal, name, lead, shown, free[n:], tail) + } + } + } + // A ROW TOO NARROW EVEN FOR THE NAME, THE PLACE YOU ARE IN AND THE FOLD is + // drawn with every foldable word folded and cut at the frame's edge; a + // button the cut reached is not a target ([app.navPaint]). + return a.navPaint(width, pal, name, lead, shown, free, tails[len(tails)-1]) +} + +// navTails is every spelling the pulse end of the row may take, widest first, +// in the order the ladder gives clauses up (this file's header). The last but +// one is the day's figure with the short count, which the places fold beside, +// and the last is the short count alone ("" when nothing wants you). +func (a *app) navTails(pal palette, mode pulseMode) [7]string { + p := a.pulseParts(a.now(), pal, mode) + host := "" + if name := strings.TrimSpace(a.host); name != "" { + // THE MACHINE THESE PAGES ARE ABOUT, dim, and nothing at all on a local + // session: it is invisible when there is nothing to say (host.go). It is + // `on spark` rather than a bare `spark` so it cannot read as a place. + host = pal.dim(placeMachineLead + name) + } + rung := func(parts ...string) string { + out := "" + for _, part := range parts { + if part == "" { + continue + } + if out != "" { + out += pulseGap + } + out += part + } + return out + } + return [7]string{ + rung(p.wants, p.hands, p.money, host, p.clock), + rung(p.wants, p.hands, p.money, host), + rung(p.wants, p.hands, p.money), + rung(p.wants, p.money), + rung(p.ask, p.money), + rung(p.ask, p.spend), + rung(p.ask), + } +} + +// navPaint draws the row with `folded` behind `more ▾` and `tail` on the far +// end, and records where every button landed. +func (a *app) navPaint(width int, pal palette, name string, lead int, shown, folded []page, tail string) string { + var b strings.Builder + b.WriteString(name) + b.WriteString(strings.Repeat(" ", navLead)) + at := lead + lit := a.navLit() + isFolded := func(id page) bool { + for _, f := range folded { + if f == id { + return true + } + } + return false + } + for _, id := range shown { + if isFolded(id) { + continue + } + word := a.barChipWord(id, a.mapShowing) + w := ansi.StringWidth(word) + tabPadCols + b.WriteString(a.navChipPaint(pal, id, word, id == lit)) + // A BUTTON THE FRAME'S EDGE CUT IS NOT A TARGET: a press resolves + // against what was drawn, and half a word is not a door. + if at+w <= width { + a.tabs = append(a.tabs, placeTabSpan{id: id, from: at, to: at + w}) + } + at += w + } + if len(folded) > 0 { + word := a.navMoreWord(pal) + w := ansi.StringWidth(word) + tabPadCols + b.WriteString(a.navMorePaint(pal, word)) + if at+w <= width { + a.navMore.span = hudSpan{from: at, to: at + w} + a.navMore.folded = append(a.navMore.folded, folded...) + } + at += w + } + line := b.String() + if tail != "" { + line += strings.Repeat(" ", max(width-at-ansi.StringWidth(tail)-navInset, navTailGap)) + tail + strings.Repeat(" ", navInset) + } + if ansi.StringWidth(line) > width { + return ansi.Truncate(line, width, "") + } + return line + strings.Repeat(" ", width-ansi.StringWidth(line)) +} + +// navChipPaint is one place's button: the cursor's band while the bar's +// cursor is on it, the pointer's ground under the pointer, the one accent on +// the place you are in, and muted otherwise. +func (a *app) navChipPaint(pal palette, id page, word string, lit bool) string { + chip := tabPad + word + tabPad + ink, hover := pal.muted, pal.ink + if lit { + ink = func(s string) string { return pal.bold(pal.accent(s)) } + hover = ink + } + switch { + case a.bar.on && id == a.bar.at: + // THE CURSOR'S OWN BAND, and it replaces the hover and the lit ink + // rather than stacking on them: while the cursor is up here the row + // is the one a person is standing on ([barCursor]). + return pal.cursor(pal.bold(pal.ink(chip)), 0) + case id == a.tabHover: + return a.navHoverPaint(pal, word, hover) + case lit && pal.profile == tokens.NoColor: + // WITH NO COLOUR TO LIGHT IT, the place you are in wears brackets in + // its pad cells, as the strip's tab in front does ([tabLabel]); the + // button is the same width either way. + return pal.bold("[" + word + "]") + } + return ink(chip) +} + +// navHoverPaint is a word button under the pointer: the strip's own hover +// ground ([app.tabHoverPaint]) over the pads and the word, and the linear mark +// in the leading pad where the terminal cannot show a ground. +func (a *app) navHoverPaint(pal palette, word string, ink func(string) string) string { + chip := tabPad + word + tabPad + if pal.profile < tokens.ANSI256 { + chip = a.linearMark("·", ".") + word + tabPad + } + if pal.linear { + return ink(chip) + } + return pal.background(ink(chip), 0, pal.ramp.mark) +} + +// navMorePaint is the fold's button: muted, on the pointer's ground under the +// pointer and while its menu is open, as the team chip is. +func (a *app) navMorePaint(pal palette, word string) string { + if a.navMore.hot || a.navMore.on { + return a.navHoverPaint(pal, word, pal.ink) + } + return pal.muted(tabPad + word + tabPad) +} + +// ── THE POINTER ───────────────────────────────────────────────────────────── + +// navAt is whether row y is the nav: the row the last frame drew it on, on a +// frame that still has one. A CONVERSATION UNDER THE STRIP'S FLOORS DRAWS NO +// HEAD AT ALL ([app.tabsHeight]), and its body starts on row zero; the same +// question [app.tabAt] asks of the strip keeps a press there from being read +// as a press on a nav that a taller frame drew a moment ago. +func (a *app) navAt(y int) bool { + if a.tabRow < 0 || y != a.tabRow { + return false + } + if a.pageShowing() || a.headCovers() { + return true + } + width, _ := a.size() + return a.tabsHeight(width) > 0 +} + +// navPress is a press on the nav's row: the place whose button it landed in, +// or the fold's menu. THE WHOLE ROW IS THE NAV'S, so a press in the air +// between two buttons, or on the wordmark or the pulse, stops here rather than +// falling through to whatever the page under it would make of row zero. +// +// PRESSING THE PLACE YOU ARE ALREADY IN DOES NOTHING. Going there is closing +// and reopening it, which throws away the filter somebody typed and the row +// they were standing on. The one exception is `chats` pressed over a page that +// covers the chats (the run's work tab): that is the way back to them. +func (a *app) navPress(x, y int) (tea.Cmd, bool) { + if !a.navAt(y) { + return nil, false + } + if a.navMore.span.holds(x) { + if a.navMore.on { + a.closeNavMore() + } else { + a.openNavMore() + } + return nil, true + } + for _, span := range a.tabs { + if x < span.from || x >= span.to { + continue + } + if a.headCovers() { + a.headUncover() + } + if span.id == a.navLit() { + return nil, true + } + return a.showPage(span.id), true + } + return nil, true +} + +// headCovers is whether a full-frame view that is not a place is drawn over +// the chats: the grid of open tabs, or the run's work tab. Both wear the head, +// and the nav's doors lead out of them. +func (a *app) headCovers() bool { return a.wall.on || a.workTabOn } + +// headUncover takes those views down, so the page a nav word opens is the page +// on screen. +func (a *app) headUncover() { + if a.wall.on { + a.closeWall() + } + if a.workTabOn { + a.workTabOn = false + a.closeTaskPlan() + a.chatTabBar = tabBar{} + } + a.touch() +} + +// navHover is the pointer over the nav's row: the button under it takes the +// pointer's ground and nothing else on the frame moves. It reports whether the +// pointer is on the row at all. +// +// THE POINTER LEAVING THE ROW IS NEWS TOO, and it is the half that is easy to +// forget: a word left lit after the hand moved away is a door that claims to be +// under a pointer that is somewhere else. +func (a *app) navHover(x, y int) bool { + if !a.navAt(y) { + a.barHover(pageNone) + a.navMoreHot(false) + return false + } + under := pageNone + for _, span := range a.tabs { + if x >= span.from && x < span.to { + under = span.id + break + } + } + a.barHover(under) + a.navMoreHot(a.navMore.span.holds(x)) + return true +} + +// headHover is the pointer over the head. On every page that is the nav. The +// strip is a chat's row, and the conversation's own hover ([app.setHover]) +// answers it there. It reports whether the pointer is on a row the head +// answers for. +func (a *app) headHover(x, y int) bool { + onNav := a.navHover(x, y) + if onNav && !a.pageShowing() { + // THE CONVERSATION'S OWN HOVER LETS GO of whatever it was on, a tab + // of the strip included, since the pointer is on neither. + a.setHover(x, y) + } + return onNav +} + +// ── THE HINT ──────────────────────────────────────────────────────────────── + +// headHint is the hint line's sentence while the pointer rests on a word of +// the head that is a door the key legend does not already name, and "" when it +// rests on none. It is `alt+2 teams · the teams you hand work to`: the key, +// the word, and what it opens. +// +// `chats` AND `▦ All` ARE TOLD APART HERE, because they sit one over the other +// and both are about conversations: `chats` is the place, every conversation +// one at a time, and `▦ All` is the grid of the tabs this window has open, +// all at once. +func (a *app) headHint() string { + switch { + case a.navMore.on: + return navMoreFootWords + case placeFor(a.tabHover) != nil: + return a.chords.say(placeChord(a.tabHover)+" "+a.tabHover.word()) + hintSegment + placeFor(a.tabHover).about() + case a.navMore.hot: + return "more · the places this row has no room for" + case a.hot.kind == hoverTab: + // THE STRIP'S DOORS SAY WHAT THEY SAY IN A CONVERSATION, in the one + // place those sentences are written (walldock.go's + // [app.dockHoverWords]): `▦ All`, the team chip, the manager's place. + return a.dockHoverWords() + } + return "" +} diff --git a/internal/tui3/topnav_test.go b/internal/tui3/topnav_test.go new file mode 100644 index 0000000000..b61923799a --- /dev/null +++ b/internal/tui3/topnav_test.go @@ -0,0 +1,456 @@ +package tui3 + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/Agent-Field/codeaf/internal/tui2/tokens" + "github.com/charmbracelet/x/ansi" +) + +// navPlaces is the nav's buttons alone, as a reader sees them: the cells from +// the first button's first cell to the last button's last, `more ▾` included, +// off the row [app.navLine] drew. The pulse at the row's end is not in it, so +// a test about the places is not a test about the clock. +func navPlaces(a *app, width int, numbered bool) string { + was := a.mapShowing + a.mapShowing = numbered + defer func() { a.mapShowing = was }() + line := a.navLine(width, a.pal) + if len(a.tabs) == 0 { + return "" + } + from, to := a.tabs[0].from, a.tabs[len(a.tabs)-1].to + if a.navMore.span.pressable() { + to = a.navMore.span.to + } + return strings.TrimSpace(plain(ansi.Cut(line, from, to))) +} + +// navWidths are the widths the head is pinned at: a split pane, the classic +// terminal, a laptop and a wide screen. +var navWidths = []int{60, 80, 110, 160} + +// navChat is a conversation with three tabs on its strip, a team shown and +// some money spent, the fixture every test here starts from. +func navChat(t *testing.T) *app { + t.Helper() + a, _, _, _ := trafficApp(t) + a.open = func(workspace, transcript string) (Conversation, error) { return Conversation{}, nil } + a.welcome.open = false + a.railAway = true + a.height = 30 + return a +} + +// headRowsOf is the frame's first rows, as a reader sees them. +func headRowsOf(a *app) []string { + n := placeHeadRows + 1 + if !a.pageShowing() { + n = chatHeadRows + 1 + } + rows := strings.Split(plain(frame(a)), "\n") + if len(rows) > n { + rows = rows[:n] + } + return rows +} + +// ROW ZERO IS THE SAME ON EVERY PAGE. A chat then draws the strip, the rule +// and a blank, and the body under those four rows. A place draws the rule and +// a blank and no strip, and the body starts on the next row. +func TestTheHeadIsTheSameFourRowsOnEveryPage(t *testing.T) { + for _, width := range navWidths { + a := navChat(t) + a.width = width + a.touch() + chat := headRowsOf(a) + chatNav := append([]placeTabSpan(nil), a.tabs...) + if a.tabRow != navRow || a.headHeight() != chatHeadRows { + t.Fatalf("at %d the chat's nav is on row %d and its head is %d rows", width, a.tabRow, a.headHeight()) + } + if !strings.Contains(chat[tabStripRow], "harbor") || !strings.HasPrefix(chat[2], "─") || strings.TrimSpace(chat[3]) != "" { + t.Fatalf("at %d the chat's head is not the nav, the strip, the rule and a blank:\n%s", width, strings.Join(chat, "\n")) + } + for _, to := range []page{pageHome, pageTeams, pageSpend} { + walkTo(t, a, to) + place := headRowsOf(a) + if a.tabRow != navRow || a.headHeight() != placeHeadRows { + t.Fatalf("at %d %s drew its nav on row %d and a %d-row head", width, to.word(), a.tabRow, a.headHeight()) + } + if place[navRow] != chat[navRow] { + t.Fatalf("at %d %s moved row zero:\nchat %q\nplace %q", width, to.word(), chat[navRow], place[navRow]) + } + if !strings.HasPrefix(place[1], "─") || strings.TrimSpace(place[2]) != "" || strings.Contains(place[1], "harbor") { + t.Fatalf("at %d %s drew a strip where the rule belongs:\n%s", width, to.word(), strings.Join(place, "\n")) + } + if len(a.chatTabHits) != 0 { + t.Fatalf("at %d %s kept %d strip targets for a row it did not draw", width, to.word(), len(a.chatTabHits)) + } + // AND THE WORDS STAND IN THE SAME CELLS: every button the chat drew + // is where the place drew it, wherever both drew one. + for _, c := range chatNav { + for _, p := range a.tabs { + if c.id == p.id && c != p { + t.Fatalf("at %d %q moved from %+v on the chat to %+v on %s", width, c.id.word(), c, p, to.word()) + } + } + } + a.showPage(pageNone) + } + if width == 80 || width == 110 { + t.Logf("the chat's head at %d:\n%s", width, strings.Join(chat, "\n")) + } + } +} + +// THE NAV LIGHTS WHERE YOU STAND, IN THE ONE ACCENT. The place on a place, and +// `chats` inside a conversation, since the strip under the nav is the chats. +// Every other word is muted, and exactly one is lit. +func TestTheNavLightsWhereYouStand(t *testing.T) { + a := navChat(t) + a.width = 160 + lit := func(id page) string { return a.pal.bold(a.pal.accent(tabPad + id.word() + tabPad)) } + line := a.navLine(a.width, a.pal) + if !strings.Contains(line, lit(pageChats)) { + t.Fatalf("inside a conversation `chats` is not lit: %q", line) + } + for _, to := range []page{pageHome, pageTeams, pageTasks, pageSpend, pageSettings} { + walkTo(t, a, to) + line := a.navLine(a.width, a.pal) + for _, id := range barPages(to, false) { + if got := strings.Contains(line, lit(id)); got != (id == to) { + t.Fatalf("standing in %s, %s is lit %v", to.word(), id.word(), got) + } + if id != to && !strings.Contains(line, a.pal.muted(tabPad+id.word()+tabPad)) { + t.Fatalf("standing in %s, %s is not muted", to.word(), id.word()) + } + } + } + // AND WITH NO COLOUR TO LIGHT IT, the place wears brackets in its pads, in + // the same cells. + a.pal = newPalette(tokens.NoColor, false) + walkTo(t, a, pageSpend) + if line := plain(a.navLine(a.width, a.pal)); !strings.Contains(line, "[spend]") { + t.Fatalf("a plain terminal cannot tell which place is lit: %q", line) + } +} + +// EVERY BUTTON'S HOVER GROUND IS ITS TARGET, PADS INCLUDED. Each cell of a +// word's button, its two pad cells too, puts that word under the pointer, the +// cell either side of it does not, and the ground drawn covers exactly those +// cells. On a plain terminal the pointer's word wears `·` in its leading pad. +func TestEveryNavButtonsHoverGroundIsItsTarget(t *testing.T) { + a := navChat(t) + for _, width := range navWidths { + a.width = width + for _, plainTerm := range []bool{false, true} { + a.pal = newPalette(tokens.TrueColor, false) + if plainTerm { + a.pal = newPalette(tokens.NoColor, false) + } + a.navMemo = navMemo{} + a.navLine(width, a.pal) + spans := append([]placeTabSpan(nil), a.tabs...) + if a.navMore.span.pressable() { + spans = append(spans, placeTabSpan{id: pageNone, from: a.navMore.span.from, to: a.navMore.span.to}) + } + for _, span := range spans { + for x := span.from - 1; x <= span.to; x++ { + a.navHover(x, navRow) + in := x >= span.from && x < span.to + under := a.tabHover == span.id && span.id != pageNone || span.id == pageNone && a.navMore.hot + if under != in { + t.Fatalf("at %d the pointer at %d is under %v %v, and the button is %d..%d", width, x, span.id.word(), under, span.from, span.to) + } + } + a.navHover(span.from, navRow) + line := a.navLine(width, a.pal) + word := strings.TrimSpace(plain(ansi.Cut(line, span.from, span.to))) + want := a.pal.background(a.pal.ink(tabPad+strings.TrimPrefix(word, "·")+tabPad), 0, a.pal.ramp.mark) + if plainTerm { + if got := plain(ansi.Cut(line, span.from, span.to)); !strings.HasPrefix(got, "·") { + t.Fatalf("at %d on a plain terminal %q has no pointer mark under the pointer", width, got) + } + } else if span.id != a.navLit() && !strings.Contains(line, want) { + t.Fatalf("at %d the ground under %q does not cover its pads", width, word) + } + a.navHover(-1, -1) + } + } + } +} + +// A PRESS ON EACH NAV WORD OPENS THAT PLACE, from a conversation and from a +// place, on any cell of its button; a press on the place you are already in +// does nothing at all; and none of it moves the draft or the caret. +func TestAPressOnEachNavWordOpensThatPlace(t *testing.T) { + a := navChat(t) + a.width = 160 + a.input.setText("half a sentence") + caret := a.input.cursor + frame(a) + for _, span := range append([]placeTabSpan(nil), a.tabs...) { + for _, x := range []int{span.from, span.to - 1} { + a.showPage(pageNone) + frame(a) + drive(t, a, tea.MouseClickMsg{X: x, Y: navRow, Button: tea.MouseLeft}) + switch { + case span.id == pageChats && a.pageShowing(): + t.Fatalf("a press on `chats` inside a conversation opened %s", a.page.word()) + case span.id != pageChats && !a.at(span.id): + t.Fatalf("a press at %d on %q left the router on %q", x, span.id.word(), a.page.word()) + } + if span.id != pageChats { + // AND FROM THE PLACE, `chats` IS THE WAY BACK. + frame(a) + for _, back := range a.tabs { + if back.id == pageChats { + drive(t, a, tea.MouseClickMsg{X: back.from, Y: navRow, Button: tea.MouseLeft}) + } + } + if a.pageShowing() { + t.Fatalf("`chats` on %s did not go back to the conversation", span.id.word()) + } + } + } + } + if a.input.String() != "half a sentence" || a.input.cursor != caret { + t.Fatalf("the nav moved the draft or its caret: %q at %d", a.input.String(), a.input.cursor) + } +} + +// A PRESS ON ROW 1 OF A PLACE IS THE PAGE'S. The strip is not drawn there, so +// the row under the nav is the rule, and a click on it does not open a chat. +// The page's own first row is the next one after the blank. +func TestAPressOnRowOneOfAPlaceIsThePages(t *testing.T) { + a := navChat(t) + a.width = 160 + front := a.frontTabKey() + for _, id := range placeOrder { + if id == pageChats { + continue + } + walkTo(t, a, id) + frame(a) + if len(a.chatTabHits) != 0 { + t.Fatalf("%s kept strip targets", id.word()) + } + if _, ok := a.tabAt(4, tabStripRow); ok { + t.Fatalf("%s still has a tab on row 1", id.word()) + } + rows := strings.Split(plain(frame(a)), "\n") + if len(rows) <= placeHeadRows || !strings.HasPrefix(rows[1], "─") { + t.Fatalf("%s row 1 is not the rule:\n%s", id.word(), strings.Join(rows[:placeHeadRows+1], "\n")) + } + drive(t, a, tea.MouseClickMsg{X: 4, Y: tabStripRow, Button: tea.MouseLeft}) + if !a.at(id) || a.frontTabKey() != front { + t.Fatalf("a press on row 1 of %s left %q with %q in front", id.word(), a.page.word(), a.frontTabKey()) + } + if line, ok := placeBodyLine(placeHeadRows, 0, 8); !ok || line != 0 { + t.Fatalf("%s body does not start at row %d", id.word(), placeHeadRows) + } + } +} + +// THE NAV FOLDS INTO `more ▾`, AND `more ▾` IS A DOOR. A press opens a menu of +// exactly the folded places; the pointer lights a row, a press on it goes +// there, `↓` and `enter` do the same from the keyboard, and `esc` puts it away +// with the page, the draft and the caret exactly where they were. +func TestTheMoreMenuOpensTheFoldedPlaces(t *testing.T) { + a := navChat(t) + a.width = 50 + a.input.setText("a draft") + frame(a) + more := a.navMore.span + folded := append([]page(nil), a.navMore.folded...) + if !more.pressable() || len(folded) == 0 { + t.Fatalf("at 50 columns nothing folded: %q", plain(a.navLine(50, a.pal))) + } + drive(t, a, tea.MouseClickMsg{X: more.from, Y: navRow, Button: tea.MouseLeft}) + if !a.navMore.on { + t.Fatal("a press on `more ▾` did not open its menu") + } + text := plain(frame(a)) + for _, id := range folded { + if !strings.Contains(text, id.word()) || !strings.Contains(text, placeChord(id)) { + t.Fatalf("the menu does not offer %q with its key:\n%s", id.word(), text) + } + } + drive(t, a, key("esc")) + if a.navMore.on || a.pageShowing() || a.input.String() != "a draft" { + t.Fatalf("esc did not put the menu away and leave everything else (page %q, draft %q)", a.page.word(), a.input.String()) + } + // The keyboard. + drive(t, a, tea.MouseClickMsg{X: more.from, Y: navRow, Button: tea.MouseLeft}) + frame(a) + if len(folded) > 1 { + drive(t, a, key("down")) + } + drive(t, a, key("enter")) + if want := folded[min(1, len(folded)-1)]; !a.at(want) || a.navMore.on { + t.Fatalf("enter in the menu landed on %q, want %q", a.page.word(), want.word()) + } + // The pointer. + a.showPage(pageNone) + frame(a) + drive(t, a, tea.MouseClickMsg{X: a.navMore.span.from, Y: navRow, Button: tea.MouseLeft}) + frame(a) + if len(a.navMore.hits) == 0 { + t.Fatal("the open menu drew no rows") + } + last := a.navMore.hits[len(a.navMore.hits)-1] + target := a.navMore.folded[last.arg] + drive(t, a, tea.MouseMotionMsg{X: last.x0, Y: last.y0}) + if a.navMore.hover != last.arg { + t.Fatalf("the pointer on a menu row lights %v", a.navMore.hover) + } + drive(t, a, tea.MouseClickMsg{X: last.x0, Y: last.y0, Button: tea.MouseLeft}) + if !a.at(target) { + t.Fatalf("a press on the menu's %q row landed on %q", target.word(), a.page.word()) + } + // AND A PRESS OFF IT ONLY PUTS IT AWAY. + frame(a) + if a.navMore.span.pressable() { + drive(t, a, tea.MouseClickMsg{X: a.navMore.span.from, Y: navRow, Button: tea.MouseLeft}) + was := a.page + drive(t, a, tea.MouseClickMsg{X: 1, Y: a.height - 1, Button: tea.MouseLeft}) + if a.navMore.on || a.page != was { + t.Fatal("a press off the menu did something besides putting it away") + } + } +} + +// EVERY NAV WORD SAYS WHAT IT OPENS AND ITS KEY while the pointer rests on it, +// on the hint line of a place and of a conversation. `chats` and `▦ All` say +// two different things: the place, and the grid of the tabs open here. +func TestEveryNavWordSaysWhatItOpens(t *testing.T) { + for _, id := range placeOrder { + if strings.TrimSpace(placeFor(id).about()) == "" { + t.Fatalf("%s has nothing to say on the hint line", id.word()) + } + } + a := navChat(t) + a.width = 160 + walkTo(t, a, pageSpend) + frame(a) + for _, span := range a.tabs { + a.navHover(span.from, navRow) + hint := a.placeHintSaid() + if !strings.Contains(hint, a.chords.say(placeChord(span.id))) || !strings.Contains(hint, placeFor(span.id).about()) { + t.Fatalf("hovering %q, the place's hint line reads %q", span.id.word(), hint) + } + } + a.navHover(-1, -1) + a.showPage(pageNone) + frame(a) + for _, span := range a.tabs { + if span.id != pageChats { + continue + } + a.navHover(span.from, navRow) + if hint := a.footHint(a.width); !strings.Contains(hint, placeFor(pageChats).about()) { + t.Fatalf("hovering `chats` in a conversation, the hint reads %q", hint) + } + } + a.navHover(-1, -1) + frame(a) + if !a.wall.door.pressable() { + t.Fatal("the strip drew no `▦ All`") + } + drive(t, a, tea.MouseMotionMsg{X: a.wall.door.from, Y: tabStripRow}) + all := a.footHint(a.width) + if !strings.Contains(all, "grid of your open tabs") || strings.Contains(all, placeFor(pageChats).about()) { + t.Fatalf("`▦ All` does not say it is the grid of open tabs: %q", all) + } +} + +// THE FOLD IS A WORD DOOR, NEVER A COUNT. The places' bar used to end a narrow +// row in `▸ 3`, a count nobody could press; `more ▾` is a word that opens the +// places it stands for, and its menu's caret is the one every menu here wears. +// Widening the window so `more ▾` is no longer drawn used to leave the hint +// on `more · the places this row has no room for` until the pointer moved. +// A resize drops that hover, and the nav word hover with it. +func TestAResizeDropsTheMoreHint(t *testing.T) { + a := navChat(t) + a.width, a.height = 48, 24 + navPlaces(a, 48, false) + if !a.navMore.span.pressable() { + t.Fatal("at 48 the nav drew no more") + } + a.navHover(a.navMore.span.from, navRow) + if hint := a.footHint(48); !strings.Contains(hint, "more · the places this row has no room for") { + t.Fatalf("hovering more, the hint reads %q", hint) + } + for _, span := range a.tabs { + if span.id == pageSettings { + a.navHover(span.from, navRow) + } + } + if a.tabHover != pageSettings && !a.navMore.hot { + t.Fatal("neither the nav word nor more is hovered") + } + a.navHover(a.navMore.span.from, navRow) + drive(t, a, tea.WindowSizeMsg{Width: 110, Height: 24}) + navPlaces(a, a.width, false) + if a.navMore.span.pressable() { + t.Fatal("at 110 more is still a door") + } + if hint := a.footHint(a.width); strings.Contains(hint, "more") { + t.Fatalf("after the resize the hint still says more: %q", hint) + } + if a.tabHover != pageNone || a.navMore.hot { + t.Fatalf("resize left hover: word %q more %v", a.tabHover.word(), a.navMore.hot) + } +} + +func TestTheNavsFoldIsAWordDoorNotACount(t *testing.T) { + a := placeApp(t) + for width := 30; width <= 200; width++ { + bar := navPlaces(a, width, false) + if strings.Contains(bar, tokens.GlyphCollapsed) || strings.Contains(bar, "+") { + t.Fatalf("at %d the nav's fold is a count: %q", width, bar) + } + if a.navMore.span.pressable() != strings.HasSuffix(bar, "more ▾") { + t.Fatalf("at %d the fold's word and its door disagree: %q", width, bar) + } + } +} + +// THE COUNT THAT WANTS YOU NEVER LEAVES THE ROW. At every width from a split +// pane to a wide screen the nav carries the number of things stopped on the +// person, in amber: `2 want you` where it fits and `2 ?` where it does not. +// And at eighty columns the short count costs no place: all six words stay. +func TestTheCountThatWantsYouNeverLeavesTheNav(t *testing.T) { + a := navChat(t) + a.machine = machineFacts{wants: 2, hands: 1, spent: 1.2, ceiling: 20} + long := a.pal.warn("2" + pulseWantWord) + short := a.pal.warn("2 " + tabSignalGlyph(tabNeedsPerson, a.pal.ascii)) + for width := 44; width <= 200; width++ { + a.width = width + a.navMemo = navMemo{} + line := a.navLine(width, a.pal) + if ansi.StringWidth(line) != width { + t.Fatalf("at %d the nav is %d wide", width, ansi.StringWidth(line)) + } + if !strings.Contains(line, long) && !strings.Contains(line, short) { + t.Fatalf("at %d the nav lost the count that wants you: %q", width, plain(line)) + } + } + a.width = 80 + a.navMemo = navMemo{} + row := plain(a.navLine(80, a.pal)) + if !placeWordsInOrder(row, "home", "teams", "chats", "sessions", "spend", "settings") || a.navMore.span.pressable() { + t.Fatalf("at 80 the short count cost a place: %q", row) + } + if !strings.HasSuffix(strings.TrimRight(row, " "), "2 ? · $1.20 / "+railFigure(20)) { + t.Fatalf("at 80 the pulse is not the short count and the allowance: %q", row) + } + // AND NOTHING WANTING YOU DRAWS NOTHING: no `0 ?`. + a.machine.wants = 0 + a.navMemo = navMemo{} + if row := plain(a.navLine(60, a.pal)); strings.Contains(row, "?") { + t.Fatalf("an empty count drew a mark: %q", row) + } +} diff --git a/internal/tui3/tui3.go b/internal/tui3/tui3.go index 3886960874..f0b6381813 100644 --- a/internal/tui3/tui3.go +++ b/internal/tui3/tui3.go @@ -1100,6 +1100,17 @@ type Options struct { // watch. Nothing half-works and nothing claims to. Standing StandingSeam + // Teams is where the teams file and the Traffic logs are: the profile of + // the machine the SESSION runs on, because the team tools a model calls + // keep them there ([TeamsSeam] says what each function owes). + // + // The zero value is this machine's own profile ([Options.ProfileDir]), + // which is every local launch. The --host door hands one that asks the + // engine; over --host with no seam (an engine without the teams doors) the + // window keeps no teams at all rather than keeping them here, where the far + // session would never read them (host.go). + Teams TeamsSeam + // Link is what the door can tell this surface about the connection the // conversation is on the far end of: the sentence to draw while a dropped // link is being redialled, the empty round trip to measure on a slow clock, diff --git a/internal/tui3/unverified_test.go b/internal/tui3/unverified_test.go index 5530d00a3b..3bbabb6192 100644 --- a/internal/tui3/unverified_test.go +++ b/internal/tui3/unverified_test.go @@ -82,7 +82,9 @@ func TestAnUnverifiedLandingIsNeitherDoneNorFailed(t *testing.T) { t.Fatalf("an unverified node filed under %q, want %q", railGroupWords[group], railGroupWords[railAttention]) } - rail := plain(strings.Join(a.railRows(12), "\n")) + // The row, and the hint line over it, where the reason the row has no room + // for is said. + rail := plain(strings.Join(a.railRows(12), "\n")) + "\n" + railHint(a, 7) for _, want := range []string{ // The column leads with the STATE and nothing else — the card's identity // cell is not spent here (task.go's [app.railLead]). diff --git a/internal/tui3/view.go b/internal/tui3/view.go index c93551424b..c8f69ced81 100644 --- a/internal/tui3/view.go +++ b/internal/tui3/view.go @@ -267,6 +267,21 @@ func (a *app) View() tea.View { // is the one somebody reaches for — fails rather than quietly costing a frame. func (a *app) frame() (string, int, int) { body, caretX, caretY := a.frameBody() + // A tile just opened from the wall frames the conversation's first few + // pictures as it grows into the frame (wall.go); a string compare when not. + body = a.wallZoomed(body) + // The strip's team switcher hangs over whatever page is drawn under it + // (teammenu.go); the frame as it was when it is down. + body = a.teamMenuOver(body) + // And the nav's fold menu hangs under `more ▾` on the same terms + // (navmore.go). + body = a.navMoreOver(body) + // The teams page's members card hangs over its pane (teamcrew.go), a + // team's card (teamsheet.go) over whatever is drawn under it, and the move + // picker (teammove.go) over both, since the card opens it. + body = a.teamCrewOver(body) + body = a.teamSheetOver(body) + body = a.teamMoveOver(body) return norm.NFC.String(body), caretX, caretY } @@ -274,6 +289,14 @@ func (a *app) frame() (string, int, int) { // one composition pass [app.frame] puts over the whole of it. func (a *app) frameBody() (string, int, int) { a.inlineWaitShowing = false + // AND THERE IS NO NAV UNTIL A FRAME DRAWS ONE. Every frame with a head goes + // through [app.headRows], which records the row it put the nav on; the + // frames that do not (home's phone inbox and sheet, the task record card, a + // conversation under the strip's floors) draw something else in those cells + // entirely, and a press resolved against the last nav this window happened + // to paint would open a place for a click on a rule (topnav.go's + // [app.navPress]). + a.tabRow = -1 width, height := a.size() if a.pasteEdit.open { return a.pasteEditorFrame(width, height) @@ -286,17 +309,13 @@ func (a *app) frameBody() (string, int, int) { lines, caretX, caretY := a.taskPlanFrame(width, height) return strings.Join(lines, "\n"), caretX, caretY } + if a.wall.on { + return strings.Join(a.wallFrame(width, height), "\n"), 0, 0 + } if a.workTabOn { lines := a.workTabFrame(width, height) return strings.Join(lines, "\n"), 2, max(len(lines)-1, 0) } - // AND THERE IS NO TAB BAR UNTIL A FRAME DRAWS ONE. Every place goes through - // [placeFrame], which records the row it put the bar on; the frames that do - // not — home's phone inbox and sheet, the task record card — draw something - // else in those cells entirely, and a press resolved against the last bar - // this window happened to paint would open a place for a click on a rule - // (placemouse.go's [app.placeTabPress]). - a.tabRow = -1 // THE FIRST-RUN SETUP IS DECIDED BEFORE EVERY OTHER FULLSCREEN SURFACE, // because it is the one that may be open before any of them exists and it // goes away to reveal whichever of them was decided underneath (firstrun.go). @@ -328,7 +347,7 @@ func (a *app) frameBody() (string, int, int) { // with a refusal under a box that should never have been on the page. // // IT IS UNDER THE PLACES because a place is a room in the machine and this is - // one job in one conversation; alt+1…7 leaves it, and [app.standDownRest] + // one job in one conversation; alt+1…9 leaves it, and [app.standDownRest] // closes it on the way out so it cannot reappear under a place somebody has // since walked away from. // @@ -442,7 +461,13 @@ func (a *app) chatFrameLines(width, height int) ([]string, int, int) { // conversation that is and which others this window can go back to // (chattabs.go). They are two rows because they are two questions — the one // that used to carry both carried neither well. - tabs := a.tabsRow(width) + // THE STRIP IS LAID OUT ONLY WHILE A CONVERSATION IS IN FRONT. The teams + // page's hosted pane is drawn through here with the page set aside, and + // that pane wears the place's head, which has no strip (head.go). + tabs := "" + if a.stripInHead() { + tabs = a.tabsRow(width) + } head := a.roomHeadRows(width) // AND THE TASK STRIP IS THE ROW UNDER IT, for the same reason and at the same // width: what is running is a fact about the SESSION, not about the @@ -459,15 +484,17 @@ func (a *app) chatFrameLines(width, height int) ([]string, int, int) { // the whole window rather than about the transcript (task.go). rows := make([]string, 0, height) - if tabs != "" { - // THE HEAD IS THE PLACES' HEAD — the pulse, the strip, the rule and the - // blank — drawn by the one function both frames call (head.go), and a - // room lays its trail under the blank (chattabs.go's - // [app.headSealHeight]). The prefix is cut at exactly the count - // [app.headHeight] charges, so the rows the frame draws and the rows the - // scrolling subtracts are the same rows by construction. - head := a.headRows(width, tabs, a.pal) - rows = append(rows, head[:a.tabsHeight(width)+a.headSealHeight(width)]...) + if n := a.tabsHeight(width) + a.headSealHeight(width); n > 0 { + // THE HEAD IS DRAWN BY THE ONE FUNCTION BOTH FRAMES CALL (head.go): + // the nav, the strip while a conversation is in front, the rule and + // the blank. A room lays its trail under the blank. The prefix is cut + // at exactly the count [app.headHeight] charges, so the rows the frame + // draws and the rows the scrolling subtracts are the same rows. + drawn := a.headRows(width, tabs, a.pal) + if n > len(drawn) { + n = len(drawn) + } + rows = append(rows, drawn[:n]...) } if len(head) > 0 { rows = append(rows, head...) @@ -480,6 +507,12 @@ func (a *app) chatFrameLines(width, height int) ([]string, int, int) { rows = append(rows, a.roomKinRows(width)...) } rows = append(rows, strip...) + // AND THE TEAMS PAGE'S OWN ROWS, while it hosts this conversation: the team's + // header, members and inbox, pinned under the strip and charged in + // [app.topHeight] on the same terms (teamspagehost.go). + if a.teamsHosting() { + rows = append(rows, a.teamsHostTop(width)...) + } // THE ROSTER TAKES THE BODY WHOLE on a frame with no columns to lend it: the // same rows, the same folds, the same footer, laid out at the full width // instead of squeezed into thirty columns that are not there (task.go's @@ -1022,6 +1055,11 @@ func (a *app) rule(width int) string { // nothing at all. func (a *app) size() (int, int) { width, height := a.width, a.height + // THE TEAMS PAGE LENDS ITS MANAGER A RECTANGLE (teamspagehost.go): while the + // pane hosts the conversation, the conversation's width is the terminal's + // less the rail, so every layout and hit test it makes resolves against the + // cells it is really drawn in. + width -= a.teamsHostRail() if width < 8 { width = 8 } @@ -1103,7 +1141,10 @@ func (a *app) bodyRows(width, height int) ([]row, int) { if a.roomOpen() { return a.roomWindow(width, height) } - return a.window(width, height) + // A MESSAGE SOMEBODY WAS JUST TAKEN TO IS LIFTED for a moment + // (teamjump.go). The draw only: the pointer resolves through window. + rows, pad := a.window(width, height) + return a.trafficLandRows(rows, width), pad } // bodyTop is the screen row the conversation starts on, or -1 when the frame is @@ -1227,7 +1268,9 @@ func (a *app) startPageBody() int { // is resolved through them — three questions that must never be able to disagree // about where the body starts. Neither of the two may ask [app.viewHeight] back, // which is why both answer from the terminal's size alone. -func (a *app) topHeight() int { return a.headHeight() + a.stripHeight() } +func (a *app) topHeight() int { + return a.headHeight() + a.stripHeight() + a.teamsHostTopHeight() +} // headHeight is what the pinned focus header costs the body region: one row // while a room is open on a frame with the height to spare, the kin rows under @@ -1237,11 +1280,9 @@ func (a *app) topHeight() int { return a.headHeight() + a.stripHeight() } // through, rather than at the frame — a header the frame drew and the scrolling // did not know about would put the room's last row under the input box. func (a *app) headHeight() int { - // THE PULSE AND THE TAB STRIP ARE THE FIRST OF THOSE ROWS AND ARE CHARGED - // FOR HERE, on the strip's own two floors (chattabs.go's [app.tabsHeight]): - // they are drawn over the conversation and over every page inside it, - // because which conversation this is stays true wherever you have walked to - // inside one. + // THE NAV, AND THE STRIP WHILE A CONVERSATION IS IN FRONT, ARE THE FIRST + // OF THOSE ROWS AND ARE CHARGED FOR HERE (chattabs.go's [app.tabsHeight]). + // On a place the strip is not drawn, so the page starts one row higher. // // AND THE SEAM UNDER THE STRIP — the rule and the blank that are the head's // last two rows on every frame, a room's included — which is what closes the @@ -1410,6 +1451,11 @@ func (a *app) resized(width, height int) tea.Cmd { return nil } a.width, a.height = width, height + // A hover names a door the last layout drew. The new width may not draw + // it: `more ▾` leaves the row once the places fit, and a nav word may + // fold. The hint reads the hover, not the row, so leaving it would keep + // naming a door that is gone until the pointer moved. + a.dropResizeHover() a.touch() if a.rows == nil { a.clampScroll() diff --git a/internal/tui3/wall.go b/internal/tui3/wall.go new file mode 100644 index 0000000000..630ac00b73 --- /dev/null +++ b/internal/tui3/wall.go @@ -0,0 +1,1689 @@ +package tui3 + +import ( + "context" + "errors" + "math/rand/v2" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── THE WALL'S WIRING: KEYS, FRAME, POINTER AND STRIP ─────────────────────── +// +// This is the only file of the wall that touches the app. The reading +// (walltail.go), the painting (wallview.go) and the teams (teams.go) meet +// here through the shapes in wallcontract.go. +// +// THE WALL'S DOORS ARE THE STRIP'S DOORS. Enter on a tile is [app.tabGo] and x +// is [app.tabDismiss], so a tile can never do something its tab would not: a +// held conversation is attached, a remembered one is opened, and closing a +// tile takes a view off this window and never ends work. + +// THE KEY MAP, and the press that does the same thing. Every button is a key +// and every act a key does is a press somewhere, except the few that are pure +// navigation or have no control to hang from (marked "key only"). +// +// alt+v open or close the wall ▦ in the dock, ▦ All on the strip +// esc, q back one layer: popover, card, help, selection, +// filter, wall ‹ Back, a press off a card +// ? what you can do here Help ? +// arrows, hjkl move the focus (key only; hover never moves it) +// home g, end G first and last tile (key only) +// pgup, pgdown a screen of rows the wheel, one row a notch +// n next waiting on a person the title's needs-you count +// enter open the focused tile a press on any tile, or Open +// space pick the focused tile Select; any tile once one is picked +// x close its view, or the picked' Close on a tile, Close views +// m its teams, or the picked' Teams on a tile, Add to… +// s new team of the picked + New team, Make team +// e the shown team's card a segment's dot or ⋯ +// r resume the shown team's the title's Open them +// members not open here +// tab, shift+tab next or previous team a Teams segment +// 1 to 9 that team, again for All a Teams segment +// D close the shown team Close… on its card +// o suggest teams, on All ✦ Organize on the Teams row +// u undo the last Organize Undo, while the Teams row offers it +// / filter Filter / +// -, + or = fewer or more columns Columns − + +// 0 columns back to automatic (key only) +// +// Every row of the help sheet (wallhelp.go) is a press too, and does what its +// key does. +// +// A PRESS ON A TILE OPENS IT, as a window's thumbnail does in any overview: +// one press, not a press to aim and another to go. Once any tile is picked a +// press toggles instead, as a photo grid does in its selection mode. The +// pointer resting on a tile lights it and turns its bottom border into its +// action row, and changes nothing else; the keyboard's focus is its own and +// only the keys move it. +// +// THE MOTION IS SMALL AND NEVER HOLDS A KEY. The tiles come in row by row as +// the wall opens (about 140ms in all), and an opened tile's rectangle grows +// into the frame over three frames while the conversation is already live +// behind it. Both run on the paint clock, both are cut short by any key or +// press, and neither is drawn on the linear or ASCII tiers or over a remote +// link, where a few frames of movement is a stutter rather than a gesture. +// Hover is instant, as it is everywhere in a terminal, and esc is instant. + +// wallOpenKey opens and closes the wall. alt+g is home's regroup and alt+1..7 +// are the places, so the wall takes v, for view. Option+v composes to `√` on a +// Mac keyboard that is not sending alt, and the wall answers that as well. +const ( + wallOpenKey = "alt+v" + wallOpenDead = "√" +) + +func wallOpenPressed(msg tea.KeyPressMsg) bool { + s := msg.String() + return s == wallOpenKey || s == wallOpenDead +} + +// openWall stands the wall up and asks for every tile's tail OFF THE LOOP. The +// first frame draws whatever the cache already holds; the readings land a +// moment later and the tiles fill in. +func (a *app) openWall() tea.Cmd { + a.teamsEnsure() + now := a.now() + a.wall.on = true + a.wall.openedAt = now + a.wall.naming, a.wall.filterOn = false, false + a.wall.places = nil + a.wall.zoomAt = time.Time{} + a.wall.ptrIn, a.wall.rehover = false, false + if a.wall.marked == nil { + a.wall.marked = map[string]bool{} + } + tiles := a.wallShown(now) + a.wall.focus = 0 + keys := make([]string, 0, len(tiles)) + for i, tile := range tiles { + if tile.here { + a.wall.focus = i + } + keys = append(keys, tile.tab.key) + } + // The conversation in front is focused AND on screen from the first frame, + // so the eye lands where the keys are. + a.wall.scroll = 0 + a.wallMove(a.wall.focus, len(tiles)) + a.wall.revealAt = time.Time{} + if a.wallMotionOK() && len(tiles) > 0 { + a.wall.revealAt = now + } + a.touch() + var tick tea.Cmd + if !a.wall.ticking { + tick = a.wallTick() + } + return tea.Batch(a.wallReadCmd(keys...), tick, a.wake()) +} + +func (a *app) closeWall() { + a.wall.on = false + a.wall.naming, a.wall.filterOn = false, false + a.wall.hover = wallHitRef{} + a.wall.pop = wallPop{} + a.wall.revealAt = time.Time{} + a.wall.card = wallRect{} + a.wall.spinning = false + a.wall.help = false + if a.wall.org.on { + a.wallOrganizeClose() + } + a.touch() +} + +// wallShown is the tiles the wall draws: every conversation open in this +// window, narrowed to the active team's members when one is active. A member +// this window does not have open is not a tile; the title counts it and +// offers to resume it ([app.wallResumeAway]). +func (a *app) wallShown(now time.Time) []wallTile { + tiles := a.wallTiles(now) + sp, ok := a.teamActive() + if !ok { + return tiles + } + in := make(map[string]bool, len(sp.Members)) + for _, m := range sp.Members { + in[m.Key] = true + } + kept := tiles[:0] + for _, tile := range tiles { + if in[tile.tab.key] { + kept = append(kept, tile) + } + } + // THE MANAGER'S TILE IS PINNED FIRST, as its tab is the strip's first + // place, and wears the manager's mark (teammanager.go). + for i, tile := range kept { + if sp.Manager == "" || tile.tab.key != sp.Manager { + continue + } + tile.manager = true + copy(kept[1:i+1], kept[:i]) + kept[0] = tile + break + } + return kept +} + +// wallHead is the rows above the grid: the same pulse, tab strip and rule +// every other full-frame surface draws, so the wall reads as a place in this +// window and not a program of its own. +func (a *app) wallHead(width int) []string { + return a.headRows(width, a.tabsRow(width), a.pal) +} + +func (a *app) wallFrame(width, height int) []string { + a.caret = false + head := a.wallHead(width) + a.wall.headRows = len(head) + room := height - len(head) + if room < 1 { + return head[:height] + } + now := a.now() + tiles := a.wallShown(now) + if a.wall.focus >= len(tiles) { + a.wall.focus = max(len(tiles)-1, 0) + } + a.wall.stirred = false + // The body is drawn with the chat's own pieces at the width the grid will + // give it (wallmini.go), kept per reading so a quiet frame redraws nothing. + cols, tileW, tileH := wallGrid(len(tiles), width, room, a.wall.cols) + // The scroll the painter will draw is the one kept, so the wheel steps + // from what is on screen and never from a number the frame overruled. + a.wall.scroll = wallScrollFor(a.wall.focus, a.wall.scroll, len(tiles), width, room, a.wall.cols) + a.wall.spinning = false + for i := range tiles { + tiles[i].marked = a.wall.marked[tiles[i].tab.key] + tiles[i].teams = a.teamsOf(tiles[i].tab.key) + tail := a.wall.tails[tiles[i].tab.key] + tiles[i].rows = a.wallMiniRows(tail, wallInnerW(tileW)) + if tail != nil { + tiles[i].doing = wallDoing(tail.recent, tiles[i].signal) + tiles[i].moved = tail.freshAt + } else { + tiles[i].doing = wallDoing(nil, tiles[i].signal) + } + if tiles[i].signal == tabWorking && tiles[i].live { + a.wall.spinning = true + } + } + reduced := a.wallReduced() + if reduced { + a.wall.spinning = false + } + view := wallView{ + tiles: tiles, + focus: a.wall.focus, + scroll: a.wall.scroll, + cols: a.wall.cols, + filter: a.wall.filter, + filtering: a.wall.filterOn, + naming: a.wall.naming, + name: a.wall.name, + nameFresh: a.wall.nameFresh, + asking: a.wall.nameAsking, + nameIn: a.teamNameOf(a.wall.nameParent), + made: a.wall.made, + madeN: a.wall.madeN, + madeAt: a.wall.madeAt, + hover: a.wall.hover, + choices: a.wall.choices, + choice: a.wall.choice, + pop: a.wall.pop, + spin: wallSpin(now), + now: now, + reduced: reduced, + pointerOn: a.wall.ptrIn, + pointerY: a.wall.ptrY - len(head), + help: a.wall.help, + helpTop: a.wall.helpTop, + doorHot: a.hot.kind == hoverTab && a.wall.door.pressable() && a.hot.index == a.wall.door.from, + } + if t, ok := a.teamActive(); ok { + view.team = t.ID + } + view.popManager, view.mark = a.wallPopManagerRow(), a.teamManagerMark() + if view.popManager != 0 { + if t, ok := a.teamActive(); ok && len(a.wall.pop.targets) == 1 { + view.popManagerWord = a.teamManagerMenuWord(t, a.wall.pop.targets[0]) + } + } + // The counts are of conversations open in this window, whatever a filter + // is hiding: a team's members this window has no tab for are still + // members, but they are not on the wall; the title counts them apart and + // offers to resume them ([app.wallResumeAway]). They are read off the + // strip's list, not a second build of every tile. + open := map[string]bool{} + tabs := a.tabList() + for _, tab := range tabs { + if !tab.start && !tab.work { + open[tab.key] = true + } + } + view.org = a.wallOrganizeFrame(tiles, tabs) + view.total = len(open) + for _, t := range a.wallTeams() { + n := 0 + for _, m := range t.Members { + if open[m.Key] { + n++ + } + } + view.teams = append(view.teams, wallTeamRow{id: t.ID, name: a.wallTeamLabel(t), hue: t.HueSpec(), count: n, members: len(t.Members)}) + } + if t, ok := a.teamActive(); ok { + view.away = len(a.teamAway(t, tabs)) + } + rows, hits := renderWall(a.pal, view, width, room) + // A scroll moved the tiles under a pointer that did not move: the target + // under it now is lit, as a page lights the link that scrolled under the + // cursor. It costs a second paint only on the frame after a scroll. + if a.wall.rehover { + a.wall.rehover = false + if a.wall.ptrIn { + if ref := wallHitIn(hits, a.wall.ptrX, a.wall.ptrY-len(head)); ref != view.hover { + a.wall.hover, view.hover = ref, ref + rows, hits = renderWall(a.pal, view, width, room) + } + } + } + a.wall.card = a.wallCardRect(view, width, room, len(head)) + a.wallRevealMask(rows, hits, len(tiles), cols, tileH, room, width, now) + for i := range hits { + hits[i].y0 += len(head) + hits[i].y1 += len(head) + } + a.wall.hits = hits + return append(head, rows...) +} + +// wallGeometry is the room the grid has, for moving the focus by a row. The +// head's height is the last frame's when there was one, so a key does not lay +// the tab strip out a second time to learn a number the frame already knew. +func (a *app) wallGeometry(n int) (cols, room int) { + width, height := a.size() + head := a.wall.headRows + if head <= 0 { + head = len(a.wallHead(width)) + } + room = height - head + cols, _, _ = wallGrid(n, width, room, a.wall.cols) + return max(cols, 1), room +} + +// wallRowsOnScreen is how many tile rows the grid shows at once, never under +// one. +func (a *app) wallRowsOnScreen(n int) int { + width, _ := a.size() + _, room := a.wallGeometry(n) + _, _, tileH := wallGrid(n, width, room, a.wall.cols) + return max(wallVisibleRows(room, tileH), 1) +} + +func (a *app) wallMove(to, n int) { + if n == 0 { + a.wall.focus = 0 + return + } + a.wall.focus = min(max(to, 0), n-1) + width, _ := a.size() + cols, room := a.wallGeometry(n) + a.wall.scroll = wallScrollFor(a.wall.focus, a.wall.scroll, n, width, room, cols) +} + +func (a *app) wallKey(msg tea.KeyPressMsg) tea.Cmd { + // A key finishes whatever is still moving before it does anything, so no + // key ever lands on a picture that is not yet the whole wall. + a.wallSettle() + key := msg.String() + tiles := a.wallShown(a.now()) + + if a.wall.pop.kind != wallPopNone { + return a.wallPopKey(msg, tiles) + } + if a.wall.help { + if cmd, took := a.wallHelpKey(key); took { + return cmd + } + } + if a.wall.naming { + switch key { + case "esc": + a.wall.naming = false + case "enter": + return a.wallMakeTeam(tiles) + case "ctrl+r": + a.wallShuffleName(tiles) + case "left", "right": + if c := len(a.wall.choices); c > 0 { + step := 1 + if key == "left" { + step = c - 1 + } + a.wall.choice = (a.wall.choice + step) % c + } + case "backspace": + a.wall.name = dropLastRune(a.wall.name) + a.wall.nameFresh, a.wall.nameAsking = false, false + default: + if t := msg.Key().Text; t != "" { + // A name the wall filled in is selected: the first key typed + // replaces it, as it would in any text field. The name being + // asked for is no longer wanted: the person is naming it. + if a.wall.nameFresh { + a.wall.name = "" + } + a.wall.name += t + a.wall.nameFresh, a.wall.nameAsking = false, false + } + } + return nil + } + if a.wall.org.on { + return a.wallOrganizeKey(key) + } + if a.wall.filterOn { + switch key { + case "esc": + a.wallClearFilter(tiles) + return nil + case "enter": + // The typing is put down and the focus stays on the match it was + // on, the first unless the arrows moved it, so a second enter opens it. + a.wall.filterOn = false + return nil + case "left", "right", "up", "down": + // The arrows walk the matches while the box stays up, as they do + // in any type-to-find list. + a.wall.filterOn = false + cmd := a.wallKey(msg) + a.wall.filterOn = true + return cmd + case "backspace": + a.wall.filter = dropLastRune(a.wall.filter) + default: + t := msg.Key().Text + if t == "" { + return nil + } + a.wall.filter += t + } + // What is typed changed the matches: the focus goes to the first. + a.wall.focus, a.wall.scroll = 0, 0 + return nil + } + if wallOpenPressed(msg) { + a.closeWall() + return nil + } + return a.wallCommand(key, tiles) +} + +// wallCommand is what one key does on the wall at rest, with no card, filter +// or popover taking the keyboard. The help sheet's rows press it too, so a row +// does exactly what its key does. +func (a *app) wallCommand(key string, tiles []wallTile) tea.Cmd { + n := len(tiles) + switch key { + case "esc", "q": + a.wallBack(tiles) + case "pgdown", "pgup": + step := a.wallRowsOnScreen(n) + if key == "pgup" { + step = -step + } + cols, _ := a.wallGeometry(n) + a.wallMove(min(max(a.wall.focus+step*cols, 0), n-1), n) + case "left", "h": + a.wallMove(a.wall.focus-1, n) + case "right", "l": + a.wallMove(a.wall.focus+1, n) + case "up", "k": + cols, _ := a.wallGeometry(n) + a.wallMove(a.wall.focus-cols, n) + case "down", "j": + cols, _ := a.wallGeometry(n) + a.wallMove(a.wall.focus+cols, n) + case "home", "g": + a.wallMove(0, n) + case "end", "G": + a.wallMove(n-1, n) + case "enter": + return a.wallOpen(tiles, a.wall.focus) + case "space": + a.wallToggle(tiles, a.wall.focus) + case "m": + // The picked conversations' teams, as the tray's Add to… opens them; + // with none picked, the focused one's, as a press on its Teams does. + if marked := a.wallMarkedTabs(tiles); len(marked) > 0 { + keys := make([]string, 0, len(marked)) + for _, tab := range marked { + keys = append(keys, tab.key) + } + a.wallOpenMembers(keys, a.wallAnchor(wallHitAction, int(wallActAddTo))) + } else if n > 0 { + a.wallOpenMembers([]string{tiles[a.wall.focus].tab.key}, a.wallAnchor(wallHitTeams, a.wall.focus)) + } + case "s": + return a.wallStartNaming(tiles) + case "x": + // The picked views, as the tray's Close views does; with none picked, + // the focused one's, as its Close does. + if len(a.wallMarkedTabs(tiles)) > 0 { + return a.wallCloseViews(tiles) + } + if n == 0 { + return nil + } + return a.wallDismissAt(tiles, a.wall.focus) + case "r": + // The shown team's members not open here, as the title's Open them. + return a.wallResumeAway() + case "e": + // The shown team's settings, where its dot or ⋯ opens them. + if id := a.wall.activeID; id != "" { + return a.teamSheetOpen(id, teamSheetSettings) + } + case "1", "2", "3", "4", "5", "6", "7", "8", "9": + // A team by its place on the Teams row; the digit of the team that + // is shown goes back to All, so the same key undoes itself. + i := int(key[0] - '1') + switch { + case i >= len(a.wallTeams()): + case a.wallTeams()[i].ID == a.wall.activeID: + a.wallSetTeam("") + default: + a.wallSetTeam(a.wallTeams()[i].ID) + } + case "/": + a.wall.filterOn = true + case "n": + a.wallNext(tiles) + case "?": + a.wallOpenHelp() + case "tab", "shift+tab": + a.wallCycleTeam(key == "tab") + case "-": + a.wallCols(-1, n) + case "=", "+": + a.wallCols(1, n) + case "0": + a.wall.cols = 0 + a.wallMove(a.wall.focus, n) + case "D": + // CLOSE the shown team (ruling c-9): at once with Undo when nothing + // in it runs, and the close card when something does. A team is + // deleted only from the teams page's Closed fold, once it is closed. + if id := a.wall.activeID; id != "" { + return a.teamsCloseAsk(id) + } + case "o": + return a.wallOrganizeOpen() + case "u": + a.wallOrganizeUndo() + } + return nil +} + +// wallBack is esc once the popover, the card and the help sheet are down: it +// takes off the innermost thing still on, the selection, then the filter, then +// the wall. +// The selection goes before the filter because it is the newer and the +// smaller of the two, and it may have been picked through the filter. +func (a *app) wallBack(tiles []wallTile) { + switch { + case len(a.wallMarkedTabs(tiles)) > 0: + a.wall.marked = map[string]bool{} + case a.wall.filter != "": + a.wallClearFilter(tiles) + default: + a.closeWall() + } +} + +// wallClearFilter takes the filter off and keeps the focus on the conversation +// it was on, now among all of them, so clearing a search is not losing your +// place. +func (a *app) wallClearFilter(tiles []wallTile) { + key := "" + if f := a.wall.focus; f >= 0 && f < len(tiles) { + key = tiles[f].tab.key + } + a.wall.filterOn, a.wall.filter = false, "" + a.wallFocusKey(key) +} + +// wallFocusKey moves the focus to the tile with key, scrolled into view, or +// to the first tile when it is not shown. +func (a *app) wallFocusKey(key string) { + tiles := a.wallShown(a.now()) + for i, tile := range tiles { + if tile.tab.key == key { + a.wallMove(i, len(tiles)) + return + } + } + a.wall.scroll = 0 + a.wallMove(0, len(tiles)) +} + +// wallOpen goes to tile i's conversation. The wall is down on the same +// message, so the conversation is live before the first frame of the zoom is +// drawn over it; the zoom only frames it (see [app.wallZoomed]). +func (a *app) wallOpen(tiles []wallTile, i int) tea.Cmd { + if i < 0 || i >= len(tiles) { + return nil + } + tab := tiles[i].tab + from, ok := a.wallTileRect(i) + a.closeWall() + if ok && a.wallMotionOK() { + a.wall.zoomFrom, a.wall.zoomAt = from, a.now() + return tea.Batch(a.tabGo(tab), a.wake()) + } + return a.tabGo(tab) +} + +// wallToggle marks tile i, or unmarks it. Any tile marked is the selection +// mode, and the last one unmarked leaves it. +func (a *app) wallToggle(tiles []wallTile, i int) { + if i < 0 || i >= len(tiles) { + return + } + k := tiles[i].tab.key + if a.wall.marked[k] { + delete(a.wall.marked, k) + } else { + a.wall.marked[k] = true + } +} + +func (a *app) wallNext(tiles []wallTile) { + n := len(tiles) + for step := 1; step <= n; step++ { + i := (a.wall.focus + step) % n + if tiles[i].signal == tabNeedsPerson { + a.wallMove(i, n) + return + } + } +} + +func (a *app) wallCols(by, n int) { + cols, _ := a.wallGeometry(n) + a.wall.cols = min(max(cols+by, 1), 6) + a.wallMove(a.wall.focus, n) +} + +// wallStartNaming opens the new-team card with a name already in it. Nothing +// marked names the focused tile alone, which is the one a person pressing s +// is looking at. +// +// THE NAME IS GIVEN ONCE, HERE, FROM WHAT THE CONVERSATIONS ARE. A shared +// project folder is the name, and nothing is asked. Otherwise a pleasant word +// is shown at once and one model call is asked for a better one off the loop +// ([app.wallAskName]); it replaces the word only if the person has not typed. +// After the card is saved nothing renames a team but the person. +func (a *app) wallStartNaming(tiles []wallTile) tea.Cmd { + marked := a.wallMarkedTabs(tiles) + if len(marked) == 0 && len(tiles) > 0 { + a.wall.marked[tiles[a.wall.focus].tab.key] = true + marked = a.wallMarkedTabs(tiles) + } + if len(marked) == 0 { + return nil + } + a.wall.naming = true + a.wall.filterOn = false + a.wall.pop = wallPop{} + a.wall.nameParent = "" + a.wall.name = teamFreshName(marked, a.teamNames(), "", rand.IntN) + a.wall.nameFresh = true + // The colours offered are the farthest from every team's, best first, + // and the best is taken until the person takes another. + a.wall.choices = teamHueChoices(a.teamHues(""), teamReservedHues(a.pal), wallSwatchCount) + a.wall.choice = 0 + return a.wallAskName(marked) +} + +// teamNamer is the door a team's suggested name comes through: the agent's +// own naming errand (internal/session's teamname.go), on the path and the +// cheap model conversations name themselves with. It is asserted rather than +// added to [Agent], as [namedAgent] is, so an agent without it is simply not +// asked. +type teamNamer interface { + NameTeam(ctx context.Context, titles []string) (string, error) +} + +// teamNameWait is the most a suggestion is waited for. Past it the word +// already in the card is the name and the suggestion is dropped. +const teamNameWait = 5 * time.Second + +// wallNameTimeMsg ends the wait for suggestion gen. +type wallNameTimeMsg struct{ gen int } + +// wallAskName asks the agent once, off the loop, for a name for marked, and +// says `naming…` in the card while it waits. It asks nothing when the +// conversations share a folder, whose name is already the right one, or when +// there is no agent that names. +func (a *app) wallAskName(marked []chatTab) tea.Cmd { + a.wall.nameGen++ + a.wall.nameAsking = false + if teamFolder(marked) != "" || a.agent == nil { + return nil + } + namer, ok := a.agent.(teamNamer) + if !ok { + return nil + } + var titles []string + for _, tab := range marked { + title := tab.full + if strings.TrimSpace(title) == "" { + title = tab.word + } + if title = strings.TrimSpace(title); title != "" { + titles = append(titles, title) + } + } + if len(titles) == 0 { + return nil + } + gen := a.wall.nameGen + a.wall.nameAsking = true + ask := a.besideLine(func() func(here bool) tea.Cmd { + ctx, cancel := context.WithTimeout(context.Background(), teamNameWait) + defer cancel() + name, err := namer.NameTeam(ctx, titles) + return func(bool) tea.Cmd { + a.wallTeamNamed(gen, name, err) + return nil + } + }) + wait := tea.Tick(teamNameWait, func(time.Time) tea.Msg { return wallNameTimeMsg{gen: gen} }) + return tea.Batch(ask, wait) +} + +// wallTeamNamed takes suggestion gen into the card, if it is still the one +// being waited for, the card is still up and the person has not typed. A +// failure, an empty answer or a name another team already has leaves the word +// that was there. +func (a *app) wallTeamNamed(gen int, name string, err error) { + if gen != a.wall.nameGen || !a.wall.nameAsking { + return + } + a.wall.nameAsking = false + a.touch() + if err != nil || !a.wall.naming || !a.wall.nameFresh { + return + } + name = ansi.Truncate(strings.TrimSpace(name), teamNameCells, "") + if name == "" { + return + } + for _, taken := range a.teamNames() { + if strings.EqualFold(taken, name) { + return + } + } + a.wall.name = name +} + +// wallNameTimedOut ends the wait for suggestion gen: the word in the card +// stays, and an answer that comes later is not used. +func (a *app) wallNameTimedOut(gen int) { + if gen == a.wall.nameGen && a.wall.nameAsking { + a.wall.nameAsking = false + a.touch() + } +} + +// wallSwatchCount is how many colours a card offers. +const wallSwatchCount = 6 + +// wallShuffleName puts another pleasant word in the card, never the one that +// is there and never one a team already has, and moves the colour to the next +// best one offered. +func (a *app) wallShuffleName(tiles []wallTile) { + a.wall.name = teamFreshName(a.wallMarkedTabs(tiles), a.teamNames(), a.wall.name, rand.IntN) + a.wall.nameFresh = true + // A shuffle is the person choosing: a suggestion still on its way is + // no longer wanted. + a.wall.nameGen++ + a.wall.nameAsking = false + if c := len(a.wall.choices); c > 0 { + a.wall.choice = (a.wall.choice + 1) % c + } +} + +func (a *app) wallMarkedTabs(tiles []wallTile) []chatTab { + var out []chatTab + for _, tile := range tiles { + if a.wall.marked[tile.tab.key] { + out = append(out, tile.tab) + } + } + return out +} + +func (a *app) wallMakeTeam(tiles []wallTile) tea.Cmd { + name := strings.TrimSpace(a.wall.name) + a.wall.naming = false + if name == "" { + return nil + } + a.teamsEnsure() + hue := nextTeamHue(a.teamHues(""), teamReservedHues(a.pal)) + if a.wall.choice >= 0 && a.wall.choice < len(a.wall.choices) { + hue = a.wall.choices[a.wall.choice] + } + parent := a.wall.nameParent + a.wall.nameParent = "" + id, err := a.teamMakeIn(name, a.wallMarkedTabs(tiles), hue, parent) + made, ok := a.teamByID(id) + if !ok { + return nil + } + if err != nil { + a.note("the team is kept for this window, but " + err.Error()) + } + // THE VIEW STAYS WHERE IT WAS. A person making a team is usually sorting + // several at once, and a wall that jumped into the new one would hide the + // conversations they were about to sort next. The chip row names the team + // and its chip is one press away. + a.wall.marked = map[string]bool{} + a.wall.made, a.wall.madeN, a.wall.madeAt = made.Name, len(made.Members), time.Now() + return nil +} + +// wallPlace is where one team's grid was left: the focused conversation, by +// key so a tile that moved is still found, and the row at the top. +type wallPlace struct { + key string + scroll int +} + +// wallSetTeam narrows the wall and the strip to team id, or widens them for +// "". Like the chips' cycling it never switches the conversation in front. +// +// EACH TEAM KEEPS ITS PLACE WHILE THE WALL IS UP. Looking into harbor and +// back to All returns to the tile and the row that were on screen, as a +// browser's tabs each keep their own scroll; a team not visited yet starts +// at its first tile. The places are kept by id, so a team deleted or moved +// takes its place with it and hands it to nobody. +func (a *app) wallSetTeam(id string) { + if teamIndex(a.wall.teams, id) < 0 { + id = "" + } + if id == a.wall.activeID { + return + } + if a.wall.places == nil { + a.wall.places = map[string]wallPlace{} + } + tiles := a.wallShown(a.now()) + if f := a.wall.focus; f >= 0 && f < len(tiles) { + a.wall.places[a.wall.activeID] = wallPlace{key: tiles[f].tab.key, scroll: a.wall.scroll} + } + a.wall.activeID = id + a.wall.hover = wallHitRef{} + a.wall.rehover = true + place, ok := a.wall.places[id] + if !ok { + a.wall.focus, a.wall.scroll = 0, 0 + return + } + a.wall.scroll = place.scroll + a.wallFocusKey(place.key) +} + +// wallDeleteTeam forgets team id. Its conversations stay open: a team is a +// view, and so is its going. +func (a *app) wallDeleteTeam(id string) { + if teamIndex(a.wall.teams, id) < 0 { + return + } + if err := a.teamDelete(id); err != nil { + a.note("the team is gone from this window, but " + err.Error()) + } + a.wall.hover = wallHitRef{} + a.wall.pop = wallPop{} +} + +// wallCycleTeam walks all → each team → all. It only narrows what the wall +// and the strip show; it never switches the conversation in front, so a person +// can look through their teams without leaving the one they are in. +func (a *app) wallCycleTeam(forward bool) { + shown := a.wallTeams() + n := len(shown) + if n == 0 { + return + } + at := teamIndex(shown, a.wall.activeID) // -1 is All + next := at + 1 + if !forward { + next = at - 1 + } + if next >= n { + next = -1 + } + if next < -1 { + next = n - 1 + } + if next < 0 { + a.wallSetTeam("") + return + } + a.wallSetTeam(shown[next].ID) +} + +// ── THE POINTER ───────────────────────────────────────────────────────────── +// +// Every target was written down by the painter as it drew (wallHit), and a +// press or a hover resolves against those cells and never against a second +// computation of the layout. + +// wallHitAt is the target under a pointer on the last frame. +func (a *app) wallHitAt(x, y int) (wallHit, bool) { + for _, hit := range a.wall.hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit, true + } + } + return wallHit{}, false +} + +// wallMotion answers the pointer moving while the wall is up. Over the head +// rows it is the strip's hover, as it is everywhere; over the wall it is the +// wall's, and the frame is repainted only when the target under it changed. +// +// A POINTER MOVING INSIDE ONE TARGET DRAWS NOTHING. The hover is a target and +// not a cell, so a hand wandering across a tile's body changes nothing the +// frame reads, and the frame Bubble Tea is about to ask for is the one it was +// given last time (coalesce.go's still). Only a motion on a message that +// changed nothing else may say so: a wheel folded into the same message has +// moved the grid (stirred). +// +// ONE TARGET CAN SPAN TWO ROWS' MEANINGS: a waiting tile's Answer and its +// row's Answer share one ref, as a picked tile's ☐ and its row's Select do, +// and the painter lights the one on the pointer's row (wallView.pointerY), so +// on those targets a change of row is a change. +func (a *app) wallMotion(x, y int) { + rowMoved := y != a.wall.ptrY + a.wall.ptrX, a.wall.ptrY, a.wall.ptrIn = x, y, y >= a.wall.headRows + if y < a.wall.headRows { + a.wallSetHover(wallHitRef{}) + // The nav is on the head's first row here as on every page + // (topnav.go). + a.navHover(x, y) + a.setHover(x, y) + return + } + a.navHover(x, y) + if a.hot != (hoverAt{}) { + a.hot = hoverAt{} + a.touch() + a.wall.stirred = true + } + hit, _ := a.wallHitAt(x, y) + if a.wall.hover == hit.ref() && (hit.kind == wallHitOpen || hit.kind == wallHitSelect) && rowMoved { + a.wall.stirred = true + a.touch() + return + } + if a.wall.hover == hit.ref() && !a.wall.stirred { + a.ptr.still = true + return + } + a.wallSetHover(hit.ref()) +} + +// wallHitIn is the target under x,y among hits, the zero ref for none. +func wallHitIn(hits []wallHit, x, y int) wallHitRef { + for _, hit := range hits { + if x >= hit.x0 && x < hit.x1 && y >= hit.y0 && y < hit.y1 { + return hit.ref() + } + } + return wallHitRef{} +} + +func (a *app) wallSetHover(ref wallHitRef) { + if a.wall.hover == ref { + return + } + a.wall.hover = ref + a.touch() +} + +// wallPress answers a left press while the wall is up and reports whether it +// took it. A press on the head rows is the strip's: its scrolling and its × +// leave the wall up, and a tab closes the wall and lets the strip switch to it. +func (a *app) wallPress(x, y int) (tea.Cmd, bool) { + if y < a.wall.headRows { + if hit, ok := a.tabAt(x, y); ok { + switch hit.kind { + case tabTeam: + // The chip is the team switcher here as on every page. + a.openTeamMenu() + return nil, true + case tabWall: + // The strip's own door to this view closes it, as alt+v does. + a.closeWall() + return nil, true + case tabScrollLeft, tabScrollRight: + return nil, false + case tabClose: + if a.tabCloseAsks(hit.tab) { + a.closeWall() + } + return nil, false + } + } + a.closeWall() + return nil, false + } + a.wallSettle() + // A PRESS OFF A CARD PUTS THE CARD AWAY and does nothing else, as a menu + // or a sheet does anywhere: the popover, or the new-team or Organize card, + // which is the same as its Cancel. A press inside a card but on none of its + // controls is a press on the card, and does nothing. + if a.wall.card.w() > 0 && (a.wall.pop.kind != wallPopNone || a.wall.naming || a.wall.help || a.wall.org.on) { + if !a.wall.card.holds(x, y) { + a.wall.pop = wallPop{} + a.wall.naming = false + a.wall.help = false + if a.wall.org.on { + a.wallOrganizeClose() + } + a.wall.stirred = true + return nil, true + } + } + hit, ok := a.wallHitAt(x, y) + if !ok { + return nil, true + } + a.wall.stirred = true + return a.wallDo(hit), true +} + +// wallDo is what a press on one target does. Every button whose act has a key +// does what that key does, by calling the same function. +func (a *app) wallDo(hit wallHit) tea.Cmd { + tiles := a.wallShown(a.now()) + n := len(tiles) + // While a team is being named the card is modal: only its own buttons + // answer, as only its own keys do. + if a.wall.naming { + switch { + case hit.kind == wallHitSwatch: + if hit.arg < len(a.wall.choices) { + a.wall.choice = hit.arg + } + case hit.kind == wallHitAction && (hit.arg == int(wallActSave) || hit.arg == int(wallActCancel) || hit.arg == int(wallActShuffle)): + return a.wallAct(wallAct(hit.arg), tiles) + } + return nil + } + // The Organize card is modal as the new-team card is. + if a.wall.org.on { + return a.wallOrganizePress(hit) + } + // The help sheet answers only its own rows, as a menu does. + if a.wall.help { + if hit.kind == wallHitHelp { + return a.wallHelpPress(hit.arg, tiles) + } + return nil + } + // A popover is dismissed by a press anywhere off it, and that press does + // nothing else, as a menu's is. + if a.wall.pop.kind != wallPopNone { + if hit.kind != wallHitPopRow && hit.kind != wallHitSwatch { + a.wall.pop = wallPop{} + return nil + } + return a.wallPopPress(hit, tiles) + } + // A press anywhere but the filter's own words puts the typing down and + // keeps what was typed, as enter does. + if hit.kind != wallHitAction || (hit.arg != int(wallActFilter) && hit.arg != int(wallActFilterClear)) { + a.wall.filterOn = false + } + switch hit.kind { + case wallHitTile: + switch { + case hit.arg >= n: + case len(a.wallMarkedTabs(tiles)) > 0: + // The selection mode: a press anywhere on a tile picks it, the way a + // photo grid does once one photo is picked. + a.wallToggle(tiles, hit.arg) + default: + // One press opens, as a thumbnail does in any overview. + return a.wallOpen(tiles, hit.arg) + } + case wallHitSelect: + a.wallToggle(tiles, hit.arg) + case wallHitTeams: + if hit.arg < n { + a.wallOpenMembers([]string{tiles[hit.arg].tab.key}, a.wallLocal(hit)) + } + case wallHitOpen: + return a.wallOpen(tiles, hit.arg) + case wallHitClose: + return a.wallDismissAt(tiles, hit.arg) + case wallHitChip: + a.wallSetTeam(hit.id) + case wallHitChipMenu: + // The team's card (teamsheet.go), over the wall. + return a.teamSheetOpen(hit.id, teamSheetSettings) + case wallHitAddTeam: + return a.wallStartNaming(tiles) + case wallHitMini: + a.wallMove(hit.arg, n) + case wallHitAction: + if wallAct(hit.arg) == wallActAddTo { + var keys []string + for _, tab := range a.wallMarkedTabs(tiles) { + keys = append(keys, tab.key) + } + a.wallOpenMembers(keys, a.wallLocal(hit)) + return nil + } + return a.wallAct(wallAct(hit.arg), tiles) + } + return nil +} + +func (a *app) wallAct(act wallAct, tiles []wallTile) tea.Cmd { + n := len(tiles) + switch act { + case wallActBack: + if n == 0 { + a.closeWall() + return nil + } + a.wallBack(tiles) + case wallActOpen: + return a.wallOpen(tiles, a.wall.focus) + case wallActSelect: + a.wallToggle(tiles, a.wall.focus) + case wallActNewTeam, wallActMakeTeam: + return a.wallStartNaming(tiles) + case wallActFilter: + a.wall.filterOn = true + case wallActFilterClear: + a.wallClearFilter(tiles) + case wallActNext: + a.wallNext(tiles) + case wallActColsLess: + a.wallCols(-1, n) + case wallActColsMore: + a.wallCols(1, n) + case wallActClose: + return a.wallDismissAt(tiles, a.wall.focus) + case wallActCloseViews: + return a.wallCloseViews(tiles) + case wallActClear: + a.wall.marked = map[string]bool{} + case wallActSave: + return a.wallMakeTeam(tiles) + case wallActCancel: + a.wall.naming = false + case wallActShuffle: + a.wallShuffleName(tiles) + case wallActHelp: + a.wallOpenHelp() + case wallActOrganize: + return a.wallOrganizeOpen() + case wallActOrgUndo: + a.wallOrganizeUndo() + case wallActOrgApply: + a.wallOrganizeApply() + case wallActOrgCancel: + a.wallOrganizeClose() + case wallActResume: + return a.wallResumeAway() + } + return nil +} + +// wallDismissAt is tile i's ×. A conversation with work in flight is asked +// about first (tabclose.go), and that card is drawn on the conversation's +// page, so the wall steps aside for it rather than hiding the question behind +// itself. +func (a *app) wallDismissAt(tiles []wallTile, i int) tea.Cmd { + if i < 0 || i >= len(tiles) { + return nil + } + tab := tiles[i].tab + if a.tabCloseAsks(tab) { + a.closeWall() + return a.tabDismiss(tab) + } + focused := a.wallFocusedKey(tiles) + cmd := a.tabDismiss(tab) + a.wallRefocus(tiles, focused) + return cmd +} + +// wallResumeAway is the title's `Open them` and r: every member of the shown +// team this window does not have open is resumed BEHIND, as the manager's +// starts are ([app.trafficStarted]), so each becomes a tab and a tile and +// nothing in front moves. The focus stays on the tile it was on. +// +// A member the keeper still holds but whose tab was closed only gets its tab +// back. The rest are opened through the door on the door line, off the loop, +// one after another, because opening one is a call to the engine; what comes +// back is stowed on the loop. Over a connection that holds one conversation at +// a time there is no behind to resume into, and the note says so. +func (a *app) wallResumeAway() tea.Cmd { + t, ok := a.teamActive() + if !ok { + return nil + } + away := a.teamAway(t, a.tabList()) + if len(away) == 0 { + return nil + } + focused := a.wallFocusedKey(a.wallShown(a.now())) + var closed []teamMember + for _, m := range away { + if a.behind[m.Key] != nil { + delete(a.tabShut, m.Key) + continue + } + if strings.TrimSpace(m.File) != "" { + closed = append(closed, m) + } + } + a.chatTabBar = tabBar{} + a.wallRefocusKey(focused) + if len(closed) == 0 { + return nil + } + switch { + case a.shared: + a.note("could not open the rest of " + t.Name + ": " + oneConversationWord) + return nil + case a.open == nil: + a.note("could not open the rest of " + t.Name + ": " + resumeUnavailableWord) + return nil + } + open, name := a.open, t.Name + return a.besideLine(func() func(bool) tea.Cmd { + convs := make([]Conversation, 0, len(closed)) + var refused []string + for _, m := range closed { + conv, err := open(m.Where, m.File) + switch { + case errors.Is(err, session.ErrSessionLocked): + refused = append(refused, teamMemberWord(m)+": "+sessionBusyWord) + case err != nil: + refused = append(refused, teamMemberWord(m)+": "+err.Error()) + case conv.Agent != nil: + convs = append(convs, conv) + } + } + return func(bool) tea.Cmd { return a.wallResumed(name, convs, refused) } + }) +} + +// wallResumed holds what [app.wallResumeAway] opened, behind, and says what +// did not open. +func (a *app) wallResumed(team string, convs []Conversation, refused []string) tea.Cmd { + focused := "" + if a.wall.on { + focused = a.wallFocusedKey(a.wallShown(a.now())) + } + var cmds []tea.Cmd + var keys []string + for _, conv := range convs { + key := a.convKey(conv.SessionFile) + cmds = append(cmds, a.stow(conv, nil)) + a.trafficBehindTop(key) + keys = append(keys, key) + } + a.chatTabBar = tabBar{} + if a.wall.on { + a.wallRefocusKey(focused) + cmds = append(cmds, a.wallReadCmd(keys...)) + } + if len(refused) > 0 { + a.note("could not open all of " + team + ": " + strings.Join(refused, "; ")) + } + a.touch() + return tea.Batch(cmds...) +} + +// wallRefocusKey keeps the focus on the tile holding key after the tiles +// changed under it; with no such key, or the wall down, it does nothing. +func (a *app) wallRefocusKey(key string) { + if !a.wall.on || key == "" { + return + } + tiles := a.wallShown(a.now()) + for i, tile := range tiles { + if tile.tab.key == key { + a.wallMove(i, len(tiles)) + return + } + } +} + +// teamMemberWord is how a note names a member: its title, else its handle. +func teamMemberWord(m teamMember) string { + if w := strings.TrimSpace(m.Word); w != "" { + return w + } + if m.Handle != "" { + return "@" + m.Handle + } + return "a member" +} + +// wallFocusedKey is the focused tile's conversation, "" for none. +func (a *app) wallFocusedKey(tiles []wallTile) string { + if f := a.wall.focus; f >= 0 && f < len(tiles) { + return tiles[f].tab.key + } + return "" +} + +// wallRefocus puts the focus back after tiles left the wall. A focused tile +// that is still there keeps it, wherever the closing moved it to. One that +// went hands it to its nearest survivor on the right, which slides into the +// place it left, and at the end of the list to the one on its left, as +// closing a browser tab does: never back to the start. +func (a *app) wallRefocus(before []wallTile, key string) { + if !a.wall.on { + return + } + after := a.wallShown(a.now()) + at := make(map[string]int, len(after)) + for i, tile := range after { + at[tile.tab.key] = i + } + if j, ok := at[key]; ok { + a.wallMove(j, len(after)) + return + } + was := -1 + for i, tile := range before { + if tile.tab.key == key { + was = i + } + } + for i := was + 1; was >= 0 && i < len(before); i++ { + if j, ok := at[before[i].tab.key]; ok { + a.wallMove(j, len(after)) + return + } + } + for i := was - 1; i >= 0; i-- { + if j, ok := at[before[i].tab.key]; ok { + a.wallMove(j, len(after)) + return + } + } + a.wallMove(0, len(after)) +} + +// wallCloseViews closes the view of every marked tile. The ones at rest go at +// once; the first with work in flight is asked about, on its page, and any +// others like it stay marked so nothing is closed that was not asked about. +func (a *app) wallCloseViews(tiles []wallTile) tea.Cmd { + focused := a.wallFocusedKey(tiles) + defer a.wallRefocus(tiles, focused) + var cmds []tea.Cmd + var ask *chatTab + for _, tab := range a.wallMarkedTabs(tiles) { + if a.tabCloseAsks(tab) { + if ask == nil { + held := tab + ask = &held + } + continue + } + delete(a.wall.marked, tab.key) + cmds = append(cmds, a.tabDismiss(tab)) + } + if ask != nil { + delete(a.wall.marked, ask.key) + a.closeWall() + cmds = append(cmds, a.tabDismiss(*ask)) + } + a.wall.hover = wallHitRef{} + return tea.Batch(cmds...) +} + +// wallWheelSettle is how long one wheel step holds before the next in the +// same direction is taken. A tile row is a dozen lines or more, so a step per +// event would throw a trackpad's burst of thirty straight to the end; one per +// settle is a row per notch for a hand turning a wheel, and a few rows for a +// flick. +const wallWheelSettle = 90 * time.Millisecond + +// wallWheel is a wheel notch over the wall at x,y: the VIEW moves one tile row, +// clamped to the list, as a page does, and the focus moves only when the +// scroll would leave it off screen, onto the same column of the nearest row +// that is on it. A notch the other way is taken at once: a hand reversing is +// not a burst. +func (a *app) wallWheel(x, y int, down bool) { + a.wallSettle() + a.wall.ptrX, a.wall.ptrY, a.wall.ptrIn = x, y, y >= a.wall.headRows + dir := -1 + if down { + dir = 1 + } + now := a.now() + if dir == a.wall.wheelDir && now.Sub(a.wall.wheelAt) < wallWheelSettle { + return + } + a.wall.wheelDir, a.wall.wheelAt = dir, now + // The help sheet scrolls under the wheel, and nothing behind it does; the + // Organize card walks its rows, which scrolls it. + if a.wall.help { + a.wallHelpScroll(dir) + return + } + if a.wall.org.on { + if down { + a.wallOrganizeKey("down") + } else { + a.wallOrganizeKey("up") + } + a.wall.stirred = true + a.touch() + return + } + // A popover hangs from a control that is about to move, so it goes, as a + // menu does when the page under it scrolls. + if a.wall.pop.kind != wallPopNone { + a.wall.pop = wallPop{} + a.wall.stirred = true + a.touch() + } + n := len(a.wallShown(now)) + if n == 0 { + return + } + cols, _ := a.wallGeometry(n) + vis := a.wallRowsOnScreen(n) + top := max((n+cols-1)/cols-vis, 0) + scroll := min(max(a.wall.scroll+dir, 0), top) + if scroll == a.wall.scroll { + return + } + a.wall.scroll = scroll + row, col := a.wall.focus/cols, a.wall.focus%cols + row = min(max(row, scroll), scroll+vis-1) + a.wall.focus = min(row*cols+col, n-1) + a.wall.hover = wallHitRef{} + a.wall.rehover = true + a.wall.stirred = true + a.touch() +} + +// ── THE MOTION ────────────────────────────────────────────────────────────── +// +// Two small movements, both on the paint clock (app.go's [app.paint] keeps it +// turning while [app.wallAnimating] says so) and both functions of the time +// since they began, so a slow link draws the same motion in fewer frames +// rather than a slower one. Neither delays a key: every key and press settles +// the reveal first, and the zoom is drawn over a conversation that is +// already live. + +// wallRevealSpan is the most the opening's reveal takes from the first tile +// row to the last, and wallRevealStep the most between two rows. Two rows +// arrive 45ms apart; four take 135ms. Past that it would be waiting. +const ( + wallRevealSpan = 135 * time.Millisecond + wallRevealStep = 45 * time.Millisecond +) + +// wallZoomFor is how long an opened tile takes to grow into the frame: three +// frames at the local cadence, on an ease-out, so most of the growth is in +// the first. +const wallZoomFor = 100 * time.Millisecond + +// wallMotionOK says the wall may move at all. The linear tier is the +// screen-reader tier and draws no motion anywhere; the ASCII tier is a +// terminal that could not be trusted with the glyphs, and is not asked to +// animate either; and over a remote link a frame is a third as frequent, so a +// 140ms movement is one jump. +func (a *app) wallMotionOK() bool { + return !a.wallReduced() && !a.remote +} + +// wallReduced is the tiers that draw no motion at all, the working spinner +// included: the painter is told so ([wallView.reduced]) and draws a still +// mark. A remote link keeps its spinner, which already steps at the link's +// own cadence everywhere else on this surface. +func (a *app) wallReduced() bool { + return a.linear || a.pal.linear || a.pal.ascii +} + +// wallAnimating reports whether the wall has motion in flight that the paint +// clock must draw at its full cadence: the reveal or the zoom. +// It reads the wall's own fields and nothing else, because it is asked on +// every paint. +func (a *app) wallAnimating() bool { + now := a.now() + if !a.wall.zoomAt.IsZero() && now.Sub(a.wall.zoomAt) < wallZoomFor { + return true + } + return a.wall.on && !a.wall.revealAt.IsZero() +} + +// wallSpinning reports whether the wall is up with a live working tile, whose +// spinner wants a frame each step and nothing more. +func (a *app) wallSpinning() bool { + return a.wall.on && a.wall.spinning +} + +// wallSettle ends whatever is still moving on the wall at once, which is what +// any key or press does before it acts. +func (a *app) wallSettle() { + if !a.wall.revealAt.IsZero() { + a.wall.revealAt = time.Time{} + a.touch() + } +} + +// wallZoomDone ends an opened tile's zoom at once. +func (a *app) wallZoomDone() { + if !a.wall.zoomAt.IsZero() { + a.wall.zoomAt = time.Time{} + a.touch() + } +} + +// wallSpin is the working spinner's step for a frame drawn at now. It is +// counted in time at the spinner's own cadence rather than in paints, so a +// wall drawn on its half-second reading tick still shows the glyph the spinner +// has reached, not the one it had when the clock last turned. +func wallSpin(now time.Time) int { + return int(now.UnixMilli() / int64(spinnerStep*frameInterval/time.Millisecond)) +} + +// wallRect is a rectangle of frame cells, inclusive-exclusive. +type wallRect struct{ x0, y0, x1, y1 int } + +func (r wallRect) w() int { return r.x1 - r.x0 } + +func (r wallRect) holds(x, y int) bool { + return x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1 +} + +// wallTileRect is where tile i was drawn on the last frame, from its own +// targets, in frame cells. +func (a *app) wallTileRect(i int) (wallRect, bool) { + return wallTileBounds(a.wall.hits, i) +} + +func wallTileBounds(hits []wallHit, i int) (wallRect, bool) { + var r wallRect + ok := false + for _, hit := range hits { + if !hit.ref().onTile(i) { + continue + } + if !ok { + r, ok = wallRect{hit.x0, hit.y0, hit.x1, hit.y1}, true + continue + } + r.x0, r.y0 = min(r.x0, hit.x0), min(r.y0, hit.y0) + r.x1, r.y1 = max(r.x1, hit.x1), max(r.y1, hit.y1) + } + return r, ok +} + +// wallCardRect is where the help sheet, the popover, the Organize card or +// else the new-team card lands on this frame, so a press can be told to be on it or off it. It is laid out +// only while one is up, and a card is a handful of short rows. +func (a *app) wallCardRect(v wallView, width, room, head int) wallRect { + var card wallCard + g := wallGlyphsFor(a.pal.ascii) + switch { + case v.help: + card = wallHelpCard(a.pal, v, width, room) + a.wall.helpMax = card.over + case v.org.on: + card = wallOrgCard(a.pal, g, v, width, room) + a.wall.org.top = card.top + case v.pop.kind != wallPopNone && !v.naming: + card = wallPopCard(a.pal, g, v, width, room) + case v.naming: + card = wallNameCard(a.pal, g, v, width, room) + } + if len(card.rows) == 0 { + return wallRect{} + } + return wallRect{card.x, card.y + head, card.x + card.w, card.y + head + len(card.rows)} +} + +// wallRevealMask blanks the tiles whose row has not come in yet, in place, +// and ends the reveal once the last row is due. The tiles were painted +// whole, from their cached rows, so the reveal costs a blanking of cells for +// a handful of frames and never a second drawing of a body. A card or the +// tray over the grid ends it at once: a reveal is for the tiles alone, and a +// half-blanked card would read as a fault. +func (a *app) wallRevealMask(rows []string, hits []wallHit, n, cols, tileH, room, width int, now time.Time) { + if a.wall.revealAt.IsZero() { + return + } + if a.wall.naming || a.wall.help || a.wall.org.on || a.wall.pop.kind != wallPopNone || len(a.wall.marked) > 0 || n == 0 || cols < 1 { + a.wall.revealAt = time.Time{} + return + } + vis := max(wallVisibleRows(room, tileH), 1) + step := wallRevealStep + if vis > 1 && wallRevealSpan/time.Duration(vis-1) < step { + step = wallRevealSpan / time.Duration(vis-1) + } + gone := now.Sub(a.wall.revealAt) + if gone >= step*time.Duration(vis-1) { + a.wall.revealAt = time.Time{} + return + } + first := a.wall.scroll * cols + for i := first; i < min(first+vis*cols, n); i++ { + row := (i - first) / cols + if gone >= step*time.Duration(row) { + continue + } + r, ok := wallTileBounds(hits, i) + if !ok { + continue + } + blank := strings.Repeat(" ", r.w()) + for y := max(r.y0, 0); y < min(r.y1, len(rows)); y++ { + rows[y] = wallSplice(rows[y], blank, r.x0, width) + } + } +} + +// wallZoomed is the frame of the conversation a tile just opened, drawn +// inside the tile's rectangle growing into the whole frame, with a quiet +// border on its edge. The conversation is already in front: this only frames +// its first few pictures, so a key typed on the first of them lands in its +// box. It hands the frame back untouched once the zoom is over, and forgets +// the zoom. +func (a *app) wallZoomed(frame string) string { + if a.wall.zoomAt.IsZero() { + return frame + } + gone := a.now().Sub(a.wall.zoomAt) + if gone >= wallZoomFor || a.wall.on || !a.wallMotionOK() { + a.wall.zoomAt = time.Time{} + return frame + } + width, height := a.size() + t := float64(gone) / float64(wallZoomFor) + t = 1 - (1-t)*(1-t) + from := a.wall.zoomFrom + lerp := func(a, b int) int { return a + int(float64(b-a)*t+0.5) } + r := wallRect{lerp(from.x0, 0), lerp(from.y0, 0), lerp(from.x1, width), lerp(from.y1, height)} + if r.x1-r.x0 < 2 || r.y1-r.y0 < 2 { + return frame + } + rows := strings.Split(frame, "\n") + edge := a.pal.dim + // THE CORNERS ARE THE ONE FRAME'S (frame.go), asked for through its pieces + // so the zoom closes its box the way every other box on this surface does. + pieces := framePiecesOf(a.pal) + inner := r.x1 - r.x0 - 2 + for y := range rows { + switch { + case y < r.y0 || y >= r.y1: + rows[y] = "" + case y == r.y0: + rows[y] = strings.Repeat(" ", r.x0) + edge(pieces.tl+strings.Repeat(pieces.edge, inner)+pieces.tr) + case y == r.y1-1: + rows[y] = strings.Repeat(" ", r.x0) + edge(pieces.bl+strings.Repeat(pieces.edge, inner)+pieces.br) + default: + rows[y] = strings.Repeat(" ", r.x0) + edge(pieces.side) + wallFit(ansi.Cut(rows[y], r.x0+1, r.x1-1), inner) + "\x1b[0m" + edge(pieces.side) + } + } + return strings.Join(rows, "\n") +} + +func dropLastRune(s string) string { + r := []rune(s) + if len(r) == 0 { + return s + } + return string(r[:len(r)-1]) +} + +// wallTeamLabel is a team's name on the wall's flat Teams row: `harbor › api` +// for a team inside another (its parent's name first, so two teams called api +// are told apart), and the bare name at the top level. The row stays one flat +// row (ruling c-12); the tree is the teams page's and the switcher's. Each part +// is cut on its own, so the team's own name is never the part that is lost. +func (a *app) wallTeamLabel(t team) string { + name := t.Name + if ansi.StringWidth(name) > wallChipCap { + name = ansi.Truncate(name, wallChipCap, a.linearMark("…", "~")) + } + p, ok := a.teamByID(t.Parent) + if !ok || p.Root { + return name + } + parent := p.Name + if ansi.StringWidth(parent) > wallChipCap/2 { + parent = ansi.Truncate(parent, wallChipCap/2, a.linearMark("…", "~")) + } + return parent + " " + a.linearMark("›", ">") + " " + name +} diff --git a/internal/tui3/wallbar.go b/internal/tui3/wallbar.go new file mode 100644 index 0000000000..7275000188 --- /dev/null +++ b/internal/tui3/wallbar.go @@ -0,0 +1,1579 @@ +package tui3 + +import ( + "strconv" + "strings" + + "github.com/charmbracelet/x/ansi" +) + +// ── THE WALL'S CONTROLS: BUTTONS, TEAMS, CARDS AND POPOVERS ───────────────── +// +// Every act the wall answers a key for has a button, and every button names +// its key: ` Filter / `, ` New team s `. A person who clicks learns the key on +// the way, and a person who never clicks loses nothing, because the keys do +// what they did. +// +// This is still the painting half (wallview.go): pure functions from a +// [wallView] to rows and [wallHit]s. The hover arrives in v.hover and is only +// ever drawn here, never resolved. +// +// A CONTROL UNDER THE POINTER WEARS THE CURSOR GROUND (styles.go), the step the +// tab strip's own doors wear. A control inside something already on a ground +// takes the ladder's next step up, so the two never read as one. +// +// COLOUR BELONGS TO TEAMS AND TO STATE, AND TO NOTHING ELSE. A team's colour +// (teamhue.go) is drawn only as its dot: on its segment, on the tiles it +// holds, in its popovers. Borders and grounds stay with state. + +// wallButton is one pressable label and the key that does the same thing. +type wallButton struct { + act wallAct + label string + key string // "" for an act no single key does +} + +// wallButtonW is the cells a button takes: a cell of padding either side, so +// the hover ground reads as a button and not as a highlighted word. +func wallButtonW(b wallButton) int { + w := 2 + ansi.StringWidth(b.label) + if b.key != "" { + w += 1 + ansi.StringWidth(b.key) + } + return w +} + +// wallButtonPaint draws one button: the label in ink, the key dim. +func wallButtonPaint(pal palette, b wallButton, hot bool) string { + s := " " + pal.ink(b.label) + if b.key != "" { + s += " " + pal.dim(b.key) + } + s += " " + if hot { + return pal.cursor(s, 0) + } + return s +} + +// wallLay draws buttons left to right from column x on row y, gap blank cells +// apart, and says where each landed. +func wallLay(pal palette, bs []wallButton, hover wallHitRef, x, y, gap int) (string, int, []wallHit) { + var b strings.Builder + hits := make([]wallHit, 0, len(bs)) + w := 0 + for i, btn := range bs { + if i > 0 { + b.WriteString(strings.Repeat(" ", gap)) + w += gap + } + bw := wallButtonW(btn) + hot := hover.kind == wallHitAction && hover.arg == int(btn.act) + b.WriteString(wallButtonPaint(pal, btn, hot)) + hits = append(hits, wallHit{x0: x + w, y0: y, x1: x + w + bw, y1: y + 1, kind: wallHitAction, arg: int(btn.act)}) + w += bw + } + return b.String(), w, hits +} + +// wallBarWidth is the cells a row of buttons takes, gap blank cells between. +func wallBarWidth(bs []wallButton, gap int) int { + w := 0 + for i, b := range bs { + if i > 0 { + w += gap + } + w += wallButtonW(b) + } + return w +} + +// wallKeys is the spelling of the marks the controls use, in the palette's +// tier. +type wallKeys struct { + back, enter, pick, shuffle, minus, more, menu, caret, rule string + boxOff, boxOn, boxSome string +} + +func wallKeysFor(ascii bool) wallKeys { + if ascii { + return wallKeys{back: "<", enter: "enter", pick: "space", shuffle: "~", minus: "-", more: "...", menu: "~", caret: "v", + rule: "-", boxOff: "[ ]", boxOn: "[x]", boxSome: "[-]"} + } + return wallKeys{back: "‹", enter: "↵", pick: "␣", shuffle: "↻", minus: "−", more: "…", menu: "⋯", caret: "▾", + rule: "─", boxOff: "☐", boxOn: "☑", boxSome: "▣"} +} + +// wallPart is one piece of a row drawn on a ground: hot pieces are a control +// under the pointer and take the ladder's next step over it. +type wallPart struct { + s string + hot bool +} + +// wallCompose draws parts on ground, the hot ones on the mark step. +func wallCompose(pal palette, parts []wallPart, ground func(string) string) string { + var b, run strings.Builder + flush := func() { + if run.Len() > 0 { + b.WriteString(ground(run.String())) + run.Reset() + } + } + for _, p := range parts { + if p.hot { + flush() + b.WriteString(pal.background(p.s, 0, pal.ramp.mark)) + continue + } + run.WriteString(p.s) + } + flush() + return b.String() +} + +// wallTeamMark is team i's dot in its colour, or, where there is no colour +// to draw, its initial, dim. Either way it is one cell. +func wallTeamMark(pal palette, v wallView, i int, glyph string) string { + if i >= 0 && i < len(v.teams) { + if ink := pal.teamInk(v.teams[i].hue); ink != nil { + return ink(glyph) + } + } + initial := "?" + if i >= 0 && i < len(v.teams) { + if r := []rune(v.teams[i].name); len(r) > 0 { + initial = strings.ToLower(string(r[0])) + if ansi.StringWidth(initial) != 1 { + initial = "?" + } + } + } + return pal.dim(initial) +} + +func wallPlural(n int, word string) string { + if n == 1 { + return word + } + return word + "s" +} + +// ── THE TOOLBAR ───────────────────────────────────────────────────────────── + +// wallBar is the toolbar on row y of a frame width wide, ending a cell from +// its right edge. +func wallBar(pal palette, v wallView, width, y int) (string, []wallHit) { + return wallBarIn(pal, v, width, wallMargin, y) +} + +// wallBarIn is the toolbar along the bottom: the way back on the left, the +// acts on the wall as a whole on the right, ending inset cells from the right +// edge so its last button lines up with the grid. It never wraps: on a narrow +// frame the least needed buttons leave first, and a button is drawn whole or +// not at all. +// +// BETWEEN THE TWO IS THE STATUS LINE. While the pointer rests on any control, +// the toolbar says in one dim line what that control does and the key that +// does the same, as a desktop program's status bar does: a glyph like a +// segment's dot is learnt by pointing at it once, and nothing is drawn over +// the thing pointed at. +func wallBarIn(pal palette, v wallView, width, inset, y int) (string, []wallHit) { + k := wallKeysFor(pal.ascii) + hint := wallHint(v, pal.ascii) + if v.naming { + n := wallMarked(v) + word := " Naming a team for " + strconv.Itoa(n) + " " + wallPlural(n, "conversation") + if hint != "" { + word = " " + hint + } + return pal.dim(ansi.Truncate(word, width, "")), nil + } + const gap = 2 + left := []wallButton{{act: wallActBack, label: k.back + " Back", key: "esc"}} + acts := []wallButton{ + {act: wallActFilter, label: "Filter", key: "/"}, + {act: wallActNewTeam, label: "New team", key: "s"}, + } + cols := []wallButton{{act: wallActColsLess, label: k.minus}, {act: wallActColsMore, label: "+"}} + const colsWord = "Columns" + colsW := len(colsWord) + wallBarWidth(cols, 0) + help := []wallButton{{act: wallActHelp, label: "Help", key: "?"}} + + // A narrow frame gives up the columns first, then the acts from the right, + // and Help last of all: it is the one button that says what the rest do. + // The keys stay whatever is drawn. + showCols, showActs, showHelp := true, len(acts), true + rightW := func() int { + w := 0 + part := func(pw int) { + if w > 0 { + w += gap + } + w += pw + } + if showActs > 0 { + part(wallBarWidth(acts[:showActs], gap)) + } + if showCols { + part(colsW) + } + if showHelp { + part(wallBarWidth(help, gap)) + } + return w + } + fits := func() bool { + return 1+wallBarWidth(left, gap)+gap+rightW()+max(inset-1, 0) <= width + } + for !fits() { + switch { + case showCols: + showCols = false + case showActs > 0: + showActs-- + case showHelp: + showHelp = false + default: + return "", nil + } + } + // A HINT OUTRANKS THE BUTTONS IT WOULD BE CUT FOR. The status line is the + // one place a control says what it does and its key, and cut to fit + // between Back and the buttons it read `Resume the …` at 80 columns and + // lost the key at 110. So while it shows, the columns and then the acts + // step aside, never the one under the pointer and never Help, until the + // sentence is whole; they come back when the pointer leaves. + if hint != "" { + under := func(act wallAct) bool { return v.hover.kind == wallHitAction && v.hover.arg == int(act) } + need := ansi.StringWidth(hint) + 6 + for 1+wallBarWidth(left, gap)+need+rightW()+max(inset-1, 0) > width { + switch { + case showCols && !under(wallActColsLess) && !under(wallActColsMore): + showCols = false + case showActs > 0 && !under(acts[showActs-1].act): + showActs-- + default: + need = 0 + } + if need == 0 { + break + } + } + } + s, lw, hits := wallLay(pal, left, v.hover, 1, y, gap) + row := " " + s + rw := rightW() + // The last button's ground sits in the inset, as the title's last pill's + // does, so its word ends where the grid does. + at := width - max(inset-1, 0) - rw + used := 1 + lw + // The status line: three cells after the way back, and at least three + // before the first button on the right, cut with an ellipsis before it + // would crowd them. + const hintGap = 3 + if room := at - used - 2*hintGap; hint != "" && room >= 8 { + if ansi.StringWidth(hint) > room { + hint = ansi.Truncate(hint, room, k.more) + } + row += strings.Repeat(" ", hintGap) + pal.dim(hint) + used += hintGap + ansi.StringWidth(hint) + } + row += strings.Repeat(" ", max(at-used, 0)) + first := true + sep := func() { + if !first { + row += strings.Repeat(" ", gap) + at += gap + } + first = false + } + if showActs > 0 { + sep() + rs, w, rh := wallLay(pal, acts[:showActs], v.hover, at, y, gap) + row += rs + hits = append(hits, rh...) + at += w + } + if showCols { + sep() + row += pal.dim(colsWord) + cs, w, ch := wallLay(pal, cols, v.hover, at+len(colsWord), y, 0) + row += cs + hits = append(hits, ch...) + at += len(colsWord) + w + } + if showHelp { + sep() + hs, w, hh := wallLay(pal, help, v.hover, at, y, gap) + row += hs + hits = append(hits, hh...) + at += w + } + return row, hits +} + +// wallMembersWord is a team's size in words: `1 member`, `3 members`. +func wallMembersWord(n int) string { + if n == 1 { + return "1 member" + } + return strconv.Itoa(n) + " members" +} + +// wallHint is what the control under the pointer does, and its key after a +// dot when it has one; "" when the pointer is on no control. It is the +// person's words, the same ones the buttons use. +func wallHint(v wallView, ascii bool) string { + h := v.hover + sep, arrows := "·", "← →" + if ascii { + sep, arrows = "-", "left right" + } + name := func(i int) string { + if i >= 0 && i < len(v.tiles) { + return v.tiles[i].name + } + return "this conversation" + } + team := func(id string) string { + if i := v.teamRow(id); i >= 0 { + return v.teams[i].name + } + return "this team" + } + keyed := func(s, key string) string { return s + " " + sep + " " + key } + marked := wallMarked(v) + switch h.kind { + case wallHitTile: + if h.arg < 0 || h.arg >= len(v.tiles) { + return "" + } + switch { + case marked > 0 && v.tiles[h.arg].marked: + return keyed("Click to take out of the selection", "space") + case marked > 0: + return keyed("Click to add to the selection", "space") + case h.arg == min(max(v.focus, 0), len(v.tiles)-1): + return keyed("Click to open "+name(h.arg), "enter") + } + return "Click to focus, click again to open" + case wallHitSelect: + if h.arg >= 0 && h.arg < len(v.tiles) && v.tiles[h.arg].marked { + return keyed("Take out of the selection", "space") + } + return keyed("Select for a team", "space") + case wallHitTeams: + return keyed("Add this conversation to teams", "m") + case wallHitOpen: + if h.arg >= 0 && h.arg < len(v.tiles) && v.tiles[h.arg].signal == tabNeedsPerson { + return keyed("Open the conversation to answer it", "enter") + } + return keyed("Open conversation", "enter") + case wallHitClose: + return keyed("Close this view; the work keeps running", "x") + case wallHitChip: + // tab steps through the teams rather than naming one, so no key is + // offered for a single segment. + if h.id == "" { + return "Show every conversation open in this window" + } + // The team's segment counts what is open here, and the hint says what + // the team is beside it, so the two numbers are never read as one. + if i := v.teamRow(h.id); i >= 0 { + row := v.teams[i] + return row.name + " " + sep + " " + strconv.Itoa(row.count) + " open here " + sep + " " + wallMembersWord(row.members) + } + return "Show only the conversations in " + team(h.id) + case wallHitChipMenu: + return "Rename, recolour or delete " + team(h.id) + case wallHitAddTeam: + return keyed(wallNewTeamHint(marked), "s") + case wallHitMini: + return "Go to " + name(h.arg) + case wallHitSwatch: + return keyed("Use this colour", arrows) + case wallHitPopRow: + switch h.arg { + case wallPopNew: + return "Make a new team with this conversation in it" + case wallPopManager: + if v.popManager == wallManagerRemove { + return "Make this an ordinary member again; it keeps its history" + } + return "Make this conversation the shown team's manager; the one before stays a member" + case wallPopDelete: + return "Delete this team; its conversations stay open" + case wallPopConfirm: + return "Delete the team now" + case wallPopKeep: + return keyed("Keep the team", "esc") + case wallPopDone: + return keyed("Keep the name and close", "enter") + } + return keyed("Put in or take out of "+team(h.id), "space") + case wallHitAction: + switch wallAct(h.arg) { + case wallActBack: + switch { + case v.filter != "": + return keyed("Clear the filter", "esc") + case marked > 0: + return keyed("Clear the selection", "esc") + } + return keyed("Back to the conversation", "esc") + case wallActFilter: + return keyed("Filter conversations by name", "/") + case wallActNewTeam: + return keyed(wallNewTeamHint(marked), "s") + case wallActNext: + return keyed("Go to the next conversation waiting on you", "n") + case wallActResume: + // Short, because the toolbar gives the hint what its buttons leave: + // the title beside the button already says which team. + return keyed("Resume the "+strconv.Itoa(v.away)+" not open here", "r") + case wallActColsLess: + return keyed("Fewer columns", "-") + case wallActColsMore: + return keyed("More columns", "+") + case wallActMakeTeam: + return keyed("Make a team of the selection", "s") + case wallActAddTo: + return "Add the selection to teams" + case wallActCloseViews: + return "Close these views; the work keeps running" + case wallActClear: + return keyed("Clear the selection", "esc") + case wallActFilterClear: + return keyed("Clear the filter", "esc") + case wallActSave: + return keyed("Make the team", "enter") + case wallActCancel: + return keyed("Put the card away", "esc") + case wallActShuffle: + return keyed("Suggest another name and colour", "ctrl+r") + case wallActHelp: + return keyed("What you can do here", "?") + case wallActOrganize: + return keyed("Suggest teams for your conversations", "o") + case wallActOrgUndo: + return keyed("Put the teams back as they were", "u") + case wallActOrgApply: + return keyed("Make the ticked teams", "enter") + case wallActOrgCancel: + return keyed("Close without changing anything", "esc") + } + case wallHitOrgRow: + if h.arg >= 0 && h.arg < len(v.org.props) { + p := v.org.props[h.arg] + switch { + case p.reason != "": + return keyed(p.reason, "space") + case p.team != "": + return keyed("Add these to "+p.name, "space") + case p.folder: + return keyed("These conversations share a folder", "space") + } + } + return keyed("Tick or untick this suggestion", "space") + case wallHitHelp: + if rows := wallHelpRows(ascii); h.arg >= 0 && h.arg < len(rows) { + return rows[h.arg].hint + } + } + if v.doorHot { + return keyed("Close Conversations", "alt+v") + } + return "" +} + +// wallNewTeamHint says what + New team will hold: the selection, or with +// none the focused conversation, as [app.wallStartNaming] decides. +func wallNewTeamHint(marked int) string { + if marked > 0 { + return "Make a team of the " + strconv.Itoa(marked) + " selected" + } + return "Make a team, starting with the focused conversation" +} + +// wallEmptyRow is the whisper an empty wall draws, with the way back beside it +// as a button, centred. +func wallEmptyRow(pal palette, v wallView, width, y int) (string, []wallHit) { + btn := wallButton{act: wallActBack, label: wallKeysFor(pal.ascii).back + " Back", key: "esc"} + ww, bw := ansi.StringWidth(wallEmptyWord), wallButtonW(btn) + if ww+3+bw > width { + word := ansi.Truncate(wallEmptyWord, width, "") + return strings.Repeat(" ", (width-ansi.StringWidth(word))/2) + pal.dim(word), nil + } + left := (width - ww - 3 - bw) / 2 + s, _, hits := wallLay(pal, []wallButton{btn}, v.hover, left+ww+3, y, 1) + return strings.Repeat(" ", left) + pal.dim(wallEmptyWord) + " " + s, hits +} + +// wallNoneRow is what a narrowed grid with nothing in it says, centred on +// row y, beside the one button that widens it again: a filter matching +// nothing offers Clear, a team holding no open conversation offers All. +// +// No conversations match "xyz" Clear esc +func wallNoneRow(pal palette, v wallView, width, y int) (string, []wallHit) { + name := "this team" + if i := v.teamRow(v.team); i >= 0 { + name = v.teams[i].name + } + word := "No open conversations in " + name + btn := wallButton{act: wallActFilterClear, label: "Clear", key: "esc"} + kind, arg := wallHitAction, int(wallActFilterClear) + if v.filter != "" { + word = "No conversations match \"" + v.filter + "\"" + } else { + btn = wallButton{label: "Show all"} + kind, arg = wallHitChip, 0 + } + const gap = 3 + bw := wallButtonW(btn) + if room := width - 2 - gap - bw; ansi.StringWidth(word) > room { + if room < 8 { + return "", nil + } + word = ansi.Truncate(word, room, wallKeysFor(pal.ascii).more) + } + ww := ansi.StringWidth(word) + x := (width - ww - gap - bw) / 2 + hot := v.hover == wallHitRef{kind: kind, arg: arg} + row := strings.Repeat(" ", x) + pal.muted(word) + strings.Repeat(" ", gap) + wallButtonPaint(pal, btn, hot) + at := x + ww + gap + return row, []wallHit{{x0: at, y0: y, x1: at + bw, y1: y + 1, kind: kind, arg: arg}} +} + +// ── THE TEAMS ROW ─────────────────────────────────────────────────────────── + +// wallChipCap is the widest a team's name is drawn on its segment. +const wallChipCap = teamNameCells + +// wallTeamsRow is the second row of the head: the Teams control, one +// segmented row with a segment for All, one per team, and + New team last; +// the one shown sits on the selected ground. The minimap stands at the right +// end, inset cells from the edge, when there are more conversations than the +// screen shows. While a filter narrows the grid the row is the filter instead, +// so what narrowed it and the way to undo it are both on screen. +// +// Teams All 6 │ ● port 3 │ ● infra 2 │ + New team ▣▣ ▣▣ ▪▪ +// +// EVERY SEGMENT IS PADDED ALIKE, one cell either side of its words, and parted +// from the next by one rule, so the row reads as one control. +// +// A SEGMENT IS A DOOR TO ITS TEAM. Its dot opens the team's settings, and so +// does the ⋯ the pointer brings up where the count was, the way a sidebar +// trades a count for its menu under the pointer: nothing beside it moves. +func wallTeamsRow(pal palette, g wallGlyphs, v wallView, width, height, inset, c, first, last, y int) (string, []wallHit) { + var b strings.Builder + var hits []wallHit + x := 1 + b.WriteString(" ") + put := func(s string, w int) { + b.WriteString(s) + x += w + } + // limit is the last cell the left part may reach; Organize's piece, when + // it is drawn, keeps its own cells at the right. + limit := width + fitsAt := func(w int) bool { return x+w <= limit } + k := wallKeysFor(pal.ascii) + var org wallOrgPiece + button := func(btn wallButton) { + if !fitsAt(1 + wallButtonW(btn)) { + return + } + put(" ", 1) + s, w, h := wallLay(pal, []wallButton{btn}, v.hover, x, y, 1) + put(s, w) + hits = append(hits, h...) + } + + switch { + case v.naming && !wallNameCardFits(width, height): + // The card has no room on this frame; the prompt is drawn here instead, + // with the same two buttons. + lead := pal.muted("New team "+g.gt+" ") + pal.ink(v.name) + pal.ink(g.cursor) + if v.asking { + lead += pal.dim(wallNamingWord(pal.ascii)) + } + put(lead, ansi.StringWidth(lead)) + count := " " + pal.dim(strconv.Itoa(wallMarked(v))+" picked") + " " + put(count, ansi.StringWidth(count)) + button(wallButton{act: wallActCancel, label: "Cancel", key: "esc"}) + button(wallButton{act: wallActSave, label: "Create", key: k.enter}) + return ansi.Truncate(b.String(), width, ""), wallHitsWithin(hits, width) + case v.filtering || v.filter != "": + put(pal.dim("Filter "), 8) + w := 2 + ansi.StringWidth(v.filter) + paint := pal.dim("/ ") + pal.ink(v.filter) + if v.filtering { + paint += pal.ink(g.cursor) + w += ansi.StringWidth(g.cursor) + } + if fitsAt(w) { + hits = append(hits, wallHit{x0: x, y0: y, x1: x + w, y1: y + 1, kind: wallHitAction, arg: int(wallActFilter)}) + } + put(paint, w) + put(" ", 2) + if n := len(v.tiles); v.filter != "" { + word := "1 match" + if n != 1 { + word = strconv.Itoa(n) + " matches" + } + if fitsAt(len(word) + 2) { + put(pal.dim(word)+" ", len(word)+1) + } + } + button(wallButton{act: wallActFilterClear, label: "Clear", key: "esc"}) + default: + // ORGANIZE STANDS AT THE RIGHT END, and yields to the teams: the row is + // laid with its cells kept, and laid again without it when that would + // leave a team or + New team off the row. + org = wallOrganizeButton(pal, g, v, y) + if org.w > 0 { + limit = width - inset - org.w - 2 + if !wallTeamsSegments(pal, g, v, k, y, &b, &x, &hits, fitsAt) { + b.Reset() + b.WriteString(" ") + x, hits, limit, org = 1, hits[:0], width, wallOrgPiece{} + wallTeamsSegments(pal, g, v, k, y, &b, &x, &hits, fitsAt) + } + } else { + wallTeamsSegments(pal, g, v, k, y, &b, &x, &hits, fitsAt) + } + } + + left := b.String() + lw := x + return wallTeamsRight(pal, g, v, left, lw, hits, org, width, inset, c, first, last, y) +} + +// wallTeamsSegments lays the Teams control from cell *x: the label, All, a +// segment per team and + New team, then a moment's note of a team just made. +// It reports whether every team and + New team fit. +func wallTeamsSegments(pal palette, g wallGlyphs, v wallView, k wallKeys, y int, b *strings.Builder, x *int, hits *[]wallHit, fitsAt func(int) bool) bool { + put := func(s string, w int) { + b.WriteString(s) + *x += w + } + whole := true + { + const label = "Teams " + put(pal.dim(label[:len(label)-1]), len(label)-1) + sep := pal.dim("│") + if pal.ascii { + sep = pal.dim("|") + } + addW := 2 + len("+ New team") + first := true + // segment draws one segment and reports whether it fit, keeping room + // for the + New team segment after it when keep is set. + segment := func(at int, id, name, count string, on, keep bool) bool { + dotted := at >= 0 + nw, cw := ansi.StringWidth(name), ansi.StringWidth(count) + w := 1 + nw + 1 + cw + 1 + if dotted { + w += 2 // the dot and its blank + } + need := w + 1 + if keep { + need += 1 + addW + } + if !fitsAt(need) { + return false + } + if !first { + put(sep, 1) + } + first = false + hot := (v.hover.kind == wallHitChip || v.hover.kind == wallHitChipMenu) && v.hover.id == id + menuHot := v.hover.kind == wallHitChipMenu && v.hover.id == id + ground := func(s string) string { return s } + switch { + case on: + ground = func(s string) string { return pal.selected(s, 0) } + case hot: + ground = func(s string) string { return pal.cursor(s, 0) } + } + nameInk := pal.muted + if on || hot { + nameInk = pal.ink + } + var parts []wallPart + x0, end := *x, *x+w + if dotted { + // The dot, with the pad before it, is the settings door. + parts = append(parts, wallPart{s: " " + wallTeamMark(pal, v, at, "●"), hot: menuHot}) + *hits = append(*hits, wallHit{x0: x0, y0: y, x1: x0 + 2, y1: y + 1, kind: wallHitChipMenu, id: id}) + x0 += 2 + } + parts = append(parts, wallPart{s: " " + nameInk(name) + " "}) + tail := end - 1 - cw // the count's first cell + if dotted && hot { + menu := k.menu + if mw := ansi.StringWidth(menu); mw > cw { + menu = ansi.Truncate(menu, cw, "") + } + *hits = append(*hits, wallHit{x0: x0, y0: y, x1: tail, y1: y + 1, kind: wallHitChip, id: id}) + parts = append(parts, wallPart{s: wallFit(pal.ink(menu), cw) + " ", hot: menuHot}) + *hits = append(*hits, wallHit{x0: tail, y0: y, x1: end, y1: y + 1, kind: wallHitChipMenu, id: id}) + } else { + parts = append(parts, wallPart{s: pal.dim(count) + " "}) + *hits = append(*hits, wallHit{x0: x0, y0: y, x1: end, y1: y + 1, kind: wallHitChip, id: id}) + } + put(wallCompose(pal, parts, ground), w) + return true + } + segment(-1, "", "All", strconv.Itoa(v.total), v.team == "", true) + for i, t := range v.teams { + // The name is cut already, each part on its own (wall.go's + // [app.wallTeamLabel]): `harbor › api` is wider than one name. + name := t.name + if ansi.StringWidth(name) > 2*wallChipCap { + name = ansi.Truncate(name, 2*wallChipCap, g.more) + } + if !segment(i, t.id, name, strconv.Itoa(t.count), t.id == v.team, true) { + whole = false + break + } + } + // + New team is the control's last segment, drawn as an action: muted + // until the pointer lights it. + add := " + New team " + if !fitsAt(1 + len(add)) { + whole = false + } else { + if !first { + put(sep, 1) + } + s := pal.muted(add) + if v.hover.kind == wallHitAddTeam { + s = pal.cursor(pal.ink(add), 0) + } + *hits = append(*hits, wallHit{x0: *x, y0: y, x1: *x + len(add), y1: y + 1, kind: wallHitAddTeam}) + put(s, len(add)) + } + // A team just made says so for a moment, in the row it now sits in. + if v.made != "" && !v.madeAt.IsZero() && v.now.Sub(v.madeAt) < wallMadeFor { + word := " Made " + v.made + " " + g.sep + " " + strconv.Itoa(v.madeN) + if fitsAt(ansi.StringWidth(word)) { + put(pal.dim(word), ansi.StringWidth(word)) + } + } + } + return whole +} + +// wallTeamsRight ends the Teams row: left, lw cells wide, then Organize's +// piece and the minimap at the right end, inset cells from the edge, when there +// are more conversations than the screen shows. A minimap that does not fit +// whole says the rows on screen in words instead, and neither is drawn when +// that does not fit either. +func wallTeamsRight(pal palette, g wallGlyphs, v wallView, left string, lw int, hits []wallHit, org wallOrgPiece, width, inset, c, first, last, y int) (string, []wallHit) { + orgW := 0 + if org.w > 0 { + orgW = org.w + 2 + } + var mini string + var miniW int + var miniCells []int + // The minimap says where the screen sits among the conversations, which + // is news only when they do not all fit. + if last-first < len(v.tiles) { + mm, cells := wallMinimap(pal, g, v, c, first, last, width-lw-2-inset-orgW) + mw := ansi.StringWidth(mm) + if mm != "" && lw+2+mw+inset+orgW <= width && cells[len(cells)-1] >= 0 { + mini, miniW, miniCells = mm, mw, cells + } else { + // A minimap missing its last cells would say the wall is shorter + // than it is; the rows on screen are said in words instead. + dash := "–" + if pal.ascii { + dash = "-" + } + word := strconv.Itoa(first+1) + dash + strconv.Itoa(last) + " of " + strconv.Itoa(len(v.tiles)) + if ww := ansi.StringWidth(word); lw+2+ww+inset+orgW <= width { + mini, miniW = pal.dim(word), ww + } + } + } + if miniW == 0 && org.w == 0 { + return ansi.Truncate(left, width, ""), wallHitsWithin(hits, width) + } + rightW := org.w + miniW + if org.w > 0 && miniW > 0 { + rightW += 2 + } + at := width - inset - rightW + row := left + strings.Repeat(" ", max(at-lw, 0)) + if org.w > 0 { + row += org.s + for _, h := range org.hits { + h.x0, h.x1 = h.x0+at, h.x1+at + hits = append(hits, h) + } + at += org.w + if miniW > 0 { + row += " " + at += 2 + } + } + if miniW > 0 { + row += mini + for i, cx := range miniCells { + if cx >= 0 { + hits = append(hits, wallHit{x0: at + cx, y0: y, x1: at + cx + 1, y1: y + 1, kind: wallHitMini, arg: i}) + } + } + } + return row + strings.Repeat(" ", inset), wallHitsWithin(hits, width) +} + +// wallHitsWithin keeps the hits that end inside the row. +func wallHitsWithin(hits []wallHit, width int) []wallHit { + kept := hits[:0] + for _, h := range hits { + if h.x1 <= width { + kept = append(kept, h) + } + } + return kept +} + +// ── A TILE'S ACTION ROW AND ITS TEAMS ─────────────────────────────────────── + +// wallTileAct is one button on a tile's action row, x cells from the tile's +// left edge. +type wallTileAct struct { + kind wallHitKind + btn wallButton + x int +} + +// wallActGap is the run of border between two buttons on the action row, so +// the row still reads as the tile's border with words set into it. +const wallActGap = 2 + +// wallTileActs is the buttons tile t's action row carries at width w: Open, +// or Answer on a tile waiting on a person, then Select, Teams and Close. +// They are laid from the border's second cell, two rule cells apart, and a +// narrow tile loses them from the right, keeping its first; a tile too narrow +// for even that has no row. The answer depends on the tile's width and its +// state, never on the pointer, so the cells are the same whether the row is +// drawn or not. +func wallTileActs(ascii bool, t wallTile, w int) []wallTileAct { + k := wallKeysFor(ascii) + first := wallButton{label: "Open", key: k.enter} + if t.signal == tabNeedsPerson { + first = wallAnswerButton(ascii) + } + all := []wallTileAct{ + {kind: wallHitOpen, btn: first}, + {kind: wallHitSelect, btn: wallButton{label: "Select", key: k.pick}}, + {kind: wallHitTeams, btn: wallButton{label: "Teams", key: "m"}}, + {kind: wallHitClose, btn: wallButton{label: "Close", key: "x"}}, + } + // The row keeps "╰─" before the first button and at least one rule cell + // and the corner after the last. + x := 2 + var out []wallTileAct + for j, act := range all { + if j > 0 { + x += wallActGap + } + bw := wallButtonW(act.btn) + if x+bw+2 > w { + break + } + act.x = x + out = append(out, act) + x += bw + } + return out +} + +// wallActRow is the bottom border as the action row: each button a verb in +// ink and its key dim, in the toolbar's button style, parted by runs of the +// border, and the button under the pointer on the next ground up from the +// tile's. y is the frame row it is drawn on. +func wallActRow(pal palette, v wallView, i int, look wallTileLook, acts []wallTileAct, w, y int) string { + box, border := look.box, look.border + parts := []wallPart{{s: border(box.bl + box.h)}} + at := 2 + for j, act := range acts { + if j > 0 { + parts = append(parts, wallPart{s: border(strings.Repeat(box.h, act.x-at))}) + } + parts = append(parts, wallPart{s: wallButtonPaint(pal, act.btn, false), hot: wallRowHot(v, act.kind, i, y)}) + at = act.x + wallButtonW(act.btn) + } + parts = append(parts, wallPart{s: border(strings.Repeat(box.h, max(w-at-1, 0)) + box.br)}) + return wallFit(wallCompose(pal, parts, look.ground), w) +} + +// wallTileDotsMax is the most dots a tile's border carries before the rest +// are a count. +const wallTileDotsMax = 3 + +// wallTileDots is the teams a tile is in, as the dots on its border: up to +// three in their colours, then +N, then a team. It is "" for a tile in no +// team, which keeps no cells at all. +func wallTileDots(pal palette, v wallView, t wallTile) (string, int) { + if len(t.teams) == 0 { + return "", 0 + } + var b strings.Builder + w := 0 + for i, id := range t.teams { + if i == wallTileDotsMax { + more := "+" + strconv.Itoa(len(t.teams)-wallTileDotsMax) + b.WriteString(pal.dim(more)) + w += len(more) + break + } + b.WriteString(wallTeamMark(pal, v, v.teamRow(id), "●")) + w++ + } + b.WriteString(" ") + return b.String(), w + 1 +} + +// wallTileHits is where tile i's targets landed, its top-left corner at x0,y0. +// The first hit is always the one on the corner. A button is a target only +// while it is drawn; hidden, its cells are the tile's body, and moving onto +// them is hovering the tile, which draws it. +func wallTileHits(pal palette, v wallView, t wallTile, i int, focused bool, x0, y0, w, h int) []wallHit { + look := wallLookFor(pal, v, t, i, focused) + var hits []wallHit + // row lays one border row's targets: the tile, cut around each control. + row := func(y int, ctls []wallHit) { + at := x0 + for _, c := range ctls { + if c.x0 > at { + hits = append(hits, wallHit{x0: at, y0: y, x1: c.x0, y1: y + 1, kind: wallHitTile, arg: i}) + } + c.y0, c.y1, c.arg = y, y+1, i + hits = append(hits, c) + at = c.x1 + } + if at < x0+w { + hits = append(hits, wallHit{x0: at, y0: y, x1: x0 + w, y1: y + 1, kind: wallHitTile, arg: i}) + } + } + var top []wallHit + if look.boxOn && wallSelFits(w) && w >= 5 { + top = append(top, wallHit{x0: x0 + 2, x1: x0 + 2 + wallSelW, kind: wallHitSelect}) + } + row(y0, top) + if h <= 1 { + return hits + } + body := func(ya, yb, xa, xb int) { + if yb > ya && xb > xa { + hits = append(hits, wallHit{x0: xa, y0: ya, x1: xb, y1: yb, kind: wallHitTile, arg: i}) + } + } + // A waiting tile's Answer is the tile's open, cut out of the body around + // it so the two never share a cell. + last := y0 + h - 1 + if dx, dy, bw, ok := wallAnswerAt(pal.ascii, t, w, h); ok && y0+dy < last { + ay := y0 + dy + body(y0+1, ay, x0, x0+w) + body(ay, ay+1, x0, x0+dx) + hits = append(hits, wallHit{x0: x0 + dx, y0: ay, x1: x0 + dx + bw, y1: ay + 1, kind: wallHitOpen, arg: i}) + body(ay, ay+1, x0+dx+bw, x0+w) + body(ay+1, last, x0, x0+w) + } else { + body(y0+1, last, x0, x0+w) + } + var bottom []wallHit + if look.rowOn { + for _, act := range wallTileActs(pal.ascii, t, w) { + bottom = append(bottom, wallHit{x0: x0 + act.x, x1: x0 + act.x + wallButtonW(act.btn), kind: act.kind}) + } + } + row(last, bottom) + return hits +} + +// ── CARDS ─────────────────────────────────────────────────────────────────── + +// wallCard is a rounded card floated over the grid: its rows, its top-left +// cell, its width, and its own targets in frame cells. +type wallCard struct { + rows []string + x, y int + w int + hits []wallHit + // over is how far a scrolled card's lines can scroll, zero for a card + // that fits, and top the first of them it shows. + over int + top int +} + +// wallCardLine is one row inside a card: painted words, and the targets on +// them in cells from the row's first inner cell. A rule line is drawn as the +// card's own divider. +type wallCardLine struct { + s string + hits []wallHit + rule bool + // bleed gives the line one cell of the padding either side, for a row of + // buttons: a button's ground sits outside its word, so its word lines up + // with the text above and its ground with nothing. + bleed bool +} + +// wallCardBuild draws a card w wide at x,y: a title on the top border, then +// the lines, each padded padX cells inside the border and padY blank rows +// above and below them, cut to fit. +func wallCardBuild(pal palette, title string, lines []wallCardLine, x, y, w, padX, padY int) wallCard { + box := wallBoxLight + if pal.ascii { + box = wallBoxLightASCII + } + border := pal.muted + inner := w - 2 - 2*padX + card := wallCard{x: x, y: y, w: w} + top := border(box.tl + strings.Repeat(box.h, w-2) + box.tr) + if title != "" { + t := " " + title + " " + top = border(box.tl+box.h) + pal.ink(t) + border(strings.Repeat(box.h, max(w-3-ansi.StringWidth(t), 0))+box.tr) + } + card.rows = append(card.rows, top) + pad := strings.Repeat(" ", padX) + blank := border(box.v) + strings.Repeat(" ", max(w-2, 0)) + border(box.v) + for range padY { + card.rows = append(card.rows, blank) + } + for _, ln := range lines { + k := len(card.rows) - 1 + if ln.rule { + card.rows = append(card.rows, border(box.v)+pad+pal.dim(strings.Repeat(box.h, inner))+pad+border(box.v)) + continue + } + lw, lpad := inner, padX + if ln.bleed && padX > 0 { + lw, lpad = inner+2, padX-1 + } + side := strings.Repeat(" ", lpad) + card.rows = append(card.rows, border(box.v)+side+wallFit(ln.s, lw)+side+border(box.v)) + for _, h := range ln.hits { + if h.x1 > lw { + continue + } + h.x0 += x + 1 + lpad + h.x1 += x + 1 + lpad + h.y0, h.y1 = y+1+k, y+2+k + card.hits = append(card.hits, h) + } + } + for range padY { + card.rows = append(card.rows, blank) + } + card.rows = append(card.rows, border(box.bl+strings.Repeat(box.h, w-2)+box.br)) + return card +} + +// A card's padding: two cells inside its border either side and one blank row +// above and below, the same for every card and popover, so each reads as the +// same kind of thing. The tray is a floating toolbar and keeps the toolbar's +// single row. +const ( + wallCardPadX = 2 + wallCardPadY = 1 +) + +// wallTray is the selection tray: while any conversation is picked, a floating +// toolbar docked on the foot's rule says how many, and holds everything that +// can be done to them, the most used first. +func wallTray(pal palette, g wallGlyphs, v wallView, width, height int) wallCard { + n := wallMarked(v) + if n == 0 || height < 8 { + return wallCard{} + } + k := wallKeysFor(pal.ascii) + word := strconv.Itoa(n) + " selected" + lead := pal.accent(g.marked) + " " + pal.ink(word) + " " + leadW := ansi.StringWidth(g.marked) + 1 + len(word) + 2 + bs := []wallButton{ + {act: wallActMakeTeam, label: "Make team", key: "s"}, + {act: wallActAddTo, label: "Add to" + k.more + " " + k.caret}, + {act: wallActCloseViews, label: "Close views"}, + {act: wallActClear, label: "Clear", key: "esc"}, + } + room := width - 2 - 2 - 2*wallCardPadX + // Close views leaves first, then Add to: Make team and Clear are the two a + // selection cannot do without. + for _, act := range []wallAct{wallActCloseViews, wallActAddTo} { + if leadW+wallBarWidth(bs, 1) <= room { + break + } + for i, b := range bs { + if b.act == act { + bs = append(bs[:i], bs[i+1:]...) + break + } + } + } + if leadW+wallBarWidth(bs, 1) > room { + return wallCard{} + } + s, bw, hits := wallLay(pal, bs, v.hover, leadW, 0, 1) + w := leadW + bw + 2 + 2*wallCardPadX + x := (width - w) / 2 + // Its bottom border lies on the foot's rule, so the tray reads as risen + // out of the foot and never covers the toolbar. + y := height - wallFootRows - 1 + return wallCardBuild(pal, "", []wallCardLine{{s: lead + s, hits: hits}}, x, y, w, wallCardPadX, 0) +} + +// wallNamingWord is what the card says while a name is asked for, with the +// two cells that part it from the field. +func wallNamingWord(ascii bool) string { + if ascii { + return " naming..." + } + return " naming…" +} + +// wallNameCardRows is the new-team card's height: two borders, the padding +// above and below, and four lines. +const wallNameCardRows = 2 + 2*wallCardPadY + 4 + +// wallNameCardFits reports whether the new-team card has room on a frame. +func wallNameCardFits(width, height int) bool { + return width >= 44 && height >= wallChromeRows+wallNameCardRows+2 +} + +// wallSwatches is a row of colour choices, the one taken drawn ringed, and a +// target on each. It says how wide it is. +func wallSwatches(pal palette, v wallView, choices []teamHueSpec, choice, x int) (string, int, []wallHit) { + var b strings.Builder + var hits []wallHit + w := 0 + for j, c := range choices { + if j > 0 { + b.WriteString(" ") + w++ + } + glyph := "●" + if j == choice { + glyph = "◉" + } + ink := pal.teamInk(c) + switch { + case ink != nil: + glyph = ink(glyph) + case j == choice: + glyph = pal.ink("@") + default: + glyph = pal.dim("o") + } + if v.hover.kind == wallHitSwatch && v.hover.arg == j { + glyph = pal.background(glyph, 0, pal.ramp.mark) + } + b.WriteString(glyph) + hits = append(hits, wallHit{x0: x + w, y0: 0, x1: x + w + 1, y1: 1, kind: wallHitSwatch, arg: j}) + w++ + } + return b.String(), w, hits +} + +// wallNameCard is the card a new team is named in: +// +// ╭─ New team ────────────────────────────────────╮ +// │ │ +// │ Name harbor▌ ↻ Shuffle │ +// │ Colour ◉ ● ● ● ● ● │ +// │ 3 · the tree walk, ship the port, relay au… │ +// │ Cancel esc Create ↵ │ +// │ │ +// ╰────────────────────────────────────────────────╯ +// +// A name the wall filled in is drawn selected, as a text field draws a +// suggestion: the first key typed replaces it. +func wallNameCard(pal palette, g wallGlyphs, v wallView, width, height int) wallCard { + if !wallNameCardFits(width, height) { + return wallCard{} + } + k := wallKeysFor(pal.ascii) + w := min(60, width-4) + inner := w - 2 - 2*wallCardPadX + + shuffle := wallButton{act: wallActShuffle, label: k.shuffle + " Shuffle", key: "ctrl+r"} + if inner < 46 { + shuffle.key = "" + } + sw := wallButtonW(shuffle) + const labelW = 8 + nameRoom := max(inner-labelW-sw-2-ansi.StringWidth(g.cursor), 1) + name := v.name + if ansi.StringWidth(name) > nameRoom { + // The end of a long name is the part being typed. + name = ansi.TruncateLeft(name, ansi.StringWidth(name)-nameRoom, "") + } + field := pal.ink(name) + if v.nameFresh && name != "" { + field = pal.selected(pal.ink(name), 0) + } + field += pal.ink(g.cursor) + fieldW := labelW + ansi.StringWidth(name) + ansi.StringWidth(g.cursor) + // While a better name is asked for, the card says so, quietly, beside the + // field, and only where it fits whole. + if v.asking { + word := wallNamingWord(pal.ascii) + if ww := ansi.StringWidth(word); inner+1-sw-fieldW >= ww+1 { + field += pal.dim(word) + fieldW += ww + } + } + // The Name row and the button row bleed (wallCardLine), so Shuffle and + // Create end on the text's right edge; the label takes the cell back. + s, _, sh := wallLay(pal, []wallButton{shuffle}, v.hover, inner+2-sw, 0, 1) + l1 := wallCardLine{s: " " + pal.dim("Name ") + field + strings.Repeat(" ", max(inner+1-sw-fieldW, 0)) + s, hits: sh, bleed: true} + + sws, _, swh := wallSwatches(pal, v, v.choices, v.choice, labelW) + l2 := wallCardLine{s: pal.dim("Colour ") + sws, hits: swh} + + var names []string + for _, t := range v.tiles { + if t.marked { + names = append(names, t.name) + } + } + who := strconv.Itoa(len(names)) + " " + g.sep + " " + strings.Join(names, ", ") + if ansi.StringWidth(who) > inner { + who = ansi.Truncate(who, inner, g.more) + } + l3 := wallCardLine{s: pal.dim(who)} + + bs := []wallButton{ + {act: wallActCancel, label: "Cancel", key: "esc"}, + {act: wallActSave, label: "Create", key: k.enter}, + } + bw := wallBarWidth(bs, 1) + bstr, _, bh := wallLay(pal, bs, v.hover, inner+2-bw, 0, 1) + l4 := wallCardLine{s: strings.Repeat(" ", max(inner+2-bw, 0)) + bstr, hits: bh, bleed: true} + + x := (width - w) / 2 + gridH := height - wallChromeRows + y := wallGridTop + max((gridH-wallNameCardRows)/2, 0) + title := "New team" + if v.nameIn != "" { + title += " in " + v.nameIn + } + return wallCardBuild(pal, title, []wallCardLine{l1, l2, l3, l4}, x, y, w, wallCardPadX, wallCardPadY) +} + +// ── POPOVERS ──────────────────────────────────────────────────────────────── + +// wallPopCard is the popover that is up, hung under the control that opened +// it with its left border under the control's first cell, or over the +// control when there is no room below. It stays a margin inside the frame's +// sides, and never reaches the foot's rule or the toolbar under it. +func wallPopCard(pal palette, g wallGlyphs, v wallView, width, height int) wallCard { + var title string + var lines []wallCardLine + var inner int + switch v.pop.kind { + case wallPopMembers: + title, lines, inner = wallMembersLines(pal, g, v) + case wallPopSettings: + title, lines, inner = wallSettingsLines(pal, g, v) + default: + return wallCard{} + } + w := inner + 2 + 2*wallCardPadX + h := len(lines) + 2 + 2*wallCardPadY + floor := height - wallFootRows + 1 // the first row a card may not cover + if w > width-2*wallMargin || h > floor { + return wallCard{} + } + x := min(max(v.pop.x, wallMargin), width-wallMargin-w) + y := v.pop.y1 + if y+h > floor { + y = v.pop.y0 - h + } + y = min(max(y, 0), floor-h) + return wallCardBuild(pal, title, lines, x, y, w, wallCardPadX, wallCardPadY) +} + +// wallPopRowPaint lays one popover row across the inner width, on the cursor +// ground when the keyboard or the pointer is on it. +func wallPopRowPaint(pal palette, s string, inner int, lit bool) string { + s = wallFit(s, inner) + if lit { + return pal.cursor(s, 0) + } + return s +} + +// wallMembersLines is the teams popover: every team with a box saying +// whether the targets are in it (partly, when some are and some are not), +// and a way to a new one. It is a menu, so a box pressed is saved at once +// and there is no button to confirm it. +// +// ╭─ Teams ───────────────────╮ +// │ │ +// │ ☑ ● harbor 3 │ +// │ ☐ ● orbit 5 │ +// │ ──────────────────────── │ +// │ + New team… │ +// │ │ +// ╰────────────────────────────╯ +func wallMembersLines(pal palette, g wallGlyphs, v wallView) (string, []wallCardLine, int) { + k := wallKeysFor(pal.ascii) + in := map[string][]string{} + for _, t := range v.tiles { + in[t.tab.key] = t.teams + } + inner := 24 + for _, t := range v.teams { + inner = max(inner, ansi.StringWidth(k.boxOff)+3+min(ansi.StringWidth(t.name), wallChipCap)+6) + } + // The manager's row says which team and what it replaces, so the card is + // as wide as that sentence, up to a width a popover can hold. + if v.popManager != 0 { + inner = max(inner, min(ansi.StringWidth(v.popManagerWord), 56)) + } + var lines []wallCardLine + row := func(code int, id, s string, cursorAt int) { + lit := v.pop.cursor == cursorAt || v.hover == wallHitRef{kind: wallHitPopRow, arg: code, id: id} + lines = append(lines, wallCardLine{ + s: wallPopRowPaint(pal, s, inner, lit), + hits: []wallHit{{x0: 0, y0: 0, x1: inner, y1: 1, kind: wallHitPopRow, arg: code, id: id}}, + }) + } + for i, t := range v.teams { + held := 0 + for _, key := range v.pop.targets { + for _, id := range in[key] { + if id == t.id { + held++ + } + } + } + name := t.name + box := pal.muted(k.boxOff) + switch { + case held > 0 && held == len(v.pop.targets): + box = pal.ink(k.boxOn) + case held > 0: + box = pal.ink(k.boxSome) + } + if ansi.StringWidth(name) > wallChipCap { + name = ansi.Truncate(name, wallChipCap, g.more) + } + left := box + " " + wallTeamMark(pal, v, i, "●") + " " + pal.ink(name) + cs := strconv.Itoa(t.count) + gap := inner - ansi.StringWidth(left) - len(cs) + row(wallPopTeam, t.id, left+strings.Repeat(" ", max(gap, 1))+pal.dim(cs), i) + } + if len(v.teams) > 0 { + lines = append(lines, wallCardLine{rule: true}) + } + row(wallPopNew, "", pal.muted("+ New team"+k.more), len(v.teams)) + if v.popManager != 0 { + word := v.popManagerWord + if word == "" { + word = v.mark + " Make manager" + } + if ansi.StringWidth(word) > inner { + word = ansi.Truncate(word, inner, wallGlyphsFor(pal.ascii).more) + } + row(wallPopManager, "", pal.muted(word), len(v.teams)+1) + } + return "Teams", lines, inner +} + +// wallPopButton is one button in a popover's last row, as a popover row: a +// press is a wallHitPopRow with its code. danger draws the label in the +// failure red, which is kept for the one act that cannot be undone. +type wallPopButton struct { + label, key string + code int + danger bool +} + +// wallPopButtons lays buttons one cell apart at the right, primary last, and +// lead at the left when it is given. The row bleeds, so the words line up +// with the text above on both sides. +func wallPopButtons(pal palette, v wallView, inner int, lead *wallPopButton, bs ...wallPopButton) wallCardLine { + paint := func(b wallPopButton) (string, int) { + w := 2 + ansi.StringWidth(b.label) + ink := pal.ink + if b.danger { + ink = pal.bad + } + s := " " + ink(b.label) + if b.key != "" { + s += " " + pal.dim(b.key) + w += 1 + ansi.StringWidth(b.key) + } + s += " " + if v.hover.kind == wallHitPopRow && v.hover.arg == b.code { + s = pal.cursor(s, 0) + } + return s, w + } + ln := wallCardLine{bleed: true} + inner += 2 // the line bleeds into the padding (wallCardLine) + var b strings.Builder + x := 0 + if lead != nil { + s, w := paint(*lead) + b.WriteString(s) + ln.hits = append(ln.hits, wallHit{x0: 0, x1: w, y1: 1, kind: wallHitPopRow, arg: lead.code}) + x = w + } + rw := 0 + for i, bt := range bs { + _, w := paint(bt) + if i > 0 { + rw++ + } + rw += w + } + b.WriteString(strings.Repeat(" ", max(inner-x-rw, 1))) + x = max(inner-rw, x+1) + var right []wallHit + for i, bt := range bs { + if i > 0 { + b.WriteString(" ") + x++ + } + s, w := paint(bt) + b.WriteString(s) + right = append(right, wallHit{x0: x, x1: x + w, y1: 1, kind: wallHitPopRow, arg: bt.code}) + x += w + } + // The primary's target is listed first of the right-hand ones, so a + // search of the targets by kind alone meets the primary before the rest. + for i := len(right) - 1; i >= 0; i-- { + ln.hits = append(ln.hits, right[i]) + } + ln.s = b.String() + return ln +} + +// wallSettingsLines is a team's settings: its name, being edited as it is +// typed, its colour among the others it could have, and at the foot its +// deletion on the left and Done on the right. The deletion asks first and +// says the conversations stay open. +// +// ╭─ Team ──────────────────────────╮ +// │ │ +// │ Name port▌ │ +// │ Colour ◉ ● ● ● ● ● │ +// │ ────────────────────────────── │ +// │ Delete team Done ↵ │ +// │ │ +// ╰──────────────────────────────────╯ +func wallSettingsLines(pal palette, g wallGlyphs, v wallView) (string, []wallCardLine, int) { + k := wallKeysFor(pal.ascii) + name := "" + if i := v.teamRow(v.pop.team); i >= 0 { + name = v.teams[i].name + } + inner := 30 + const labelW = 8 + field := v.pop.name + if room := inner - labelW - 1; ansi.StringWidth(field) > room { + field = ansi.TruncateLeft(field, ansi.StringWidth(field)-room, "") + } + l1 := wallCardLine{s: pal.dim("Name ") + pal.ink(field) + pal.ink(g.cursor)} + sws, _, swh := wallSwatches(pal, v, v.pop.choices, v.pop.choice, labelW) + l2 := wallCardLine{s: pal.dim("Colour ") + sws, hits: swh} + lines := []wallCardLine{l1, l2, {rule: true}} + if !v.pop.confirm { + del := wallPopButton{label: "Delete team", code: wallPopDelete, danger: true} + lines = append(lines, wallPopButtons(pal, v, inner, &del, wallPopButton{label: "Done", key: k.enter, code: wallPopDone})) + return "Team settings", lines, inner + } + ask := "Delete " + name + "?" + if ansi.StringWidth(ask) > inner { + ask = ansi.Truncate(ask, inner, g.more) + } + lines = append(lines, + wallCardLine{s: pal.ink(ask)}, + wallCardLine{s: pal.dim("Its conversations stay open.")}, + wallCardLine{}, + wallPopButtons(pal, v, inner, nil, + wallPopButton{label: "Keep", key: "esc", code: wallPopKeep}, + wallPopButton{label: "Delete", code: wallPopConfirm, danger: true})) + return "Team settings", lines, inner +} + +// ── LAYING A CARD OVER THE FRAME ──────────────────────────────────────────── + +// wallSplice lays a card's row over a frame row at column x. The row is padded +// to the frame's width first, so a card can float over a blank row, and the +// card is fenced by resets so no ground leaks in or out of it. +func wallSplice(row, card string, x, width int) string { + row = wallFit(row, width) + cw := ansi.StringWidth(card) + left := ansi.Cut(row, 0, x) + right := ansi.Cut(row, x+cw, width) + if !strings.Contains(row, "\x1b") && !strings.Contains(card, "\x1b") { + return left + card + right + } + return left + "\x1b[0m" + card + "\x1b[0m" + right +} + +// wallCarve takes the rectangle x0,y0..x1,y1 out of every hit, keeping what is +// left of each around it, so nothing under a card answers the pointer. A +// control the card covers any of is dropped whole: a sliver of a button left +// beside a card is a target on a cell that no longer says what it does. +func wallCarve(hits []wallHit, x0, y0, x1, y1 int) []wallHit { + out := make([]wallHit, 0, len(hits)) + for _, h := range hits { + if h.x1 <= x0 || h.x0 >= x1 || h.y1 <= y0 || h.y0 >= y1 { + out = append(out, h) + continue + } + if h.kind != wallHitTile { + continue + } + if h.y0 < y0 { + a := h + a.y1 = y0 + out = append(out, a) + } + if h.y1 > y1 { + a := h + a.y0 = y1 + out = append(out, a) + } + mid := h + mid.y0, mid.y1 = max(h.y0, y0), min(h.y1, y1) + if h.x0 < x0 { + a := mid + a.x1 = x0 + out = append(out, a) + } + if h.x1 > x1 { + a := mid + a.x0 = x1 + out = append(out, a) + } + } + return out +} + +// wallOverlay lays a card over the frame: its rows spliced in, what it covers +// taken out of the hits, its own targets added. +func wallOverlay(rows []string, hits []wallHit, card wallCard, width int) []wallHit { + if len(card.rows) == 0 { + return hits + } + for dy, cr := range card.rows { + if y := card.y + dy; y >= 0 && y < len(rows) { + rows[y] = wallSplice(rows[y], cr, card.x, width) + } + } + hits = wallCarve(hits, card.x, card.y, card.x+card.w, card.y+len(card.rows)) + return append(hits, card.hits...) +} diff --git a/internal/tui3/wallclick_test.go b/internal/tui3/wallclick_test.go new file mode 100644 index 0000000000..9f7c613172 --- /dev/null +++ b/internal/tui3/wallclick_test.go @@ -0,0 +1,231 @@ +package tui3 + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" +) + +// wallHitFor is the first target of kind and arg on the wall as it was last +// drawn. The arg is matched exactly: a negative one is a real target (the All +// chip is -1, the popover's delete rows are below it), never a wildcard. +func wallHitFor(t *testing.T, a *app, kind wallHitKind, arg int) wallHit { + t.Helper() + for _, hit := range a.wall.hits { + if hit.kind == kind && hit.arg == arg { + return hit + } + } + t.Fatalf("no target %d/%d on the wall:\n%s", kind, arg, wallPlainFrame(a.wallFrame(a.width, a.height))) + return wallHit{} +} + +// wallHitForTeam is the target of kind on team id ("" for All) on the last +// frame. +func wallHitForTeam(t *testing.T, a *app, kind wallHitKind, id string) wallHit { + t.Helper() + for _, hit := range a.wall.hits { + if hit.kind == kind && hit.id == id { + return hit + } + } + t.Fatalf("no target %d/%q on the wall:\n%s", kind, id, wallPlainFrame(a.wallFrame(a.width, a.height))) + return wallHit{} +} + +// wallClick moves the pointer onto a target, repaints, and presses it, the +// order a hand does it in. +func wallClick(t *testing.T, a *app, hit wallHit) tea.Cmd { + t.Helper() + a.wallMotion(hit.x0, hit.y0) + _ = a.wallFrame(a.width, a.height) + cmd, took := a.wallPress(hit.x0, hit.y0) + if !took { + t.Fatalf("the wall did not take a press on %+v", hit) + } + _ = a.wallFrame(a.width, a.height) + return cmd +} + +// A HAND CAN DO WHAT THE KEYS DO: pick two tiles with their boxes, make a team +// of them from the tray, keep the name the wall offered, and land in it. +func TestWallClickPicksTilesAndMakesATeam(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + if n := len(a.wallShown(a.now())); n < 2 { + t.Fatalf("%d tiles", n) + } + + // The box is revealed by the hover, then pressed. + body := wallHitFor(t, a, wallHitTile, 1) + a.wallMotion(body.x0+4, body.y0+2) + _ = a.wallFrame(a.width, a.height) + wallClick(t, a, wallHitFor(t, a, wallHitSelect, 1)) + if len(a.wall.marked) != 1 { + t.Fatalf("the box marked %d tiles", len(a.wall.marked)) + } + // Selection mode: a press on another tile's body picks it too. + wallClick(t, a, wallHitFor(t, a, wallHitTile, 0)) + if len(a.wall.marked) != 2 { + t.Fatalf("a press in selection mode marked %d tiles", len(a.wall.marked)) + } + if !strings.Contains(wallPlainFrame(a.wallFrame(a.width, a.height)), "2 selected") { + t.Fatal("no tray") + } + + wallClick(t, a, wallHitFor(t, a, wallHitAction, int(wallActMakeTeam))) + if !a.wall.naming || a.wall.name == "" || !a.wall.nameFresh { + t.Fatalf("make team opened no card with a name in it: naming=%v name=%q", a.wall.naming, a.wall.name) + } + offered := a.wall.name + // While the card is up nothing under it answers. + if cmd := a.wallDo(wallHit{kind: wallHitAction, arg: int(wallActClear)}); cmd != nil || len(a.wall.marked) != 2 { + t.Fatal("the card let a press through") + } + wallClick(t, a, wallHitFor(t, a, wallHitAction, int(wallActSave))) + if a.wall.naming || a.wall.activeID != "" || len(a.wall.teams) == 0 || a.wall.teams[len(a.wall.teams)-1].Name != offered { + t.Fatalf("create did not make %q and stay in the view: %+v active=%q", offered, a.wall.teams, a.wall.activeID) + } + if len(a.wall.marked) != 0 || a.wall.made != offered { + t.Fatalf("after create: marked=%v made=%q", a.wall.marked, a.wall.made) + } + if !strings.Contains(ansi.Strip(a.wallFrame(a.width, a.height)[a.wall.headRows+1]), "Made "+offered) { + t.Fatal("the chips row does not say the team was made") + } + + // The chip for all widens the wall again, and the typed name replaces the + // offered one. + wallClick(t, a, wallHitForTeam(t, a, wallHitChip, "")) + if a.wall.activeID != "" { + t.Fatalf("the all chip left team %q active", a.wall.activeID) + } + a.wallKey(tea.KeyPressMsg{Code: 's', Text: "s"}) + a.wallKey(tea.KeyPressMsg{Code: 'q', Text: "q"}) + if a.wall.name != "q" { + t.Fatalf("the first key did not replace the offered name: %q", a.wall.name) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + // esc with tiles picked clears the pick before it closes anything. + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + if !a.wall.on || len(a.wall.marked) != 0 { + t.Fatalf("esc: on=%v marked=%v", a.wall.on, a.wall.marked) + } +} + +// A CONVERSATION'S TEAMS ARE A CLICK AWAY: its ●+ opens the popover, a box +// puts it in a team and takes it out again, and a team's dot opens its +// settings, where it is renamed, recoloured and deleted, the last only once +// the question is answered. +func TestWallClickTeamsPopoverAndSettings(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + harbor, err := a.teamMake("harbor", []chatTab{tiles[0].tab}) + if err != nil { + t.Fatal(err) + } + orbit, err := a.teamMake("orbit", []chatTab{tiles[0].tab}) + if err != nil { + t.Fatal(err) + } + _ = a.wallFrame(a.width, a.height) + key := tiles[1].tab.key + + // Hover the tile so its controls are drawn, then press its ●+. + body := wallHitFor(t, a, wallHitTile, 1) + a.wallMotion(body.x0+4, body.y0+3) + _ = a.wallFrame(a.width, a.height) + wallClick(t, a, wallHitFor(t, a, wallHitTeams, 1)) + if a.wall.pop.kind != wallPopMembers || len(a.wall.pop.targets) != 1 || a.wall.pop.targets[0] != key { + t.Fatalf("the popover: %+v", a.wall.pop) + } + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + if !strings.Contains(frame, "☐ ● harbor") || !strings.Contains(frame, "+ New team") { + t.Fatalf("the popover is not drawn:\n%s", frame) + } + wallClick(t, a, wallHitForTeam(t, a, wallHitPopRow, orbit)) + if got := a.teamsOf(key); len(got) != 1 || got[0] != orbit { + t.Fatalf("after one box the conversation is in %v", got) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyUp}) + a.wallKey(tea.KeyPressMsg{Code: tea.KeySpace, Text: " "}) + if got := a.teamsOf(key); len(got) != 2 { + t.Fatalf("after the keyboard's box the conversation is in %v", got) + } + a.wallKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + if a.wall.pop.kind != wallPopNone || !a.wall.on { + t.Fatal("esc did not put the popover away, or took the whole view with it") + } + + // The dot on a segment opens that team's settings. + _ = a.wallFrame(a.width, a.height) + wallClick(t, a, wallHitForTeam(t, a, wallHitChipMenu, harbor)) + // The team's card (teamsheet.go), over the wall. + if !a.tsheet.on || a.tsheet.team != harbor || a.tsheet.name.String() != "harbor" { + t.Fatalf("settings: %+v", a.tsheet) + } + before := a.wall.teams[0].HueSpec() + a.teamSheetDo(tsSwatch + 2) + if a.wall.teams[0].HueSpec() == before { + t.Fatal("a swatch did not recolour the team") + } + a.tsheet.cursor = tsName + for range "harbor" { + a.teamSheetKey(tea.KeyPressMsg{Code: tea.KeyBackspace}) + } + for _, r := range "dock" { + a.teamSheetKey(tea.KeyPressMsg{Code: r, Text: string(r)}) + } + a.teamSheetKey(tea.KeyPressMsg{Code: tea.KeyEscape}) + if a.wall.teams[0].Name != "dock" || a.tsheet.on { + t.Fatalf("rename: %q, card %+v", a.wall.teams[0].Name, a.tsheet) + } + _ = a.wallFrame(a.width, a.height) + // The card's `Close team…` closes it (ruling c-9: a team is deleted only + // once closed, from the teams page), and the wall's Teams row drops it. + wallClick(t, a, wallHitForTeam(t, a, wallHitChipMenu, harbor)) + a.teamSheetDo(tsCloseTeam) + if got, ok := a.teamByID(harbor); !ok || !got.Closed() { + t.Fatalf("Close team did not close it: %+v", a.teamNames()) + } + if shown := a.wallTeams(); len(shown) != 1 || shown[0].Name != "orbit" { + t.Fatalf("after the close the wall lists %d teams", len(shown)) + } + if len(a.wallShown(a.now())) != len(tiles) { + t.Fatal("closing a team closed a conversation on the wall") + } +} + +// WHILE A TEAM NARROWS THE STRIP, THE STRIP SAYS WHICH: a chip at its left +// end, which opens the team switcher (teammenu.go). +func TestTabTeamChipNamesTheShownTeam(t *testing.T) { + a, _, _ := tabApp(t) + plainRow := plain(a.tabsRow(a.width)) + if strings.Contains(plainRow, "▾") { + t.Fatalf("a chip with no team shown: %q", plainRow) + } + tabs := a.tabList() + i, err := a.teamMake("harbor", tabs[:1]) + if err != nil { + t.Fatal(err) + } + a.wall.activeID = i + a.touch() + row := plain(a.tabsRow(a.width)) + if !strings.Contains(row, "● harbor ▾") || !a.wall.chip.pressable() { + t.Fatalf("no chip: %q %+v", row, a.wall.chip) + } + for _, hit := range a.chatTabHits { + if hit.span.from < a.wall.chip.to { + t.Fatalf("a tab was drawn under the chip: %+v", hit) + } + } + if _, took := a.tabPress(a.wall.chip.from+1, tabStripRow); !took || !a.teamMenu.on || a.wall.on { + t.Fatal("the chip did not open the team switcher") + } + t.Logf("%q", row) +} diff --git a/internal/tui3/wallcontract.go b/internal/tui3/wallcontract.go new file mode 100644 index 0000000000..948e0e6c99 --- /dev/null +++ b/internal/tui3/wallcontract.go @@ -0,0 +1,445 @@ +package tui3 + +import ( + "time" + + "github.com/Agent-Field/codeaf/internal/session" + teamstore "github.com/Agent-Field/codeaf/internal/teams" +) + +// ── THE WALL AND ITS TEAMS: THE SHAPES THE THREE HALVES AGREE ON ─────────── +// +// The wall is a full-frame grid of every conversation this window has a tab +// for, each drawn as a tile holding the live tail of its transcript. A team is +// a named set of those conversations that the tab strip can be narrowed to. +// +// The wall is built in three halves that meet only through the types in this +// file: the reading (walltail.go) turns what this process holds into tiles, +// the painting (wallview.go) turns tiles into rows, and the teams +// (teams.go, teamhue.go) keep the named sets and their colours on disk. The +// wiring (wall.go, wallpop.go) is the only part that touches the app's keys, +// frame and pointer; the strip draws the wall's toggle and the shown team's +// chip itself (chattabs.go). +// +// THE FRAME LAW HOLDS HERE AS EVERYWHERE (framedisk_law_test.go): nothing a +// frame calls opens a file, crosses a wire or takes an agent's mutex. Tails +// are read on a stir or an opening and cached; the painter draws the cache. + +// wallLineKind is what one tail line is, which is all that decides its ink. +type wallLineKind uint8 + +const ( + wallProse wallLineKind = iota // the assistant's words + wallTool // one tool call, folded to one line: `▸ bash go test ./...` + wallUser // what the person said + wallNote // a session aside or a compaction note +) + +// wallLine is one logical line of a tile's tail, NOT yet fit to any width. +// The painter wraps and cuts; the reader never knows how wide a tile is. +type wallLine struct { + kind wallLineKind + text string +} + +// wallSparkLen is how many activity samples a tile keeps, one per second. +const wallSparkLen = 24 + +// wallTile is one conversation as the wall draws it. +type wallTile struct { + // tab is the strip's own record of this conversation. The wall's doors are + // the strip's doors: enter is [app.tabGo] and x is [app.tabDismiss]. + tab chatTab + name string + here bool + // signal is [app.tabSignalFor]'s reading, never a second one. + signal tabSignal + // live is false for a tile whose tail is a snapshot this window cannot + // refresh: over a shared engine handle only the front conversation is + // live. A frozen tile draws no spinner and no sparkline, and says `seen`. + live bool + // seen is when the tail was last read. + seen time.Time + // age is time since the conversation last moved, spelled short ("2m"); + // "" when unknown. + age string + // lines is the tail, oldest first, at most wallTailCap logical lines. + lines []wallLine + // fresh is how many of the LAST lines arrived since the previous reading; + // the painter lifts them to ink and lets them settle. + fresh int + // freshAt is when those lines arrived, for the settle. + freshAt time.Time + // spark is activity per second, oldest first, each 0..7, len <= wallSparkLen. + // All zeros (or empty) draws no sparkline: the emptiness law. + spark []uint8 + // question is the one-line ask when signal is tabNeedsPerson, "" otherwise. + question string + // marked is picked for a new team. + marked bool + // manager says this is the manager of the team shown, pinned first and + // marked before its name (teammanager.go). + manager bool + // rows is the tail drawn the way the conversation itself draws it + // (wallmini.go), already painted and fit to the body's width. When it is + // set the painter draws it in place of lines. + rows []string + // doing is what a working conversation is doing now, `running bash`, + // `writing`, `waiting on you`; "" at rest (wallmini.go's [wallDoing]). + doing string + // moved is when the conversation last grew; zero when this window has not + // seen it move. + moved time.Time + // teams is the id of every team this conversation is in. A conversation + // may be in several. + teams []string +} + +// wallTailCap is the most logical lines a reading keeps per conversation. +const wallTailCap = 40 + +// wallView is everything the painter needs, and nothing it may go and get. +type wallView struct { + // team is the active team's id, "" for All, and teams is every team in + // the order the Teams row draws them. + team string + teams []wallTeamRow + tiles []wallTile + focus int + // scroll is the first tile ROW on screen. + scroll int + // cols forces the column count; 0 lets the frame decide. + cols int + // filter is what the person has typed after `/`; filtering says the box is up. + filter string + filtering bool + // naming is the new-team prompt; name is what is typed in it. + naming bool + name string + // spin is the frame's pulse step, for the working mark. + spin int + now time.Time + // reduced turns every settle and every motion off. + reduced bool + // hover is the target the pointer rests on, as the last frame's hits named + // it; the zero ref is no hover. It lights a button and reveals a tile's own + // controls, and it never moves a cell. + hover wallHitRef + // total is how many conversations are open in all. + total int + // away is how many of the shown team's members this window does not have + // open; the title offers to resume them while it is not zero. + away int + // choices is the colours the new-team card offers and choice the one + // taken. + choices []teamHueSpec + choice int + // pop is the popover that is up, if one is. + pop wallPop + // nameFresh says the name in the new-team card is one the wall filled in, + // drawn selected so the first key typed replaces it; asking says a better + // one is being asked for, and the card says `naming…`. + nameFresh bool + asking bool + // nameIn is the team the new team will be made inside, by name, "" for + // the top level (`+ New team in harbor` on the teams page). + nameIn string + // made is the team just made and how many it holds, said on the chip row + // until madeAt is wallMadeFor old. + made string + madeN int + madeAt time.Time + // pointerOn says pointerY holds the row the pointer is on, in the painter's + // own rows (the head's rows taken off). Some targets share a ref on two + // rows, a waiting tile's Answer and its row's Answer, or a picked tile's ☐ + // and its row's Select, and the row says which one to light; left unset, + // both light. + pointerOn bool + pointerY int + // help says the help sheet is up, and helpTop is the first of its lines + // shown when it is scrolled. + help bool + helpTop int + // doorHot says the pointer rests on the strip's own door to this view + // (chattabs.go), which the toolbar explains like any other control. + doorHot bool + // org is Organize's button and card (teamorganize.go). + org wallOrganize + // popManager is the teams popover's manager row for its one conversation + // in the team shown: 0 for none, and otherwise one of wallManagerMake and + // wallManagerRemove (teammanager.go). mark is the manager's glyph. + popManager int + // popManagerWord is that row's words (teammanager.go's + // [app.teamManagerMenuWord]). + popManagerWord string + mark string +} + +// The teams popover's manager row, as [wallView.popManager] says it. +const ( + wallManagerMake = 1 + wallManagerRemove = 2 +) + +// wallTeamRow is one team as the painter draws it: its id, name and colour, +// how many of its members are open in this window, and how many members it +// has in all, open or not. +type wallTeamRow struct { + id string + name string + hue teamHueSpec + count int + members int +} + +// teamRow is where team id sits in v.teams, -1 when it is not there. +func (v wallView) teamRow(id string) int { + for i, t := range v.teams { + if id != "" && t.id == id { + return i + } + } + return -1 +} + +// wallHitKind is what a press on one hit does. +type wallHitKind uint8 + +const ( + wallHitNone wallHitKind = iota + wallHitTile // a tile's body: open it, or pick it in selection mode; arg is the tile + wallHitSelect // a tile's Select, or its ☐ in selection mode: pick it or put it back; arg is the tile + wallHitTeams // a tile's Teams: the teams it is in; arg is the tile + wallHitOpen // a tile's Open, or its Answer; arg is the tile + wallHitClose // a tile's Close, which closes the view; arg is the tile + wallHitChip // a Teams segment; id is the team, "" for All + wallHitChipMenu // a segment's dot or its ⋯: the team's settings; id is the team + wallHitAddTeam // the + New team segment + wallHitAction // a button; arg is a wallAct + wallHitMini // one minimap cell; arg is the tile + wallHitPopRow // a popover row; id is a team (arg wallPopTeam), or arg is a wallPop row code + wallHitSwatch // a colour swatch; arg is its index among the choices + wallHitHelp // a row of the help sheet; arg is its place in [wallHelpList] + wallHitOrgRow // a suggestion on the Organize card; arg is its place in the card +) + +// The popover rows that are not a team. +const ( + wallPopTeam = 0 // a team's row; the hit's id says which + wallPopNew = -1 // + New team… + wallPopDelete = -2 // Delete team + wallPopConfirm = -3 // Delete, confirmed + wallPopKeep = -4 // Keep, the delete undone + wallPopManager = -6 // Make manager, or Remove manager, in the team shown +) + +// wallPopKind is which popover is up. +type wallPopKind uint8 + +const ( + wallPopNone wallPopKind = iota + wallPopMembers // which teams the targets are in + wallPopSettings // one team's name, colour and deletion +) + +// wallPop is a small card anchored to the control that opened it. It is the +// wiring's state and the painter's input at once: everything it draws is here +// or in the view. +type wallPop struct { + kind wallPopKind + // x, y0 and y1 are the anchor: the column it hangs from, and the rows of + // the control, so it can open under it or, short of room, over it. + x, y0, y1 int + // targets is the tiles a members popover acts on, by key. + targets []string + // cursor is the row the keyboard is on. + cursor int + // team, name, choices and choice are the settings popover's: the team's + // id, its name as being edited, the colours offered and the one it has. + team string + name string + choices []teamHueSpec + choice int + // confirm says the delete has been asked for and waits on its answer. + confirm bool +} + +// wallAct is what one button does. Every act that has a key does exactly +// what that key does. +type wallAct int + +const ( + wallActBack wallAct = iota // esc + wallActOpen // enter + wallActSelect // space + wallActNewTeam // s + wallActFilter // / + wallActNext // n + wallActColsLess // - + wallActColsMore // + or = + wallActClose // x + wallActMakeTeam // s, from the tray + wallActAddTo // the teams popover for every picked tile, from the tray + wallActCloseViews // x on every marked tile + wallActClear // unmark all + wallActSave // enter, naming + wallActCancel // esc, naming + wallActFilterClear // esc, filtering + wallActShuffle // ctrl+r, naming + wallActHelp // ? + wallActOrganize // o: the Organize card, on All + wallActOrgUndo // u: the last Organize undone, while it is offered + wallActOrgApply // enter, organizing + wallActOrgCancel // esc, organizing + wallActResume // r: the shown team's members not open here, resumed behind +) + +// wallHitRef names one target without its cells, which is what a hover keeps +// from one frame to the next. +// +// A TARGET ON A TEAM NAMES IT BY ID, in id, and never by its place: a hover +// or a popover that outlives a frame must still mean the same team after one +// is deleted or the row is redrawn in another order. +type wallHitRef struct { + kind wallHitKind + arg int + id string +} + +// wallHit is where one target landed, for the pointer. +type wallHit struct { + x0, y0, x1, y1 int // inclusive-exclusive cell rectangle + kind wallHitKind + arg int // the tile, the act or a popover row code, by kind + id string // the team, for a target on one; "" is All +} + +func (h wallHit) ref() wallHitRef { return wallHitRef{kind: h.kind, arg: h.arg, id: h.id} } + +// onTile reports whether the ref is one of tile i's own targets. +func (r wallHitRef) onTile(i int) bool { + return r.kind >= wallHitTile && r.kind <= wallHitClose && r.arg == i +} + +// team and teamMember are the store's own types (internal/teams), named +// here as the interface has always named them. The store owns the file, the +// ids, the tree, handles and the manager; the interface owns how a team looks. +type ( + team = teamstore.Team + teamMember = teamstore.Member +) + +// wallState is the wall's whole footprint on the app: one field. +type wallState struct { + // frontVer is the front conversation as the wall last read it for its tile + // (walltail.go's [app.wallFrontMoved]). + frontVer wallFrontVer + on bool + focus int + scroll int + cols int + marked map[string]bool // by chatTab.key + filter string + filterOn bool + naming bool + name string + openedAt time.Time + hits []wallHit + // tails is the reading cache, by chatTab.key (walltail.go owns it). + tails map[string]*wallTail + // teams is the loaded set and activeID the id of the one the strip is + // narrowed to, "" for none (teams.go owns both). + teams []team + activeID string + loaded bool + // ticking says a wallTickMsg is already on its way, so an opening never + // starts a second clock beside the first. + ticking bool + // hover is what the pointer rests on, resolved against hits. + hover wallHitRef + // headRows is how many rows the last frame spent above the grid, so a + // pointer can be told apart from the strip without laying the strip out. + headRows int + // pop is the popover that is up; choices and choice are the new-team + // card's colours and the one taken. + pop wallPop + choices []teamHueSpec + choice int + // chip is where the strip drew its team chip, empty when it was not + // drawn. + chip hudSpan + // nameFresh, made, madeN and madeAt are the view's fields of those names. + // nameGen counts the suggestions asked for, so an answer to one the card + // has moved past is dropped, and nameAsking says one is on its way. + nameFresh bool + nameGen int + nameAsking bool + // nameParent is the team a new team is made inside, by id: set by `+ New + // team in harbor` and cleared by every other opening of the card. + nameParent string + made string + madeN int + madeAt time.Time + + // The motion and the pointer's memory (wall.go). revealAt is when the + // opening's row-by-row reveal began, zero once it is done; zoomAt and + // zoomFrom are an opened tile growing into the frame. + revealAt time.Time + zoomAt time.Time + zoomFrom wallRect + // wheelAt and wheelDir are the last wheel step taken, so a trackpad's + // burst moves one row per settle rather than one per event. + wheelAt time.Time + wheelDir int + // ptrX, ptrY and ptrIn are where the pointer last was over the wall, so a + // scroll can light what slid under it; rehover asks the next frame to. + ptrX, ptrY int + ptrIn bool + rehover bool + // stirred says something besides the hover changed since the last frame, + // so a pointer resting on the same target may not reuse that frame. + stirred bool + // places is each team's focus and scroll while the wall is up, by team + // id, "" for All. + places map[string]wallPlace + // card is where the popover or the new-team card was drawn, in frame + // cells, empty when neither is up. + card wallRect + // spinning says the last frame drew a live working tile, whose spinner + // needs the paint clock turning. + spinning bool + // help says the help sheet is up; helpTop is its scroll, and helpMax the + // most it could scroll on the last frame, so a key clamps to what was + // drawn. + help bool + helpTop int + helpMax int + // door is where the strip drew its own door to this view, empty when it + // was not drawn (chattabs.go). + door hudSpan + // org is Organize's card, its suggestions and its Undo (teamorganize.go). + org wallOrganize +} + +// wallTail is one conversation's cached reading (walltail.go fills it). +type wallTail struct { + lines []wallLine + count int // transcript entries seen at the last reading + textLen int // total text length seen, so a growing last entry counts as activity + seen time.Time + fresh int + freshAt time.Time + // spark is a ring of per-second activity, newest at sparkAt. + spark [wallSparkLen]uint8 + sparkAt time.Time + live bool + // recent is the last few entries as they were read, kept so a tile can be + // drawn with the chat's own markdown and tool rows rather than flattened. + recent []session.DisplayEntry + // ver moves whenever the reading changed; the drawn rows are kept against + // it and the width they were drawn at. + ver int + rows []string + rowsW int + rowsVer int +} diff --git a/internal/tui3/walldock.go b/internal/tui3/walldock.go new file mode 100644 index 0000000000..2e22d5ec12 --- /dev/null +++ b/internal/tui3/walldock.go @@ -0,0 +1,442 @@ +package tui3 + +import ( + "strconv" + "strings" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" +) + +// ── THE DOCK: EVERY OPEN CONVERSATION, UNDER THE BOX ──────────────────────── +// +// The wall's door used to be a `⊞` at the right end of the tab strip, which is +// the far end of the frame from where a person's hands are. The owner asked for +// it to come down to where people type, so the row under the box ends in a +// small map of every conversation this window has open: +// +// › say what you want done +// alt+k chats · / commands ▦ All ▪▪▣▪ +// +// `▦ All` is the wall's door, spelled exactly as the strip's own door to it is +// spelled (chattabs.go's [tabWallWord]), and it is ONE BUTTON: the glyph and the +// word are one target, and the pointer's ground covers both. Each cell after it +// is one conversation, in the strip's own order ([app.tabList]), painted by what +// it is doing: the live hue while it works, the warning hue while it waits on a +// person, dim at rest. The one in front is `▣` in ink. A press on a cell goes +// to that conversation by the strip's own door ([app.tabGo]), so a cell can +// never do something its tab would not. +// +// ONE WORD, ONE DOOR, EVERYWHERE. The word here used to be `chats`, and the +// nav's `chats` sits over the same frame and goes somewhere else: back to the +// conversation in front (place_chats.go). Two presses on one word that land in +// two places is a word a person cannot learn, so this door says what it opens, +// in the words the strip already uses for it. +// +// IT READS MEMORY AND NOTHING ELSE. The cells are the strip's list and the +// strip's signals ([app.tabSignalFor]), both of which are the keeper's cached +// facts, because this row is drawn on every frame and the frame may not touch +// the disk (framedisk_law_test.go). +// +// IT IS DRAWN ONLY WHERE IT HAS SOMETHING TO SAY. One conversation is not a +// map, so the dock waits for a second (the emptiness law). It is drawn only on +// the row the keys are drawn on, so never on the wall itself, never on the +// phone's deck, and never on the new-chat frame, which has no keys row. +// +// AND IT TAKES ONLY WHAT THE KEYS LEFT. The keys are how a person drives this +// frame from the keyboard, and the aliveness on a frame with no seam is the +// one fact a frame may never lose (footswap.go), so both are laid out first +// and the dock is fitted into what remains: the word `All` first, then +// fewer cells and a `+N` count, and then no dock at all. The telemetry is on +// the seam, a row the dock never draws on, so no number is ever given up for it. + +// dockCap is how many conversations the dock spells before it counts the rest. +const dockCap = 12 + +// dockFloor is the fewest cells a narrowed dock will draw. Below it the dock is +// dropped whole: one cell and a count is not a map of anything. +const dockFloor = 2 + +// dockLabel is the word after the wall's glyph, the strip's own word for the +// same door ([tabWallWord]). It is ASCII, so its length is its width. +const dockLabel = tabWallWord + +// dockWallWord is what the hint slot says while the pointer rests on the +// strip's own door to the wall (`▦ All`), and the dock's `▦ All` says +// [dockChatsWord], which is the same sentence: they are the same door. +// +// IT SAYS GRID AND TABS, NOT "EVERY CONVERSATION", because the nav's `chats` +// sits right over it on every page and is the place for every conversation +// (topnav.go). Two doors a row apart that both said "every conversation" +// would be one door drawn twice; this one is the tabs open here, side by side. +const dockWallWord = "The grid of your open tabs, and your teams" + hintSegment + wallOpenKey + +// dockChatsWord is what the hint slot says while the pointer rests on the +// dock's `▦ All`. +const dockChatsWord = dockWallWord + +// dockCell is one conversation's cell as it was drawn: its column and its tab. +type dockCell struct { + span hudSpan + tab chatTab +} + +// dockMap is where the dock landed on the last frame, written by the draw and +// read by the pointer (render.go's [hudSpan] bargain): a press resolves against +// what was painted, never against a second computation of it. label is the +// whole door, glyph and word, empty on a row that dropped the word; wall is +// the glyph's own cell, which is the whole door on a row with no word. +type dockMap struct { + label hudSpan + wall hudSpan + cells []dockCell +} + +// dockClear forgets where the dock was drawn, on every frame before the keys +// row is laid out, so a row that draws no dock answers for none. +func (a *app) dockClear() { + a.dock.label = hudSpan{} + a.dock.wall = hudSpan{} + a.dock.cells = a.dock.cells[:0] +} + +// dockTabs is the conversations the dock draws: the strip's list, less the +// new-chat placeholder and the work tab, which are not conversations. The +// slice is the dock's own, refilled in place so a frame allocates nothing +// once the dock has been drawn once. +func (a *app) dockTabs() []chatTab { + // A WINDOW WITH ONE CONVERSATION HAS NO DOCK, and it is told so before the + // strip's list is built: a tab is the conversation in front, one this + // process holds, or one still on the recency stack ([app.tabList]), and the + // one in front is always on that stack ([app.rememberOpen] is every road to + // the front), so with nothing held and at most one on it there cannot be two. That is + // most frames, scrolling included, and the list is allocations the scroll's + // own law counts (inputsmooth_test.go). + if len(a.behind) == 0 && len(a.prev) < 2 { + a.dockList = a.dockList[:0] + return a.dockList + } + out := a.dockList[:0] + for _, tab := range a.tabList() { + if tab.start || tab.work { + continue + } + out = append(out, tab) + } + a.dockList = out + return out +} + +// dockLayout is which cells a dock of at most room cells draws: the first +// tab shown, how many, how many it could not spell, and whether the word +// `All` fits after the glyph. The one in front is always inside the window, and +// the order is never changed. ok is false when no dock fits, or when there +// is nothing to map. +// +// THE WORD DROPS FIRST. A dock that still names every cell it can is worth +// more than a word in front of a shorter one, so the word is tried only +// beside the widest window of cells that fits, and given up before any cell. +func dockLayout(tabs []chatTab, room int) (from, count, hidden int, label, ok bool) { + n := len(tabs) + if n < 2 { + return 0, 0, 0, false, false + } + front := 0 + for i, tab := range tabs { + if tab.here { + front = i + } + } + place := func(count, hidden int) (int, int) { + from := 0 + if front >= count { + from = front - count + 1 + } + return from, hidden + } + widest := min(n, dockCap) + hidden = n - widest + if dockWidth(widest, hidden, true) <= room { + from, hidden = place(widest, hidden) + return from, widest, hidden, true, true + } + for count = widest; count >= dockFloor; count-- { + hidden = n - count + if dockWidth(count, hidden, false) > room { + continue + } + from, hidden = place(count, hidden) + return from, count, hidden, false, true + } + return 0, 0, 0, false, false +} + +// dockWidth is the cells a dock of count cells and hidden more takes. label +// is the word `All` and the space between it and the wall's glyph. +func dockWidth(count, hidden int, label bool) int { + // Each cell is a full square and a space: `■ ■ ▣`, big enough to aim + // at, one cell of air so neighbours do not run into a bar. + w := 2 + 2*count - 1 + if hidden > 0 { + w += 2 + len(strconv.Itoa(hidden)) + } + if label { + w += 1 + len(dockLabel) + } + return w +} + +// dockGlyph is one cell's mark. The wide glyphs carry state by colour alone, +// so the ASCII floor spells it in the character instead: `o` working, `!` +// waiting on a person, `.` at rest, `@` in front. +func (a *app) dockGlyph(tab chatTab) string { + ascii := a.pal.ascii || a.linear + switch { + case tab.here && ascii: + return "@" + case tab.here: + return "▣" + case !ascii: + // The table's filled square, drawn as a shape: the cell's state is + // its colour, never the mark. + return tokens.GlyphStopped + case tab.signal == tabNeedsPerson: + return "!" + case tab.signal == tabWorking: + return "o" + } + return "." +} + +// dockWallGlyph is the wall's mark at the dock's left. +func (a *app) dockWallGlyph() string { + if a.pal.ascii || a.linear { + return "#" + } + return "▦" +} + +// dockPaint draws the dock with its first piece at column at, and records +// where every piece of it landed. The wall's mark wears the active team's +// colour, so the dock also says which team this window is in. The word after +// it stays dim: it names the door, and the squares carry the state. +// +// THE DOOR IS ONE BUTTON: under the pointer the ground covers the glyph, the +// space and the word, which is exactly the span a press on it takes. +func (a *app) dockPaint(tabs []chatTab, from, count, hidden int, label bool, at int) string { + var b strings.Builder + cursor := at + a.dock.wall = hudSpan{from: cursor, to: cursor + 1} + a.dock.label = hudSpan{} + door := 1 + if label { + door += 1 + len(dockLabel) + a.dock.label = hudSpan{from: cursor, to: cursor + door} + } + wall := a.dockWallGlyph() + switch { + case a.hot.kind == hoverDockWall || a.hot.kind == hoverDockLabel: + word := wall + if label { + word += " " + dockLabel + } + b.WriteString(a.pal.cursor(a.pal.ink(word), 0)) + default: + ink := a.pal.dim + if sp, ok := a.teamActive(); ok { + if pen := a.pal.teamInk(sp.HueSpec()); pen != nil && !a.linear { + ink = pen + } + } + b.WriteString(ink(wall)) + if label { + b.WriteString(a.pal.dim(" " + dockLabel)) + } + } + cursor += door - 1 + b.WriteString(" ") + cells := a.dock.cells[:0] + for i, tab := range tabs[from : from+count] { + col := cursor + 2 + 2*i + if i > 0 { + b.WriteString(" ") + } + cells = append(cells, dockCell{span: hudSpan{from: col, to: col + 1}, tab: tab}) + glyph := a.dockGlyph(tab) + switch { + case a.hot.kind == hoverDockCell && a.hot.key == tab.key: + b.WriteString(a.pal.cursor(a.pal.ink(glyph), 0)) + case tab.here: + b.WriteString(a.pal.ink(glyph)) + default: + b.WriteString(a.pal.tabSignalInk(tab.signal, glyph)) + } + } + a.dock.cells = cells + if hidden > 0 { + b.WriteString(a.pal.dim(" +" + strconv.Itoa(hidden))) + } + return b.String() +} + +// dockCellHint is the hint line for one cell. The one in front says where +// you already are. Every other cell says where a press goes, what that +// conversation is doing, and that a click does it. +func dockCellHint(tab chatTab) string { + name := tab.full + if name == "" { + name = tab.word + } + if tab.here { + return name + hintSegment + "you are here" + } + state := "idle" + switch tab.signal { + case tabWorking: + state = "running" + case tabNeedsPerson: + state = "waiting on you" + } + return "Go to " + name + hintSegment + state + hintSegment + "click" +} + +// dockHoverWords is what the hint slot says while the pointer rests on the +// dock, and "" when it rests anywhere else: `The grid of your open tabs, and +// your teams · alt+v` over `▦ All`, and [dockCellHint] over a cell. The strip's own door +// to the wall (chattabs.go) is explained here too, in its own sentence. +func (a *app) dockHoverWords() string { + // THE TEAM'S OWN DOORS EXPLAIN THEMSELVES HERE TOO: the manager's place on + // the strip, the team chip, and every row and word of the Traffic + // (teammanager.go, teamrailpointer.go). + if words := a.teamHoverWords(); words != "" { + return words + } + switch a.hot.kind { + case hoverTab: + if a.wall.door.pressable() && a.hot.index == a.wall.door.from { + return dockWallWord + } + if words := a.stripHoverWords(); words != "" { + return words + } + case hoverDockLabel, hoverDockWall: + if (a.hot.kind == hoverDockLabel && a.dock.label.pressable()) || (a.hot.kind == hoverDockWall && a.dock.wall.pressable()) { + return dockChatsWord + } + case hoverDockCell: + for _, cell := range a.dock.cells { + if cell.tab.key != a.hot.key { + continue + } + return dockCellHint(cell.tab) + } + } + // AND A JUMP THAT FOUND NOTHING SAYS SO, for a moment (teamjump.go). + return a.trafficJumpWords() +} + +// stripHoverWords is what the hint slot says while the pointer rests on a +// piece of the strip that has no sentence of its own elsewhere: a tab, its +// `×`, the new-chat `+` and the scroll arrows. EVERY DOOR ON THE ROW SAYS WHAT +// IT DOES, so none of them is a mark a person has to press to learn about. +// A tab says what its square in the dock says ([dockCellHint]), because they +// are one conversation and one door. +func (a *app) stripHoverWords() string { + hit, ok := a.hotTab() + if !ok { + return "" + } + name := hit.tab.full + if name == "" { + name = hit.tab.word + } + switch hit.kind { + case tabHere, tabOther: + if hit.kind == tabHere && (a.roomOpen() || a.startingChat()) { + return "Back to " + name + hintSegment + "click" + } + return dockCellHint(hit.tab) + case tabClose: + words := "Close this tab" + hintSegment + "the work keeps running" + if hit.tab.here { + return words + hintSegment + a.chords.say(closeTabChord) + } + return words + hintSegment + "click" + case tabNew: + return "New chat" + hintSegment + a.chords.say(newChatChord) + case tabScrollLeft: + return "More tabs to the left" + hintSegment + "click" + case tabScrollRight: + return "More tabs to the right" + hintSegment + "click" + } + return "" +} + +// dockAt is the dock's piece under column x on the keys row, as a hover. +func (a *app) dockAt(x int) (hoverAt, bool) { + if a.dock.label.holds(x) { + return hoverAt{kind: hoverDockLabel}, true + } + if a.dock.wall.holds(x) { + return hoverAt{kind: hoverDockWall}, true + } + for _, cell := range a.dock.cells { + if cell.span.holds(x) { + return hoverAt{kind: hoverDockCell, key: cell.tab.key}, true + } + } + return hoverAt{}, false +} + +// dockPress is a press on the keys row, and it takes only the dock's own +// cells: `▦ All` opens the wall, a cell goes to its conversation, and +// the one in front is already where the press would go. +func (a *app) dockPress(x, y int) (tea.Cmd, bool) { + if a.wall.on || a.copy.on || a.rew.on { + return nil, false + } + // Laying the chrome out again is what records the dock for this frame, so + // the row is resolved first and the columns read after it. + mark, ok := a.chromeAt(y) + if !ok || mark.kind != chromeStatus { + return nil, false + } + if width, _ := a.size(); layoutTier(width) == tierPhone { + return nil, false + } + if a.dock.label.holds(x) || a.dock.wall.holds(x) { + return a.openWall(), true + } + for _, cell := range a.dock.cells { + if !cell.span.holds(x) { + continue + } + if cell.tab.here { + return nil, true + } + return a.tabGo(cell.tab), true + } + return nil, false +} + +// dockRow lays the dock into the keys row once the keys are fitted: end is +// the column the dock must finish before, and used the cells the keys took +// from the left. It returns the dock painted and its width, both empty when +// no dock fits or none is due. +func (a *app) dockRow(width, end, used int) (string, int) { + if a.wall.on || layoutTier(width) == tierPhone { + return "", 0 + } + free := end - 1 + if used > 0 { + free -= used + hudGap + } + tabs := a.dockTabs() + from, count, hidden, label, ok := dockLayout(tabs, free) + if !ok { + return "", 0 + } + w := dockWidth(count, hidden, label) + return a.dockPaint(tabs, from, count, hidden, label, end-w), w +} diff --git a/internal/tui3/walldock_test.go b/internal/tui3/walldock_test.go new file mode 100644 index 0000000000..5c47b49cab --- /dev/null +++ b/internal/tui3/walldock_test.go @@ -0,0 +1,386 @@ +package tui3 + +import ( + "strings" + "testing" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" +) + +// dockRowY is the frame row the keys were drawn on, found the way the +// pointer finds it (view.go's [app.chromeAt]). +func dockRowY(t *testing.T, a *app) int { + t.Helper() + for y := a.height - 1; y >= 0; y-- { + if mark, ok := a.chromeAt(y); ok && mark.kind == chromeStatus { + return y + } + } + t.Fatal("no keys row on the frame") + return -1 +} + +// dockKeysRow lays the keys row out at width and returns it plain. +func dockKeysRow(a *app, width int) string { + a.width = width + return plain(strings.Join(a.statusRows(width), "\n")) +} + +// ONE CONVERSATION IS NOT A MAP: the dock waits for a second. +func TestDockIsAbsentWithOneConversation(t *testing.T) { + a := newTestApp(&fakeAgent{model: "m"}) + a.file, a.workspace, a.title = "/tmp/lab/this-one.jsonl", "/tmp/lab", "Shipping the parser" + emptyMachine(a) + a.width, a.height = 120, 30 + row := dockKeysRow(a, 120) + if strings.Contains(row, "▦") || a.dock.wall.pressable() || a.dock.label.pressable() || len(a.dock.cells) != 0 { + t.Fatalf("a dock with one conversation: %q %+v", row, a.dock) + } +} + +// THREE CONVERSATIONS ARE THREE CELLS, in the strip's order, each painted by +// what it is doing, with the one in front as ▣. +func TestDockDrawsEveryConversationInStripOrder(t *testing.T) { + a, _, _ := tabApp(t) + tabs := append([]chatTab(nil), a.dockTabs()...) + if len(tabs) != 3 { + t.Fatalf("%d conversations", len(tabs)) + } + // One of the two behind is working and the other waits on a person. + var working, asking string + for _, tab := range tabs { + if tab.here { + continue + } + held := a.behind[tab.key] + if held == nil || held.watch == nil { + t.Fatalf("tab %q is not held", tab.word) + } + // AN INERT WATCHER, as the strip's own signal tests use (tabsignal_test.go's + // [signalLab]). The live one's goroutine stores its first reading of the + // agent when it starts, and a flag set here before that could be put + // back to idle under the second render: red 4 times in 30 on Spark. + held.watch = &behindWatch{key: tab.key, agent: held.conv.Agent} + if working == "" { + held.watch.turning.Store(true) + working = tab.key + } else { + held.watch.waits.Store(true) + asking = tab.key + } + } + a.width = 120 + painted := strings.Join(a.statusRows(120), "") + row := plain(painted) + if !strings.Contains(row, "▦ ") { + t.Fatalf("no dock: %q", row) + } + if len(a.dock.cells) != 3 { + t.Fatalf("%d cells: %+v", len(a.dock.cells), a.dock.cells) + } + for i, cell := range a.dock.cells { + if cell.tab.key != tabs[i].key { + t.Fatalf("cell %d is %q, the strip has %q there", i, cell.tab.word, tabs[i].word) + } + got := ansi.Cut(row, cell.span.from, cell.span.to) + want := "■" + if cell.tab.here { + want = "▣" + } + if got != want { + t.Fatalf("cell %d at %v reads %q, want %q\n%q", i, cell.span, got, want, row) + } + // The hue is the strip's own for that state. + var ink string + switch { + case cell.tab.here: + ink = a.pal.ink(want) + case cell.tab.key == working: + ink = a.pal.accent(want) + case cell.tab.key == asking: + ink = a.pal.warn(want) + } + if !strings.Contains(painted, ink) { + t.Fatalf("cell %d is not painted %q", i, ink) + } + } + if got := ansi.Cut(row, a.dock.wall.from, a.dock.wall.to); got != "▦" { + t.Fatalf("the wall's mark is not where it was recorded: %q", got) + } + // THE DOOR IS `▦ All`, SPELLED AS THE STRIP SPELLS IT, AND ONE BUTTON: the + // recorded span holds the glyph and the word, and the glyph is its first cell. + if !a.dock.label.pressable() || ansi.Cut(row, a.dock.label.from, a.dock.label.to) != "▦ "+tabWallWord { + t.Fatalf("the door is not where it was recorded: %q %+v", row, a.dock.label) + } + if !strings.Contains(painted, a.pal.dim(" "+dockLabel)) { + t.Fatalf("the word is not dim: %q", painted) + } + if a.dock.label.from != a.dock.wall.from { + t.Fatalf("the glyph does not lead the door: label %+v wall %+v", a.dock.label, a.dock.wall) + } + // The ASCII floor spells the state in the character. + a.linear = true + row = dockKeysRow(a, 120) + var marks string + for _, cell := range a.dock.cells { + marks += ansi.Cut(row, cell.span.from, cell.span.to) + } + if ansi.Cut(row, a.dock.wall.from, a.dock.wall.to) != "#" || strings.Count(marks, "@") != 1 || !strings.Contains(marks, "o") || !strings.Contains(marks, "!") { + t.Fatalf("the linear dock: %q marks %q", row, marks) + } +} + +// A HAND ON THE DOCK: the hint slot names what is under it, a press on a +// cell brings that conversation to the front, and a press on ▦ opens the wall. +func TestDockHoverNamesAndPressGoes(t *testing.T) { + a, _, _ := tabApp(t) + _ = frame(a) + y := dockRowY(t, a) + if len(a.dock.cells) != 3 { + t.Fatalf("the frame drew %d cells", len(a.dock.cells)) + } + var target dockCell + for _, cell := range a.dock.cells { + if !cell.tab.here { + target = cell + break + } + } + a.setHover(target.span.from, y) + if a.hot.kind != hoverDockCell || a.hot.key != target.tab.key { + t.Fatalf("the hover on a cell is %+v", a.hot) + } + before := append([]dockCell(nil), a.dock.cells...) + lines := screenLines(a) + row := lines[y] + if !strings.HasPrefix(row, " "+dockCellHint(target.tab)) { + t.Fatalf("the hovered cell does not say %q: %q", dockCellHint(target.tab), row) + } + for i, cell := range a.dock.cells { + if cell.span != before[i].span { + t.Fatal("the dock moved under the pointer") + } + } + a.setHover(a.dock.wall.from, y) + if row := screenLines(a)[y]; !strings.HasPrefix(row, " "+dockChatsWord) { + t.Fatalf("the hovered wall mark: %q", row) + } + a.setHover(a.dock.label.from, y) + if a.hot.kind != hoverDockLabel { + t.Fatalf("the hover on the word is %+v", a.hot) + } + if row := screenLines(a)[y]; !strings.HasPrefix(row, " "+dockChatsWord) { + t.Fatalf("the hovered word: %q", row) + } + for _, cell := range a.dock.cells { + if !cell.tab.here { + continue + } + a.setHover(cell.span.from, y) + want := cell.tab.full + hintSegment + "you are here" + if row := screenLines(a)[y]; !strings.HasPrefix(row, " "+want) { + t.Fatalf("the square in front says %q, want %q", row, want) + } + break + } + + if _, took := a.dockPress(target.span.from, y); !took { + t.Fatal("the dock did not take a press on a cell") + } + if a.frontTabKey() != target.tab.key { + t.Fatalf("the press brought %q forward, want %q", a.frontTabKey(), target.tab.key) + } + _ = frame(a) + y = dockRowY(t, a) + if _, took := a.dockPress(a.dock.label.from+2, y); !took || !a.wall.on { + t.Fatal("the word did not open the wall") + } + a.closeWall() + _ = frame(a) + y = dockRowY(t, a) + if _, took := a.dockPress(a.dock.wall.from, y); !took || !a.wall.on { + t.Fatal("the wall's mark did not open the wall") + } + // A press on the blank between the keys and the dock is nothing. + a.closeWall() + _ = frame(a) + y = dockRowY(t, a) + start := a.dock.wall.from + if a.dock.label.pressable() { + start = a.dock.label.from + } + if _, took := a.dockPress(start-2, y); took { + t.Fatal("the blank before the dock took a press") + } +} + +// THE ROW NEVER OVERFLOWS, and the phone's deck carries no dock. +func TestDockKeysRowFitsEveryWidth(t *testing.T) { + a, _, _ := tabApp(t) + for _, width := range []int{60, 80, 120, 180} { + row := dockKeysRow(a, width) + if w := ansi.StringWidth(row); w != width { + t.Fatalf("at %d the keys row is %d wide: %q", width, w, row) + } + for _, cell := range a.dock.cells { + if cell.span.to > width-1 { + t.Fatalf("at %d a cell lies past the row: %+v", width, cell) + } + } + if width >= 80 && !a.dock.wall.pressable() { + t.Fatalf("at %d no dock: %q", width, row) + } + } + row := dockKeysRow(a, 44) + if strings.Contains(row, "▦") || a.dock.wall.pressable() || len(a.dock.cells) != 0 { + t.Fatalf("the phone has a dock: %q", row) + } +} + +// THE CAP COUNTS WHAT IT CANNOT SPELL, and the one in front stays inside it. +func TestDockLayoutCapsAndKeepsTheFront(t *testing.T) { + tabs := make([]chatTab, 20) + tabs[17].here = true + from, count, hidden, label, ok := dockLayout(tabs, 80) + if !ok || !label || count != dockCap || hidden != 20-dockCap || from > 17 || from+count <= 17 { + t.Fatalf("from %d count %d hidden %d label %v ok %v", from, count, hidden, label, ok) + } + if _, _, _, _, ok := dockLayout(tabs, 3); ok { + t.Fatal("a dock was fitted into three cells") + } + if _, _, _, _, ok := dockLayout(tabs[:1], 80); ok { + t.Fatal("one conversation made a dock") + } +} + +// THE WORD GOES BEFORE ANY CELL DOES. A room that holds the squares and not +// the word draws the squares. A room that holds both draws the word. A room +// that cannot hold two squares draws nothing. +func TestDockLabelDropsBeforeACell(t *testing.T) { + tabs := make([]chatTab, 3) + tabs[1].here = true + cells := dockWidth(3, 0, false) + from, count, hidden, label, ok := dockLayout(tabs, cells) + if !ok || label || count != 3 || from != 0 || hidden != 0 { + t.Fatalf("the word stayed or a cell went: from %d count %d hidden %d label %v ok %v", from, count, hidden, label, ok) + } + from, count, hidden, label, ok = dockLayout(tabs, dockWidth(3, 0, true)) + if !ok || !label || count != 3 || hidden != 0 { + t.Fatalf("the wide row dropped the word: from %d count %d hidden %d label %v ok %v", from, count, hidden, label, ok) + } + if _, _, _, _, ok := dockLayout(tabs, cells-1); ok { + t.Fatal("a dock was drawn below two cells of room") + } +} + +// EACH KIND OF CELL SAYS WHAT A PRESS DOES, in the words the hint line uses. +func TestDockHoverHintPerCellKind(t *testing.T) { + idle := chatTab{full: "Shipping the parser", signal: tabIdle} + if got := dockCellHint(idle); got != "Go to Shipping the parser"+hintSegment+"idle"+hintSegment+"click" { + t.Fatalf("idle: %q", got) + } + running := chatTab{word: "price scrape", signal: tabWorking} + if got := dockCellHint(running); got != "Go to price scrape"+hintSegment+"running"+hintSegment+"click" { + t.Fatalf("running: %q", got) + } + waiting := chatTab{full: "Refactor the rail", signal: tabNeedsPerson} + if got := dockCellHint(waiting); got != "Go to Refactor the rail"+hintSegment+"waiting on you"+hintSegment+"click" { + t.Fatalf("waiting: %q", got) + } + here := chatTab{full: "Shipping the parser", here: true, signal: tabWorking} + if got := dockCellHint(here); got != "Shipping the parser"+hintSegment+"you are here" { + t.Fatalf("here: %q", got) + } + if dockChatsWord != dockWallWord { + t.Fatalf("the word and the glyph say %q", dockChatsWord) + } +} + +// A PRESS ON THE CONVERSATION ALREADY IN FRONT DOES NOTHING: no switch, no +// wall, nothing to redraw. +func TestDockPressOnTheOneInFrontDoesNothing(t *testing.T) { + a, _, _ := tabApp(t) + _ = frame(a) + y := dockRowY(t, a) + front := a.frontTabKey() + for _, cell := range a.dock.cells { + if !cell.tab.here { + continue + } + cmd, took := a.dockPress(cell.span.from, y) + if !took || cmd != nil || a.frontTabKey() != front || a.wall.on { + t.Fatalf("a press on the front: took %v cmd %v front %q wall %v", took, cmd != nil, a.frontTabKey(), a.wall.on) + } + return + } + t.Fatal("no cell for the conversation in front") +} + +// THE DOCK'S HOVER IS THE WALL'S HOVER: the cell under the pointer sits on +// the same cursor ground a tile and a wall button wear under it. +func TestDockHoverWearsTheWallsHoverGround(t *testing.T) { + a, _, _ := tabApp(t) + _ = frame(a) + y := dockRowY(t, a) + cell := a.dock.cells[0] + a.setHover(cell.span.from, y) + lines := strings.Split(frame(a), "\n") + ground := a.pal.cursor(a.pal.ink(a.dockGlyph(cell.tab)), 0) + if !strings.Contains(lines[y], ground) { + t.Fatalf("the hovered cell is not on the cursor ground: %q", lines[y]) + } + // THE DOOR IS ONE GROUND FROM ANY CELL OF IT: the glyph, the space and the + // word light together, because a press on any of them opens the wall. + door := a.dock.label + word := a.pal.cursor(a.pal.ink(a.dockWallGlyph()+" "+dockLabel), 0) + for x := door.from; x < door.to; x++ { + a.setHover(x, y) + lines = strings.Split(frame(a), "\n") + if !strings.Contains(lines[y], word) { + t.Fatalf("the pointer at %d of the door %+v does not light all of it: %q", x, door, lines[y]) + } + } + if wall := wallButtonPaint(a.pal, wallButton{label: "x"}, true); !strings.Contains(wall, a.pal.cursor(" ", 0)[:strings.Index(a.pal.cursor(" ", 0), " ")]) { + t.Fatalf("the wall's hover is not the cursor ground: %q", wall) + } +} + +// ONE WORD, ONE DOOR. The dock's door to the wall is spelled as the strip's +// door to it is, `▦ All`, and both open the wall; the nav's `chats` over +// them is the way back to the conversations and never the wall. The dock +// used to say `chats` too, so one word on one frame led two places. +func TestTheDocksDoorIsSpelledAsTheStripsDoor(t *testing.T) { + a, _, _ := tabApp(t) + a.width, a.height = 120, 30 + rows := screenLines(a) + y := dockRowY(t, a) + strip := strings.TrimSpace(ansi.Cut(rows[tabStripRow], a.wall.door.from, a.wall.door.to)) + dock := ansi.Cut(rows[y], a.dock.label.from, a.dock.label.to) + if strip != "▦ "+tabWallWord || dock != strip { + t.Fatalf("the strip's door says %q and the dock's says %q", strip, dock) + } + if strings.Contains(ansi.Cut(rows[y], a.dock.label.from-8, a.width), "chats") { + t.Fatalf("the dock still carries the nav's word: %q", rows[y]) + } + for _, press := range []func() (tea.Cmd, bool){ + func() (tea.Cmd, bool) { return a.dockPress(a.dock.label.to-1, y) }, + func() (tea.Cmd, bool) { return a.tabPress(a.wall.door.from+1, tabStripRow) }, + } { + if _, took := press(); !took || !a.wall.on { + t.Fatal("a press on `▦ All` did not open the wall") + } + a.closeWall() + rows = screenLines(a) + y = dockRowY(t, a) + } + for _, span := range a.tabs { + if span.id != pageChats { + continue + } + drive(t, a, tea.MouseClickMsg{X: span.from + 1, Y: navRow, Button: tea.MouseLeft}) + if a.wall.on { + t.Fatal("the nav's `chats` opened the wall") + } + } +} diff --git a/internal/tui3/walldoor_test.go b/internal/tui3/walldoor_test.go new file mode 100644 index 0000000000..6962471d8f --- /dev/null +++ b/internal/tui3/walldoor_test.go @@ -0,0 +1,182 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" +) + +// wallDoorApp is the strip's three-conversation window with the new-chat `+` +// on, so the door stands where it does for a person who can start one. +func wallDoorApp(t *testing.T, width int) *app { + t.Helper() + a, _, _ := tabApp(t) + a.start = func(string) (Conversation, error) { return Conversation{}, nil } + a.width = width + a.chatTabBar = tabBar{} + a.touch() + _ = a.tabsRow(width) + return a +} + +// THE STRIP HAS ITS OWN DOOR TO THE CONVERSATIONS VIEW: ` ▦ All ` right after +// the new-chat `+`, touching it, its hit on its own words, and kept out of the +// tabs' own list so a walk of the tabs never meets it. +func TestTabWallDoorStandsAfterTheNewChat(t *testing.T) { + a := wallDoorApp(t, 120) + row := a.tabsRow(120) + door := a.wall.door + if !door.pressable() { + t.Fatalf("no door on a 120-column strip: %q", plain(row)) + } + if got := plain(ansi.Cut(row, door.from, door.to)); got != " ▦ All " { + t.Fatalf("the door's cells say %q", got) + } + var plus tabHit + for _, hit := range a.chatTabHits { + if hit.kind == tabWall { + t.Fatalf("the door is in the tabs' own list: %+v", hit) + } + if hit.kind == tabNew { + plus = hit + } + } + // ONE GAP AFTER THE `+`, the gap between any two pieces of the strip. + if !plus.span.pressable() || plus.span.to+1 != door.from || plain(ansi.Cut(row, plus.span.to, door.from)) != " " { + t.Fatalf("the door does not stand one gap after the +: + %+v door %+v\n%q", plus.span, door, plain(row)) + } + // The same blank either side as the +. + pw := plain(ansi.Cut(row, plus.span.from, plus.span.to)) + if !strings.HasPrefix(pw, " ") || !strings.HasSuffix(pw, " ") || len(pw) != 3 { + t.Fatalf("the + is %q", pw) + } + if hit, ok := a.tabAt(door.from, tabStripRow); !ok || hit.kind != tabWall { + t.Fatalf("the strip does not answer for the door: %+v", hit) + } + for _, w := range tabWords(a) { + if strings.Contains(w, "All") { + t.Fatalf("a walk of the tabs met the door: %q", w) + } + } +} + +// UNDER THE POINTER THE DOOR WEARS THE STRIP'S HOVER GROUND, moves nothing +// else, and the hint slot names it and its key. +func TestTabWallDoorHover(t *testing.T) { + a := wallDoorApp(t, 120) + rest := a.tabsRow(120) + door := a.wall.door + hover, ok := a.tabHoverAt(door.from+2, tabStripRow) + if !ok { + t.Fatal("the door does not take the pointer") + } + a.hot = hover + lit := a.tabsRow(120) + if plain(lit) != plain(rest) { + t.Fatalf("the hover moved the strip:\n%q\n%q", plain(rest), plain(lit)) + } + cell := ansi.Cut(lit, door.from, door.to) + if !strings.Contains(cell, "\x1b[48;") || cell == ansi.Cut(rest, door.from, door.to) { + t.Fatalf("the hovered door wears no ground: %q", cell) + } + if got := a.dockHoverWords(); got != dockWallWord || !strings.Contains(got, "teams") || !strings.HasSuffix(got, wallOpenKey) { + t.Fatalf("the hint slot says %q", got) + } + t.Logf("120 columns at rest:\n%q\nhovered:\n%q", plain(rest), plain(lit)) +} + +// A PRESS ON THE DOOR OPENS THE VIEW, the door is lit while it is up, and a +// press on it again, through the wall's own head, closes it. +func TestTabWallDoorOpensAndCloses(t *testing.T) { + a := wallDoorApp(t, 120) + rest := a.tabsRow(120) + door := a.wall.door + clickTab(t, a, door.from+1) + if !a.wall.on { + t.Fatal("the door did not open the view") + } + _ = a.wallFrame(a.width, a.height) + open := a.tabsRow(120) + if ansi.Cut(open, door.from, door.to) == ansi.Cut(rest, door.from, door.to) { + t.Fatal("the door is not lit while the view is up") + } + t.Logf("120 columns with the view up:\n%q", plain(open)) + if _, took := a.wallPress(door.from+1, tabStripRow); !took || a.wall.on { + t.Fatalf("a press on the door from inside the view: took %v on %v", took, a.wall.on) + } + // And the tab strip's own press closes it too. + _ = a.openWall() + clickTab(t, a, door.from+1) + if a.wall.on { + t.Fatal("the strip's press on the door did not close the view") + } +} + +// THE DOOR GOES WITH THE ROW, WORD AND GLYPH TOGETHER: ` ▦ All ` wherever it +// is drawn and nothing under [tabWallFrom], never a lone glyph; the count of +// hidden tabs stays the last thing on it. The row is exactly the frame's width. +func TestTabWallDoorAtEveryWidth(t *testing.T) { + for _, width := range []int{40, 60, 80, 120, 160} { + a := wallDoorApp(t, width) + row := a.tabsRow(width) + if got := ansi.StringWidth(row); got != width { + t.Fatalf("at %d columns the strip is %d cells:\n%q", width, got, plain(row)) + } + door := a.wall.door + want := "" + switch { + case width >= tabWallWordFrom: + want = " ▦ All " + case width >= tabWallFrom: + want = " ▦ " + } + got := "" + if door.pressable() { + got = plain(ansi.Cut(row, door.from, door.to)) + } + if got != want { + t.Fatalf("at %d columns the door is %q, want %q:\n%q", width, got, want, plain(row)) + } + for _, hit := range a.chatTabHits { + if hit.kind != tabFold { + continue + } + if door.pressable() && door.to+tabsMoreGap > hit.span.from { + t.Fatalf("at %d columns the count is not after the door by %d: %+v %+v\n%q", width, tabsMoreGap, door, hit.span, plain(row)) + } + for _, other := range a.chatTabHits { + if other.span.from > hit.span.from { + t.Fatalf("at %d columns %+v is right of the count:\n%q", width, other, plain(row)) + } + } + } + } +} + +// WHILE A TEAM NARROWS THE STRIP THE DOOR'S GLYPH WEARS ITS COLOUR, as the +// dock's does. +func TestTabWallDoorTakesTheTeamColour(t *testing.T) { + a := wallDoorApp(t, 160) + before := a.tabsRow(160) + tabs := a.tabList() + i, err := a.teamMake("harbor", tabs) + if err != nil { + t.Fatal(err) + } + a.wall.activeID = i + a.touch() + row := a.tabsRow(160) + door := a.wall.door + if !door.pressable() { + t.Fatalf("no door with a team shown: %q", plain(row)) + } + made, _ := a.teamByID(i) + ink := a.pal.teamInk(made.HueSpec()) + if ink == nil { + t.Skip("the palette draws no team colour") + } + if cell := ansi.Cut(row, door.from, door.to); !strings.Contains(cell, ink("▦")) { + t.Fatalf("the door's glyph is not in the team's colour: %q (before %q)", cell, ansi.Cut(before, a.wall.door.from, a.wall.door.to)) + } +} diff --git a/internal/tui3/wallhelp.go b/internal/tui3/wallhelp.go new file mode 100644 index 0000000000..09f8ad6b41 --- /dev/null +++ b/internal/tui3/wallhelp.go @@ -0,0 +1,285 @@ +package tui3 + +import ( + "strings" + + tea "charm.land/bubbletea/v2" + "github.com/charmbracelet/x/ansi" +) + +// ── THE HELP SHEET: WHAT YOU CAN DO HERE ──────────────────────────────────── +// +// `?` on the wall, or its toolbar's Help, puts up one card that lists every +// act the page has, grouped, each with its key: +// +// ╭─ Conversations ──────────────────────────────────────────╮ +// │ │ +// │ Navigate Organize │ +// │ Move ←↑↓→ Select ␣ │ +// │ First/last g G New team s │ +// │ … │ +// ╰──────────────────────────────────────────────────────────╯ +// +// A LIST OF KEYS IS ALSO A MENU. Every row is a press and does what its key +// does, through the same [app.wallCommand] the key goes through, with the +// sheet put away first so the act is seen. A row that needs a conversation +// acts on the focused one, as its key does; a row that names a pair of keys +// does the forward one of the two. +// +// It is the painting half's and the wiring's at once, as the popovers are +// (wallbar.go, wallpop.go): the painter is pure, and the wiring below it is +// the only part that touches the app. + +// wallHelpRow is one row of the sheet: what it does, its key as drawn, the +// key it presses, and what the toolbar says while the pointer is on it. +type wallHelpRow struct { + label, key, press, hint string +} + +// wallHelpGroup is one titled group of rows. +type wallHelpGroup struct { + name string + rows []wallHelpRow +} + +// wallHelpList is the sheet's groups, with the keys in the palette's tier. +func wallHelpList(ascii bool) []wallHelpGroup { + k := wallKeysFor(ascii) + arrows, span := "←↑↓→", "1–9" + if ascii { + arrows, span = "arrows", "1-9" + } + row := func(label, key, press, hint string) wallHelpRow { + return wallHelpRow{label: label, key: key, press: press, hint: hint} + } + return []wallHelpGroup{ + {name: "Navigate", rows: []wallHelpRow{ + row("Move", arrows, "right", "Move the focus to the next conversation"), + row("First/last", "g G", "G", "Go to the last conversation"), + row("Page", "pgup pgdn", "pgdown", "Go down a screen of rows"), + row("Next needing you", "n", "n", "Go to the next conversation waiting on you"), + }}, + {name: "Open", rows: []wallHelpRow{ + row("Open", k.enter, "enter", "Open the focused conversation"), + row("Answer", k.enter, "enter", "Open the focused conversation to answer it"), + row("Open the rest", "r", "r", "Resume the shown team's conversations not open here"), + row("Back", "esc", "esc", "Back one step"), + }}, + {name: "Organize", rows: []wallHelpRow{ + row("Select", k.pick, "space", "Select the focused conversation"), + row("New team", "s", "s", "Make a team"), + row("Organize", "o", "o", "Suggest teams for your conversations"), + row("Add to teams", "m", "m", "Add the focused conversation to teams"), + row("Make manager", "m", "m", "In the Teams list: make the focused conversation the shown team's manager"), + row("Team settings", "e", "e", "Rename, recolour or change the shown team's settings"), + row("Close team", "D", "D", "Close the shown team; reopen it from Closed on the teams page"), + row("Switch team", "tab / "+span, "tab", "Show the next team"), + row("Close view", "x", "x", "Close the focused view; the work keeps running"), + }}, + {name: "View", rows: []wallHelpRow{ + row("Filter", "/", "/", "Filter conversations by name"), + row("Fewer/more columns", k.minus+" +", "+", "Show more columns"), + row("Automatic columns", "0", "0", "Let the width choose the columns"), + }}, + } +} + +// wallHelpRows is every row in the sheet's reading order, which is the order +// a [wallHitHelp]'s arg counts in. +func wallHelpRows(ascii bool) []wallHelpRow { + var out []wallHelpRow + for _, g := range wallHelpList(ascii) { + out = append(out, g.rows...) + } + return out +} + +// wallHelpColGap is the blank cells between the sheet's two columns. +const wallHelpColGap = 4 + +// wallHelpCell is one cell of a column: a heading, a blank, or a row. +type wallHelpCell struct { + s string + row int // the row's place in [wallHelpRows], -1 for a heading or a blank +} + +// wallHelpColumn lays groups out as one column's cells, colW wide, with a +// blank between two groups. at is the first group's first row's place in +// [wallHelpRows]. +func wallHelpColumn(pal palette, v wallView, groups []wallHelpGroup, at, colW int) []wallHelpCell { + var cells []wallHelpCell + for gi, g := range groups { + if gi > 0 { + cells = append(cells, wallHelpCell{row: -1}) + } + cells = append(cells, wallHelpCell{s: pal.bold(pal.muted(g.name)), row: -1}) + for _, r := range g.rows { + gap := max(colW-ansi.StringWidth(r.label)-ansi.StringWidth(r.key), 1) + s := pal.ink(r.label) + strings.Repeat(" ", gap) + pal.dim(r.key) + lit := v.hover.kind == wallHitHelp && v.hover.arg == at + cells = append(cells, wallHelpCell{s: wallPopRowPaint(pal, s, colW, lit), row: at}) + at++ + } + } + return cells +} + +// wallHelpCard is the sheet, centred over the grid: two columns where the +// frame is wide enough for them and one where it is not. When its lines do +// not fit between the head and the foot it drops its padding first, then +// shows a window of them from v.helpTop, and its bottom border says which way +// the rest lies. +func wallHelpCard(pal palette, v wallView, width, height int) wallCard { + groups := wallHelpList(pal.ascii) + colW := 0 + for _, g := range groups { + for _, r := range g.rows { + colW = max(colW, ansi.StringWidth(r.label)+2+ansi.StringWidth(r.key)) + } + } + colW += 2 + chrome := 2 + 2*wallCardPadX + two := 2*colW+wallHelpColGap+chrome <= width-2*wallMargin + var left, right []wallHelpCell + if two { + left = wallHelpColumn(pal, v, groups[:2], 0, colW) + right = wallHelpColumn(pal, v, groups[2:], len(groups[0].rows)+len(groups[1].rows), colW) + } else { + left = wallHelpColumn(pal, v, groups, 0, colW) + } + inner := colW + if two { + inner = 2*colW + wallHelpColGap + } + w := inner + chrome + if w > width-2*wallMargin { + return wallCard{} + } + var lines []wallCardLine + for r := 0; r < max(len(left), len(right)); r++ { + var ln wallCardLine + put := func(cells []wallHelpCell, x int) { + if r >= len(cells) { + return + } + c := cells[r] + ln.s += strings.Repeat(" ", max(x-ansi.StringWidth(ln.s), 0)) + wallFit(c.s, colW) + if c.row >= 0 { + ln.hits = append(ln.hits, wallHit{x0: x, y0: 0, x1: x + colW, y1: 1, kind: wallHitHelp, arg: c.row}) + } + } + put(left, 0) + put(right, colW+wallHelpColGap) + lines = append(lines, ln) + } + + top := wallGridTop + floor := height - wallFootRows + 1 // the first row a card may not cover + room := floor - top + padY := wallCardPadY + if len(lines)+2+2*padY > room { + padY = 0 + } + vis := room - 2 - 2*padY + if vis < 1 { + return wallCard{} + } + over := max(len(lines)-vis, 0) + from := min(max(v.helpTop, 0), over) + shown := lines[from:min(from+vis, len(lines))] + h := len(shown) + 2 + 2*padY + x := (width - w) / 2 + y := top + max((room-h)/2, 0) + card := wallCardBuild(pal, "Conversations", shown, x, y, w, wallCardPadX, padY) + if over > 0 { + card.over = over + card.rows[len(card.rows)-1] = wallHelpFoot(pal, w, from < over) + } + return card +} + +// wallHelpFoot is a scrolled sheet's bottom border, saying which way the lines +// it is not showing lie. +func wallHelpFoot(pal palette, w int, below bool) string { + box := wallBoxLight + word := " ↓ more " + if !below { + word = " ↑ more " + } + if pal.ascii { + box = wallBoxLightASCII + word = strings.NewReplacer("↓", "v", "↑", "^").Replace(word) + } + fill := max(w-3-ansi.StringWidth(word), 0) + return pal.muted(box.bl+box.h) + pal.dim(word) + pal.muted(strings.Repeat(box.h, fill)+box.br) +} + +// ── THE SHEET, WIRED ──────────────────────────────────────────────────────── + +// wallOpenHelp puts the sheet up at its top. It takes the place of a popover +// or the filter's typing, as any card does. +func (a *app) wallOpenHelp() { + a.wall.help = true + a.wall.helpTop = 0 + a.wall.pop = wallPop{} + a.wall.filterOn = false + a.wall.hover = wallHitRef{} + a.wall.stirred = true + a.touch() +} + +// wallHelpScroll moves the sheet by lines, inside what the last frame said it +// could scroll. +func (a *app) wallHelpScroll(by int) { + top := min(max(a.wall.helpTop+by, 0), a.wall.helpMax) + if top == a.wall.helpTop { + return + } + a.wall.helpTop = top + a.wall.hover = wallHitRef{} + a.wall.rehover = true + a.wall.stirred = true + a.touch() +} + +// wallHelpKey is a key while the sheet is up. esc, q and ? again put it away; +// the arrows and the page keys scroll it. Any other key puts it away and does +// what it does, since a sheet of keys is read to be pressed. It reports +// whether it took the key. The sheet is at most two screens, so a page key +// goes to its top or its end. +func (a *app) wallHelpKey(key string) (tea.Cmd, bool) { + page := a.wall.helpMax + switch key { + case "esc", "q", "?": + a.wall.help = false + a.touch() + return nil, true + case "up", "k": + a.wallHelpScroll(-1) + return nil, true + case "down", "j": + a.wallHelpScroll(1) + return nil, true + case "pgup", "home": + a.wallHelpScroll(-page) + return nil, true + case "pgdown", "end": + a.wallHelpScroll(page) + return nil, true + } + a.wall.help = false + a.touch() + return nil, false +} + +// wallHelpPress is a press on row i of the sheet: the sheet goes, and the +// row's key is pressed. +func (a *app) wallHelpPress(i int, tiles []wallTile) tea.Cmd { + rows := wallHelpRows(a.pal.ascii) + if i < 0 || i >= len(rows) { + return nil + } + a.wall.help = false + a.touch() + return a.wallCommand(rows[i].press, tiles) +} diff --git a/internal/tui3/wallhelp_test.go b/internal/tui3/wallhelp_test.go new file mode 100644 index 0000000000..2c871f7f6f --- /dev/null +++ b/internal/tui3/wallhelp_test.go @@ -0,0 +1,228 @@ +package tui3 + +import ( + "fmt" + "strings" + "testing" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" + "github.com/charmbracelet/x/ansi" +) + +// ? IS HELP AND n IS THE NEXT ONE WAITING: the needs-you count still goes to +// the next waiting conversation, and says n, and ? puts up the sheet. +func TestWallQuestionMarkIsHelpAndNIsNext(t *testing.T) { + v := wallUnmarked(wallFixture(6)) + v.hover = wallHitRef{kind: wallHitAction, arg: int(wallActNext)} + if got := wallHint(v, false); got != "Go to the next conversation waiting on you · n" { + t.Fatalf("the needs-you count says %q", got) + } + // The count is still a button on its own words. + pal := newPalette(tokens.TrueColor, false) + rows, hits := renderWall(pal, wallUnmarked(wallFixture(6)), 120, 40) + found := false + for _, hit := range hits { + if hit.kind == wallHitAction && hit.arg == int(wallActNext) { + found = strings.Contains(ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0, hit.x1)), "1 needs you") + } + } + if !found { + t.Fatal("the needs-you count is not a button on its words") + } + + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + focus := a.wall.focus + wallKeyPress(a, "n") + if a.wall.help { + t.Fatal("n put up the help sheet") + } + wallKeyPress(a, "?") + if !a.wall.help || a.wall.focus != focus { + t.Fatalf("?: help %v, focus %d from %d", a.wall.help, a.wall.focus, focus) + } + frame := wallPlainFrame(a.wallFrame(a.width, a.height)) + for _, want := range []string{"─ Conversations ─", "Navigate", "Organize", "Next needing you", "Automatic columns"} { + if !strings.Contains(frame, want) { + t.Fatalf("the sheet lacks %q:\n%s", want, frame) + } + } + wallKeyPress(a, "?") + if a.wall.help || !a.wall.on { + t.Fatalf("? again: help %v on %v", a.wall.help, a.wall.on) + } +} + +// THE SHEET IS THE ESC LADDER'S INNERMOST RUNG, and a press off it puts it +// away and does nothing else. +func TestWallHelpSheetClosesLikeACard(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + a.wallSettle() + _ = a.wallFrame(a.width, a.height) + wallKeyPress(a, " ") + wallKeyPress(a, "?") + if !a.wall.help || len(a.wall.marked) != 1 { + t.Fatalf("the setup: help %v marked %v", a.wall.help, a.wall.marked) + } + wallKeyPress(a, "esc") + if a.wall.help || len(a.wall.marked) != 1 || !a.wall.on { + t.Fatalf("esc on the sheet: help %v marked %v on %v", a.wall.help, a.wall.marked, a.wall.on) + } + + a.wall.marked = map[string]bool{} + wallKeyPress(a, "?") + _ = a.wallFrame(a.width, a.height) + card := a.wall.card + if card.w() == 0 { + t.Fatal("the sheet's place was not recorded") + } + if _, took := a.wallPress(card.x0, card.y0); !took || !a.wall.help { + t.Fatal("a press on the sheet's border put it away") + } + x, y := a.width-3, a.height-3 + if card.holds(x, y) { + t.Fatal("the test's far corner is on the sheet") + } + focus := a.wall.focus + if _, took := a.wallPress(x, y); !took || a.wall.help || !a.wall.on || a.wall.focus != focus { + t.Fatalf("a press off the sheet: help %v on %v focus %d", a.wall.help, a.wall.on, a.wall.focus) + } + + // The toolbar's Help puts it up. + _ = a.wallFrame(a.width, a.height) + wallClick(t, a, wallHitFor(t, a, wallHitAction, int(wallActHelp))) + if !a.wall.help { + t.Fatal("the toolbar's Help did not put up the sheet") + } +} + +// EVERY ROW OF THE SHEET IS A PRESS, and does what its key does, on the +// focused conversation, with the sheet put away first. +func TestWallHelpRowsDoWhatTheirKeysDo(t *testing.T) { + rows := wallHelpRows(false) + index := func(label string) int { + for i, r := range rows { + if r.label == label { + return i + } + } + t.Fatalf("no row %q", label) + return -1 + } + open := func() *app { + a, _, _ := tabApp(t) + _ = a.openWall() + a.wallSettle() + a.wallMove(0, len(a.wallShown(a.now()))) + _ = a.wallFrame(a.width, a.height) + wallKeyPress(a, "?") + _ = a.wallFrame(a.width, a.height) + return a + } + + a := open() + wallClick(t, a, wallHitFor(t, a, wallHitHelp, index("Move"))) + if a.wall.help || a.wall.focus != 1 { + t.Fatalf("Move: help %v focus %d", a.wall.help, a.wall.focus) + } + a = open() + wallClick(t, a, wallHitFor(t, a, wallHitHelp, index("Select"))) + if a.wall.help || len(a.wall.marked) != 1 { + t.Fatalf("Select: help %v marked %v", a.wall.help, a.wall.marked) + } + a = open() + wallClick(t, a, wallHitFor(t, a, wallHitHelp, index("Filter"))) + if a.wall.help || !a.wall.filterOn { + t.Fatalf("Filter: help %v filtering %v", a.wall.help, a.wall.filterOn) + } + a = open() + wallClick(t, a, wallHitFor(t, a, wallHitHelp, index("Add to teams"))) + if a.wall.help || a.wall.pop.kind != wallPopMembers { + t.Fatalf("Add to teams: help %v pop %+v", a.wall.help, a.wall.pop) + } + a = open() + wallClick(t, a, wallHitFor(t, a, wallHitHelp, index("Back"))) + if a.wall.help || a.wall.on { + t.Fatalf("Back: help %v on %v", a.wall.help, a.wall.on) + } + a = open() + key := a.wallShown(a.now())[0].tab.key + wallClick(t, a, wallHitFor(t, a, wallHitHelp, index("Open"))) + if a.wall.on || a.frontTabKey() != key { + t.Fatalf("Open: on %v front %q, want %q", a.wall.on, a.frontTabKey(), key) + } + + // And every row answers, on its own words, and closes the sheet. + for i, r := range rows { + a := open() + hit := wallHitFor(t, a, wallHitHelp, i) + if got := ansi.Strip(ansi.Cut(a.wallFrame(a.width, a.height)[hit.y0], hit.x0, hit.x1)); !strings.Contains(got, r.label) { + t.Fatalf("row %q is drawn as %q", r.label, got) + } + wallClick(t, a, hit) + if a.wall.help { + t.Fatalf("row %q left the sheet up", r.label) + } + } +} + +// THE SHEET SCROLLS WHEN IT DOES NOT FIT, by key and by wheel, and its foot +// says which way the rest lies; with room it drops nothing. +func TestWallHelpSheetScrolls(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, sz := range [][2]int{{80, 21}, {120, 40}, {60, 30}, {44, 20}, {80, 14}} { + v := wallUnmarked(wallFixture(6)) + v.help = true + name := fmt.Sprintf("%s %dx%d", pname, sz[0], sz[1]) + card := wallHelpCard(pal, v, sz[0], sz[1]) + if len(card.rows) == 0 { + t.Fatalf("%s: no sheet", name) + } + seen := map[int]bool{} + for top := 0; top <= card.over; top++ { + v.helpTop = top + rows, hits := renderWall(pal, v, sz[0], sz[1]) + wallCheckRows(t, name, rows, sz[0], sz[1]) + wallCheckHits(t, name, hits, sz[0], sz[1]) + for _, hit := range hits { + if hit.kind == wallHitHelp { + seen[hit.arg] = true + } + } + } + if len(seen) != len(wallHelpRows(pal.ascii)) { + t.Fatalf("%s: %d of %d rows reachable", name, len(seen), len(wallHelpRows(pal.ascii))) + } + if card.over > 0 && !strings.Contains(ansi.Strip(card.rows[len(card.rows)-1]), "more") { + t.Fatalf("%s: a scrolled sheet does not say so: %q", name, ansi.Strip(card.rows[len(card.rows)-1])) + } + } + } + + a, _, _ := tabApp(t) + a.height = 18 + _ = a.openWall() + a.wallSettle() + wallKeyPress(a, "?") + _ = a.wallFrame(a.width, a.height) + if a.wall.helpMax == 0 { + t.Fatalf("an 18-row window's sheet does not scroll:\n%s", wallPlainFrame(a.wallFrame(a.width, a.height))) + } + wallKeyPress(a, "down") + if a.wall.helpTop != 1 || !a.wall.help { + t.Fatalf("down: top %d help %v", a.wall.helpTop, a.wall.help) + } + wallKeyPress(a, "end") + if a.wall.helpTop != a.wall.helpMax { + t.Fatalf("end: top %d of %d", a.wall.helpTop, a.wall.helpMax) + } + wallKeyPress(a, "home") + scroll, focus := a.wall.scroll, a.wall.focus + a.wallWheel(10, a.wall.headRows+6, true) + if a.wall.helpTop != 1 || a.wall.scroll != scroll || a.wall.focus != focus { + t.Fatalf("the wheel: sheet at %d, grid at %d from %d, focus %d from %d", a.wall.helpTop, a.wall.scroll, scroll, a.wall.focus, focus) + } + t.Logf("80x18 window, the sheet scrolled a line:\n%s", wallPlainFrame(a.wallFrame(a.width, a.height))) +} diff --git a/internal/tui3/wallmini.go b/internal/tui3/wallmini.go new file mode 100644 index 0000000000..c3fc3d196b --- /dev/null +++ b/internal/tui3/wallmini.go @@ -0,0 +1,213 @@ +package tui3 + +import ( + "strings" + + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── A TILE IS THE CONVERSATION, SMALLER ───────────────────────────────────── +// +// A tile used to draw its tail as flattened text: every line one ink, fences +// stripped, a reply and a tool call told apart only by a leading mark. On a +// wall of six conversations that is six walls of grey, and the eye has nothing +// to land on. So a tile is drawn with the conversation's own pieces: the +// person's words under the `›` in their muted blue, the reply through the same +// markdown pass the transcript uses (headings, lists, code highlighted by +// chroma), and each tool call on the rail with its name and its target, a +// shell command highlighted as it is in the chat. +// +// IT DOES NOT CALL [app.renderEntry]. That painter caches rows by the entry's +// position in the conversation in front, and a tile drawn through it would +// write another conversation's rows into those slots. The pieces below are +// the stateless ones renderEntry is built from. +// +// AND IT IS DRAWN ONCE PER READING, not once per frame: the rows are kept on +// the tail against its version and the width they were drawn at, so a frame +// with nothing new costs a slice copy per tile. + +// wallRecentCap is how many entries a tail keeps for drawing. A tile is at +// most a screen tall, and a dozen entries fill that many times over. +const wallRecentCap = 12 + +// wallReplyBytes is the most of one reply a tile renders. The tile shows the +// end of it, and markdown over a whole essay to draw its last paragraph is work +// thrown away on every reading. +const wallReplyBytes = 3000 + +// wallMiniRows is the tail drawn at the given width, from the cache when the +// reading and the width have not moved. +func (a *app) wallMiniRows(t *wallTail, width int) []string { + if t == nil || width < 8 || len(t.recent) == 0 { + return nil + } + if t.rows != nil && t.rowsW == width && t.rowsVer == t.ver { + return t.rows + } + t.rows, t.rowsW, t.rowsVer = a.wallQuiet(a.wallDraw(t.recent, width)), width, t.ver + return t.rows +} + +// wallSharpRows is how many of a tile's newest rows keep the chat's full ink. +const wallSharpRows = 3 + +// wallQuiet puts a tile's body BELOW the chat in the hierarchy. A tile is a +// glance, and six of them drawn at the transcript's full ink are six +// conversations all asking to be read at once. So the fade ladder the long +// lists already use (depthfade.go) is spent on age: the newest rows, which say +// what the agent is doing now, keep their colour, and everything above them +// steps down the three stops toward the top of the tile. Sharp where the +// agent is, quiet where it was. +func (a *app) wallQuiet(rows []string) []string { + n := len(rows) + for i := range rows { + age := n - 1 - i + switch { + case age < wallSharpRows: + continue + case age < wallSharpRows+4: + rows[i] = a.pal.fadeRow(rows[i], 0) + case age < wallSharpRows+10: + rows[i] = a.pal.fadeRow(rows[i], 1) + default: + rows[i] = a.pal.fadeRow(rows[i], 2) + } + } + return rows +} + +// wallDoing is what a working conversation is doing, in two or three words, +// read off the newest entry it holds. It says nothing for a conversation at +// rest: the tile's age already tells that story. +func wallDoing(recent []session.DisplayEntry, signal tabSignal) string { + switch signal { + case tabNeedsPerson: + return "waiting on you" + case tabWorking: + default: + return "" + } + if len(recent) == 0 { + return "working" + } + last := recent[len(recent)-1] + switch last.Role { + case "tool": + if name, _ := toolWords(last.Tool, ""); name != "" { + return "running " + name + } + return "running a tool" + case "assistant": + return "writing" + } + return "thinking" +} + +// wallDraw lays the entries out oldest first, with the chat's own spacing: a +// blank row between turns, none inside a run of tool calls. +func (a *app) wallDraw(entries []session.DisplayEntry, width int) []string { + var out []string + prevTool := false + for i, e := range entries { + tool := e.Role == "tool" + var rows []string + switch e.Role { + case "user": + rows = a.wallUserRows(e.Text, width) + case "assistant": + rows = a.wallReplyRows(e.Text, width) + case "tool": + last := i == len(entries)-1 || entries[i+1].Role != "tool" + rows = a.wallToolRows(e, last, width) + default: + if line := strings.TrimSpace(firstLine(e.Text)); line != "" { + rows = []string{a.pal.italic(a.pal.dim(ansi.Truncate(line, width, "…")))} + } + } + if len(rows) == 0 { + continue + } + if len(out) > 0 && !(tool && prevTool) { + out = append(out, "") + } + out = append(out, rows...) + prevTool = tool + } + return out +} + +// wallUserRows is the person's message as the transcript draws it: the accent +// `›`, the words in muted, continuations hung under the text. A long message +// shows its first three rows; the reply under it is what a tile is for. +func (a *app) wallUserRows(text string, width int) []string { + text = strings.TrimSpace(text) + if text == "" { + return nil + } + body := wrap(text, width-2) + const most = 3 + if len(body) > most { + body = append(body[:most-1], ansi.Truncate(body[most-1], width-3, "")+"…") + } + rows := make([]string, 0, len(body)) + for i, line := range body { + lead := " " + if i == 0 { + lead = a.pal.accent("› ") + } + rows = append(rows, lead+a.pal.muted(line)) + } + return rows +} + +// wallReplyRows is the reply through the transcript's own markdown pass. Only +// its end is rendered, cut at a paragraph so a heading or a list is not split +// mid-row, and a fence the cut landed inside is reopened so the code under it +// is still drawn as code. +func (a *app) wallReplyRows(text string, width int) []string { + text = strings.TrimSpace(text) + if text == "" { + return nil + } + if len(text) > wallReplyBytes { + cut := len(text) - wallReplyBytes + if at := strings.Index(text[cut:], "\n\n"); at >= 0 && at < wallReplyBytes/2 { + cut += at + 2 + } + head, tail := text[:cut], text[cut:] + if strings.Count(head, "```")%2 == 1 { + tail = "```\n" + tail + } + text = tail + } + // No path linking: resolving a code span as a path asks the workspace, and + // this is drawn for conversations that are not the one in front. + return renderMarkdownWithCode(a.styler(), text, width, nil) +} + +// wallToolRows is one call on the rail: its name in muted, its target after +// it, a shell command highlighted exactly as the transcript highlights it. +func (a *app) wallToolRows(e session.DisplayEntry, last bool, width int) []string { + hint := e.Hint + if strings.TrimSpace(hint) == "" { + hint = e.Text + } + name, target := toolWords(e.Tool, hint) + if name == "" && target == "" { + return nil + } + rail := a.pal.dim(a.pal.rail(last)) + room := width - ansi.StringWidth(a.pal.rail(last)) - ansi.StringWidth(name) - 1 + line := rail + a.pal.muted(name) + if target != "" && target != name && room > 4 { + fit := ansi.Truncate(target, room, "…") + if e.Tool == "bash" { + line += " " + a.pal.shell(fit) + } else { + line += " " + a.pal.dim(fit) + } + } + return []string{line} +} diff --git a/internal/tui3/wallmini_test.go b/internal/tui3/wallmini_test.go new file mode 100644 index 0000000000..599d3d110e --- /dev/null +++ b/internal/tui3/wallmini_test.go @@ -0,0 +1,56 @@ +package tui3 + +import ( + "strings" + "testing" + + "github.com/charmbracelet/x/ansi" + + "github.com/Agent-Field/codeaf/internal/session" +) + +func wallMiniFixture() []session.DisplayEntry { + return []session.DisplayEntry{ + {Role: "user", Text: "why is the fan loud? check what is eating cpu"}, + {Role: "tool", Tool: "bash", Hint: "ps -Ao pid,pcpu,comm -r | head -5"}, + {Role: "tool", Tool: "read", Hint: "internal/tui3/keeper.go"}, + {Role: "assistant", Text: "## The culprit\n\n`mds_stores` is at **180%**. It is Spotlight indexing:\n\n- started 4m ago\n- stops on its own\n\n```go\nfor _, p := range procs {\n\tif p.CPU > 100 {\n\t\tfmt.Println(p.Name)\n\t}\n}\n```\n"}, + } +} + +func TestWallMiniDrawsTheChatsOwnPieces(t *testing.T) { + a := newTestApp(nil) + for _, width := range []int{20, 40, 56, 90} { + rows := a.wallDraw(wallMiniFixture(), width) + if len(rows) == 0 { + t.Fatalf("width %d: no rows", width) + } + for i, r := range rows { + if w := ansi.StringWidth(r); w > width { + t.Errorf("width %d row %d is %d cells: %q", width, i, w, ansi.Strip(r)) + } + } + plain := ansi.Strip(strings.Join(rows, "\n")) + for _, want := range []string{"› why is the fan", "bash", "The culprit", "mds_stores", "range procs"} { + if width >= 56 && !strings.Contains(plain, want) { + t.Errorf("width %d lacks %q\n%s", width, want, plain) + } + } + if width == 56 { + t.Logf("\n%s", strings.Join(rows, "\n")) + } + } +} + +func TestWallMiniRowsAreKeptPerReading(t *testing.T) { + a := newTestApp(nil) + tail := &wallTail{recent: wallMiniFixture(), ver: 1} + first := a.wallMiniRows(tail, 40) + if &a.wallMiniRows(tail, 40)[0] != &first[0] { + t.Fatal("a quiet frame redrew the tile") + } + tail.ver++ + if &a.wallMiniRows(tail, 40)[0] == &first[0] { + t.Fatal("a new reading kept the old rows") + } +} diff --git a/internal/tui3/wallmotion_test.go b/internal/tui3/wallmotion_test.go new file mode 100644 index 0000000000..2ba6ea81d2 --- /dev/null +++ b/internal/tui3/wallmotion_test.go @@ -0,0 +1,502 @@ +package tui3 + +import ( + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" +) + +// wallPinned is a wall over the three-conversation fixture with its clock held +// still, so every motion is asserted at a moment the test names. +func wallPinned(t *testing.T) (*app, *time.Time) { + t.Helper() + a, _, _ := tabApp(t) + now := time.Date(2026, 9, 23, 12, 0, 0, 0, time.UTC) + a.clock = func() time.Time { return now } + return a, &now +} + +// wallKeyPress is one key through the wall's own door. +func wallKeyPress(a *app, s string) tea.Cmd { return a.wallKey(key(s)) } + +// wallRectBlank reports whether every cell of r is blank in the plain frame. +func wallRectBlank(rows []string, r wallRect) bool { + for y := r.y0; y < r.y1 && y < len(rows); y++ { + line := []rune(plain(rows[y])) + for x := r.x0; x < r.x1 && x < len(line); x++ { + if line[x] != ' ' { + return false + } + } + } + return true +} + +// ONE PRESS ON A TILE OPENS IT, and the pointer resting on another first +// moved nothing: hover is a preview, and the keyboard's focus is its own. +func TestWallOnePressOnATileOpensIt(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + target := -1 + for i, tile := range tiles { + if !tile.here { + target = i + } + } + focus := a.wall.focus + body := wallHitFor(t, a, wallHitTile, target) + a.wallMotion(body.x0+4, body.y0+3) + _ = a.wallFrame(a.width, a.height) + if a.wall.focus != focus { + t.Fatalf("the hover moved the focus from %d to %d", focus, a.wall.focus) + } + if _, took := a.wallPress(body.x0+4, body.y0+3); !took { + t.Fatal("the wall did not take the press") + } + if a.wall.on { + t.Fatal("one press on a tile did not open it") + } + if a.frontTabKey() != tiles[target].tab.key { + t.Fatalf("the press opened %q, want %q", a.frontTabKey(), tiles[target].tab.key) + } +} + +// THE WHEEL MOVES THE VIEW A ROW A NOTCH, clamped to the list; a burst inside +// one settle is one row; a notch back is taken at once; and the focus moves +// only when the scroll would leave it off screen. +func TestWallWheelScrollsTheViewARowANotch(t *testing.T) { + a, now := wallPinned(t) + a.height = 30 + a.wall.cols = 1 + _ = a.openWall() + a.wallMove(0, len(a.wallShown(a.now()))) + _ = a.wallFrame(a.width, a.height) + n := len(a.wallShown(a.now())) + vis := a.wallRowsOnScreen(n) + if n-vis < 2 { + t.Fatalf("the fixture scrolls %d rows; the test needs two", n-vis) + } + x, y := 10, a.wall.headRows+6 + + a.wallWheel(x, y, true) + if a.wall.scroll != 1 || a.wall.focus != 1 { + t.Fatalf("one notch: scroll %d focus %d, want 1 and 1 (the focus left the screen)", a.wall.scroll, a.wall.focus) + } + *now = now.Add(10 * time.Millisecond) + a.wallWheel(x, y, true) + if a.wall.scroll != 1 { + t.Fatalf("a notch inside the settle moved the view to %d", a.wall.scroll) + } + *now = now.Add(wallWheelSettle) + a.wallWheel(x, y, true) + a.wallWheel(x, y, true) + if a.wall.scroll != 2 { + t.Fatalf("after the settle the view is at %d, want 2", a.wall.scroll) + } + *now = now.Add(wallWheelSettle) + a.wallWheel(x, y, true) + if a.wall.scroll != 2 { + t.Fatalf("the wheel scrolled past the end, to %d", a.wall.scroll) + } + a.wallWheel(x, y, false) + if a.wall.scroll != 1 { + t.Fatalf("a notch back inside the settle was not taken: %d", a.wall.scroll) + } + // The frame draws the scroll the wheel left, and lights what slid under + // the resting pointer. + _ = a.wallFrame(a.width, a.height) + if a.wall.scroll != 1 || a.wall.hover.kind != wallHitTile || a.wall.hover.arg != 1 { + t.Fatalf("after the frame: scroll %d hover %+v", a.wall.scroll, a.wall.hover) + } + + // A focus already on screen stays where it is. + a.wall.cols = 2 + a.wall.scroll = 0 + a.wallMove(0, n) + _ = a.wallFrame(a.width, a.height) + *now = now.Add(wallWheelSettle) + a.wallWheel(x, y, true) + if a.wall.focus != 0 && a.wallRowsOnScreen(n) > 1 { + t.Fatalf("a focus on screen moved to %d", a.wall.focus) + } +} + +// THE WALL COMES IN ROW BY ROW, in about a seventh of a second, and a key +// finishes it at once; the linear tier draws it whole. +func TestWallOpeningRevealsRowByRowAndAKeyFinishesIt(t *testing.T) { + a, now := wallPinned(t) + a.wall.cols = 1 + _ = a.openWall() + a.wallMove(0, len(a.wallShown(a.now()))) + a.wall.revealAt = *now + rows := a.wallFrame(a.width, a.height) + if a.wallRowsOnScreen(3) < 2 { + t.Fatal("the fixture shows one row; the reveal needs two") + } + first, _ := a.wallTileRect(0) + second, _ := a.wallTileRect(1) + if wallRectBlank(rows, first) { + t.Fatal("the first row waited: it is where the eye lands") + } + if !wallRectBlank(rows, second) { + t.Fatalf("the second row was drawn on the first frame:\n%s", plain(strings.Join(rows, "\n"))) + } + if !a.wallAnimating() { + t.Fatal("the reveal does not keep the paint clock turning") + } + *now = now.Add(wallRevealStep) + rows = a.wallFrame(a.width, a.height) + if wallRectBlank(rows, second) || !a.wall.revealAt.IsZero() { + t.Fatal("the second row is not in after its step") + } + + // A key during the reveal finishes it before it acts. + _ = a.openWall() + a.wall.revealAt = *now + _ = a.wallFrame(a.width, a.height) + wallKeyPress(a, "right") + if !a.wall.revealAt.IsZero() { + t.Fatal("a key did not finish the reveal") + } + if rows := a.wallFrame(a.width, a.height); wallRectBlank(rows, second) { + t.Fatal("the frame after the key is still revealing") + } + + a.closeWall() + a.linear = true + _ = a.openWall() + if !a.wall.revealAt.IsZero() { + t.Fatal("the linear tier was given a reveal") + } +} + +// AN OPENED TILE GROWS INTO THE FRAME over a few frames, around a conversation +// that is already in front, and a key ends the growing at once. +func TestWallOpenedTileZoomsIntoTheFrame(t *testing.T) { + a, now := wallPinned(t) + _ = a.openWall() + a.wallSettle() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + target := -1 + for i, tile := range tiles { + if !tile.here { + target = i + } + } + a.wallMove(target, len(tiles)) + _ = a.wallFrame(a.width, a.height) + from, _ := a.wallTileRect(target) + wallKeyPress(a, "enter") + if a.wall.on || a.frontTabKey() != tiles[target].tab.key { + t.Fatal("enter did not open the tile") + } + if !a.wallAnimating() { + t.Fatal("the zoom does not keep the paint clock turning") + } + lines := screenLines(a) + if from.y0 == 0 || strings.TrimSpace(lines[0]) != "" { + t.Fatalf("the first frame of the zoom drew outside the tile: %q", lines[0]) + } + if !strings.HasPrefix(strings.TrimLeft(lines[from.y0], " "), "╭") { + t.Fatalf("the zoom's edge is not on the tile's top row: %q", lines[from.y0]) + } + *now = now.Add(wallZoomFor) + _ = screenLines(a) + if !a.wall.zoomAt.IsZero() || a.wallAnimating() { + t.Fatal("the zoom outlived its time") + } + + // A key ends it on the spot. + a.wall.zoomFrom, a.wall.zoomAt = from, *now + a.key(key("h")) + if !a.wall.zoomAt.IsZero() { + t.Fatal("a key did not end the zoom") + } +} + +// ESC TAKES OFF THE INNERMOST THING FIRST: the popover, the card, the +// selection, the filter, and only then the wall. +func TestWallEscClosesTheInnermostLayerFirst(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + word := tiles[len(tiles)-1].tab.word + for _, r := range "/" + word[:3] { + wallKeyPress(a, string(r)) + } + wallKeyPress(a, "enter") + if a.wall.filter == "" || a.wall.filterOn { + t.Fatalf("filter %q on %v", a.wall.filter, a.wall.filterOn) + } + wallKeyPress(a, " ") + wallKeyPress(a, "m") + if a.wall.pop.kind != wallPopMembers || len(a.wall.marked) != 1 { + t.Fatalf("the setup: pop %+v marked %v", a.wall.pop, a.wall.marked) + } + steps := []struct { + name string + gone func() bool + }{ + {"the popover", func() bool { return a.wall.pop.kind == wallPopNone && len(a.wall.marked) == 1 }}, + {"the selection", func() bool { return len(a.wall.marked) == 0 && a.wall.filter != "" }}, + {"the filter", func() bool { return a.wall.filter == "" && a.wall.on }}, + {"the wall", func() bool { return !a.wall.on }}, + } + for _, step := range steps { + wallKeyPress(a, "esc") + if !step.gone() { + t.Fatalf("esc did not take off %s alone: pop %+v marked %v filter %q on %v", + step.name, a.wall.pop, a.wall.marked, a.wall.filter, a.wall.on) + } + } + + // The card goes before the selection under it. + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + wallKeyPress(a, "s") + wallKeyPress(a, "esc") + if a.wall.naming || len(a.wall.marked) != 1 || !a.wall.on { + t.Fatalf("esc on the card: naming %v marked %v on %v", a.wall.naming, a.wall.marked, a.wall.on) + } +} + +// A PRESS OFF A POPOVER OR A CARD PUTS IT AWAY and does nothing else; a press +// on the card's own blank does nothing at all. +func TestWallPressOffACardPutsItAway(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + a.wallSettle() + _ = a.wallFrame(a.width, a.height) + focus := a.wall.focus + wallKeyPress(a, "m") + _ = a.wallFrame(a.width, a.height) + card := a.wall.card + if card.w() == 0 { + t.Fatal("the popover's place was not recorded") + } + // Its own border is on the card and answers nothing. + if _, took := a.wallPress(card.x0, card.y0); !took || a.wall.pop.kind == wallPopNone { + t.Fatal("a press on the popover's border put it away") + } + x, y := a.width-3, a.height-3 + if card.holds(x, y) { + t.Fatal("the test's far corner is on the card") + } + if _, took := a.wallPress(x, y); !took { + t.Fatal("the wall did not take the press") + } + if a.wall.pop.kind != wallPopNone || !a.wall.on || a.wall.focus != focus { + t.Fatalf("a press off the popover: pop %+v on %v focus %d", a.wall.pop, a.wall.on, a.wall.focus) + } + + wallKeyPress(a, "s") + _ = a.wallFrame(a.width, a.height) + if a.wall.card.w() == 0 { + t.Fatal("the card's place was not recorded") + } + if _, took := a.wallPress(1, a.height-3); !took || a.wall.naming || !a.wall.on || len(a.wall.marked) != 1 { + t.Fatalf("a press off the card: naming %v on %v marked %v", a.wall.naming, a.wall.on, a.wall.marked) + } +} + +// CLOSING A TILE HANDS THE FOCUS TO ITS RIGHT, or at the end of the list to +// its left, and never back to the start; closing another tile keeps the +// focus on the conversation it was on. +func TestWallCloseHandsTheFocusToTheNeighbour(t *testing.T) { + // The fixture is two conversations behind and the one in front, last. + fresh := func() (*app, []wallTile) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + if len(tiles) != 3 || tiles[0].here || tiles[1].here { + t.Fatalf("the fixture changed: %d tiles", len(tiles)) + } + return a, tiles + } + focused := func(a *app) string { return a.wallShown(a.now())[a.wall.focus].tab.key } + + a, tiles := fresh() + a.wallMove(0, len(tiles)) + wallKeyPress(a, "x") + if got := focused(a); got != tiles[1].tab.key { + t.Fatalf("closing the focused tile focused %q, want its right neighbour %q", got, tiles[1].tab.key) + } + + a, tiles = fresh() + a.wallMove(1, len(tiles)) + _ = a.wallDismissAt(tiles, 0) + if got := focused(a); got != tiles[1].tab.key { + t.Fatalf("closing another tile moved the focus to %q", got) + } + + // At the end of the list there is no right: the left neighbour takes it. + a, tiles = fresh() + before := append(append([]wallTile(nil), tiles...), wallTile{tab: chatTab{key: "gone"}}) + a.wallRefocus(before, "gone") + if a.wall.focus != len(tiles)-1 { + t.Fatalf("the last tile gone focused %d, want %d", a.wall.focus, len(tiles)-1) + } +} + +// EACH TEAM KEEPS ITS PLACE while the wall is up: All, then harbor, then All +// again, returns to the tile that was focused. +func TestWallTeamsKeepTheirPlace(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + id, err := a.teamMake("harbor", []chatTab{tiles[0].tab, tiles[1].tab}) + if err != nil { + t.Fatal(err) + } + a.wallMove(2, len(tiles)) + all := tiles[2].tab.key + wallKeyPress(a, "1") + if a.wall.activeID != id || a.wall.focus != 0 { + t.Fatalf("1: team %q focus %d", a.wall.activeID, a.wall.focus) + } + wallKeyPress(a, "right") + harbor := a.wallShown(a.now())[a.wall.focus].tab.key + wallKeyPress(a, "1") + if a.wall.activeID != "" { + t.Fatalf("the shown team's digit did not go back to All: %q", a.wall.activeID) + } + if got := a.wallShown(a.now())[a.wall.focus].tab.key; got != all { + t.Fatalf("All came back on %q, want %q", got, all) + } + wallKeyPress(a, "tab") + if got := a.wallShown(a.now())[a.wall.focus].tab.key; a.wall.activeID != id || got != harbor { + t.Fatalf("harbor came back on %q, want %q", got, harbor) + } +} + +// A FILTER FOCUSES ITS FIRST MATCH, the arrows walk the matches while the box +// is up, and clearing it keeps the conversation the focus was on. +func TestWallFilterFocusesTheFirstMatchAndClearingKeepsIt(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + a.wallMove(0, len(tiles)) + want := tiles[len(tiles)-1] + wallKeyPress(a, "/") + for _, r := range want.tab.word { + wallKeyPress(a, string(r)) + } + shown := a.wallShown(a.now()) + if len(shown) == 0 || a.wall.focus != 0 || shown[0].tab.key != want.tab.key { + t.Fatalf("the filter focused %d of %d", a.wall.focus, len(shown)) + } + wallKeyPress(a, "esc") + if a.wall.filter != "" || a.wallShown(a.now())[a.wall.focus].tab.key != want.tab.key { + t.Fatalf("clearing the filter lost the match: focus %d", a.wall.focus) + } +} + +// THE PICKED ARE ACTED ON BY THE SAME KEYS AS THE TRAY'S BUTTONS: m is Add +// to…, x is Close views; e opens the shown team's settings. +func TestWallKeysDoWhatTheButtonsDo(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + tiles := a.wallShown(a.now()) + var behind []int + for i, tile := range tiles { + if !tile.here { + behind = append(behind, i) + } + } + for _, i := range behind { + a.wallToggle(tiles, i) + } + wallKeyPress(a, "m") + if a.wall.pop.kind != wallPopMembers || len(a.wall.pop.targets) != len(behind) { + t.Fatalf("m with %d picked: %+v", len(behind), a.wall.pop) + } + wallKeyPress(a, "esc") + wallKeyPress(a, "x") + if n := len(a.wallShown(a.now())); n != len(tiles)-len(behind) { + t.Fatalf("x with %d picked left %d of %d", len(behind), n, len(tiles)) + } + + harbor, err := a.teamMake("harbor", []chatTab{tiles[0].tab}) + if err != nil { + t.Fatal(err) + } + wallKeyPress(a, "e") + if a.wall.pop.kind != wallPopNone || a.tsheet.on { + t.Fatal("e with no team shown opened something") + } + wallKeyPress(a, "1") + _ = a.wallFrame(a.width, a.height) + wallKeyPress(a, "e") + if !a.tsheet.on || a.tsheet.team != harbor { + t.Fatalf("e: %+v", a.tsheet) + } +} + +// A POINTER WANDERING INSIDE ONE TARGET REUSES THE FRAME it was given; one +// that crosses onto another target, or rests there after a scroll, does not. +func TestWallPointerInsideOneTargetDrawsNothing(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + body := wallHitFor(t, a, wallHitTile, 0) + a.wallMotion(body.x0+4, body.y0+3) + _ = a.wallFrame(a.width, a.height) + a.ptr.still = false + a.wallMotion(body.x0+6, body.y0+4) + if !a.ptr.still { + t.Fatal("a motion inside the same tile asked for a new frame") + } + a.ptr.still = false + a.wall.stirred = true + a.wallMotion(body.x0+7, body.y0+4) + if a.ptr.still { + t.Fatal("a motion after the grid moved reused the old frame") + } +} + +// THE WALL'S SPINNER COUNTS IN TIME, so a wall drawn on its half-second tick +// shows where the spinner has got to; the reduced tiers draw it still. +func TestWallSpinnerCountsInTime(t *testing.T) { + at := time.Date(2026, 9, 23, 12, 0, 0, 0, time.UTC) + step := spinnerStep * frameInterval + if wallSpin(at.Add(step)) != wallSpin(at)+1 { + t.Fatal("one spinner step of time is not one step of the spinner") + } + a, _, _ := tabApp(t) + a.linear = true + if !a.wallReduced() || a.wallMotionOK() { + t.Fatal("the linear tier is not reduced") + } +} + +// A WAITING TILE'S ANSWER AND ITS OPEN ↗ SHARE A TARGET, and the painter is +// told the pointer's row so it lights the one under it: moving between the +// two rows on the same target is a new frame. +func TestWallPointerRowReachesThePainter(t *testing.T) { + a, _, _ := tabApp(t) + _ = a.openWall() + _ = a.wallFrame(a.width, a.height) + body := wallHitFor(t, a, wallHitTile, 0) + a.wallMotion(body.x0+4, body.y0+3) + _ = a.wallFrame(a.width, a.height) + if !a.wall.ptrIn || a.wall.ptrY-a.wall.headRows != body.y0+3-a.wall.headRows { + t.Fatalf("the pointer's row is not kept: in %v y %d", a.wall.ptrIn, a.wall.ptrY) + } + a.wall.hover = wallHitRef{kind: wallHitOpen, arg: 0} + a.wall.hits = []wallHit{{x0: 0, y0: 0, x1: a.width, y1: a.height, kind: wallHitOpen, arg: 0}} + a.ptr.still = false + a.wallMotion(5, a.wall.ptrY+1) + if a.ptr.still || !a.wall.stirred { + t.Fatal("a new row on a shared target reused the old frame") + } +} diff --git a/internal/tui3/wallpop.go b/internal/tui3/wallpop.go new file mode 100644 index 0000000000..ff107a3c91 --- /dev/null +++ b/internal/tui3/wallpop.go @@ -0,0 +1,305 @@ +package tui3 + +import ( + tea "charm.land/bubbletea/v2" +) + +// ── THE WALL'S POPOVERS, WIRED ────────────────────────────────────────────── +// +// Two small cards hang off the control that opened them (wallbar.go draws +// them): which teams a conversation is in, and one team's settings. While +// one is up it has the keyboard, and a press anywhere off it puts it away and +// does nothing else, as a menu's does. +// +// A CONVERSATION MAY BE IN ANY NUMBER OF TEAMS. The teams popover is a list +// of boxes, one per team, and a box pressed is saved at once: there is no +// apply, because a grouping is cheap to change and cheap to change back. + +// wallPopDone is the settings popover's Done: the name kept, the popover put +// away, what enter does. It is a row code beside wallcontract.go's, and is +// kept here because this file is the only one that answers it. +const wallPopDone = -5 + +// wallLocal is a hit's cells as an anchor in the painter's own rows, which +// start under the head. +func (a *app) wallLocal(hit wallHit) wallPop { + return wallPop{x: hit.x0, y0: hit.y0 - a.wall.headRows, y1: hit.y1 - a.wall.headRows} +} + +// wallAnchor is where the last frame drew the target of this kind and arg, as +// an anchor; a popover opened from the keyboard hangs where a press would +// have opened it. With no such target it hangs from the tile itself. +func (a *app) wallAnchor(kind wallHitKind, arg int) wallPop { + var fallback *wallHit + for i, hit := range a.wall.hits { + if hit.kind == kind && hit.arg == arg { + return a.wallLocal(hit) + } + if fallback == nil && hit.kind == wallHitTile && hit.arg == arg { + fallback = &a.wall.hits[i] + } + } + if fallback != nil { + return a.wallLocal(*fallback) + } + return wallPop{x: 2, y0: 2, y1: 3} +} + +// wallAnchorTeam is [app.wallAnchor] for a target on team id: where the last +// frame drew it, or a corner of the grid when it was not drawn. +func (a *app) wallAnchorTeam(kind wallHitKind, id string) wallPop { + for _, hit := range a.wall.hits { + if hit.kind == kind && hit.id == id { + return a.wallLocal(hit) + } + } + return wallPop{x: 2, y0: 2, y1: 3} +} + +// wallOpenMembers puts up the teams popover for the conversations with the +// given keys. +func (a *app) wallOpenMembers(keys []string, at wallPop) { + if len(keys) == 0 { + return + } + a.teamsEnsure() + at.kind = wallPopMembers + at.targets = keys + a.wall.pop = at + a.wall.filterOn = false +} + +// wallOpenSettings puts up team id's settings: its name ready to edit, and +// the colour it has first among the others it could take. +func (a *app) wallOpenSettings(id string, at wallPop) { + t, ok := a.teamByID(id) + if !ok { + return + } + at.kind = wallPopSettings + at.team = id + at.name = t.Name + at.choices = append([]teamHueSpec{t.HueSpec()}, + teamHueChoices(a.teamHues(id), teamReservedHues(a.pal), wallSwatchCount-1)...) + at.choice = 0 + a.wall.pop = at + a.wall.filterOn = false +} + +// wallTabsFor is the conversations with the given keys, as the strip knows +// them; a key the wall is not showing (a filter hides it) is looked up on the +// strip's whole list. +func (a *app) wallTabsFor(keys []string, tiles []wallTile) []chatTab { + var out []chatTab + for _, key := range keys { + found := false + for _, tile := range tiles { + if tile.tab.key == key { + out, found = append(out, tile.tab), true + break + } + } + if found { + continue + } + for _, tab := range a.tabList() { + if tab.key == key { + out = append(out, tab) + break + } + } + } + return out +} + +// wallToggleTeam is a box in the teams popover pressed: the targets all go +// into team id, unless they are all in it already, in which case they all +// come out. A mixed box fills first, which is what a checkbox does. +func (a *app) wallToggleTeam(id string, tiles []wallTile) { + t, ok := a.teamByID(id) + if !ok { + return + } + tabs := a.wallTabsFor(a.wall.pop.targets, tiles) + all := len(tabs) > 0 + for _, tab := range tabs { + if !teamHolds(t, tab.key) { + all = false + } + } + var err error + if all { + keys := make([]string, 0, len(tabs)) + for _, tab := range tabs { + keys = append(keys, tab.key) + } + err = a.teamRemove(id, keys) + } else { + err = a.teamAdd(id, tabs) + } + if err != nil { + a.note("the team is changed for this window, but " + err.Error()) + } +} + +// wallPopManagerRow is the teams popover's manager row: offered when the +// popover is about one conversation and that conversation is in the team shown, +// as Make manager, or as Remove manager when it is that team's manager already. +// Frame-safe: memory only. +func (a *app) wallPopManagerRow() int { + p := a.wall.pop + if p.kind != wallPopMembers || len(p.targets) != 1 { + return 0 + } + t, ok := a.teamActive() + if !ok || !teamHolds(t, p.targets[0]) { + return 0 + } + if t.Manager == p.targets[0] { + return wallManagerRemove + } + return wallManagerMake +} + +// wallPopToggleManager is the popover's manager row pressed. The popover stays +// up, so the row's word is seen to flip. +func (a *app) wallPopToggleManager(tiles []wallTile) { + if a.wallPopManagerRow() == 0 { + return + } + t, _ := a.teamActive() + tabs := a.wallTabsFor(a.wall.pop.targets, tiles) + if len(tabs) == 0 { + return + } + if err := a.teamToggleManager(t.ID, tabs[0]); err != nil { + a.note("the manager is changed for this window, but " + err.Error()) + } +} + +// wallPopNewTeam is + New team… in the teams popover: the new-team card, +// with the popover's conversations as the ones picked. +func (a *app) wallPopNewTeam(tiles []wallTile) tea.Cmd { + keys := a.wall.pop.targets + a.wall.pop = wallPop{} + a.wall.marked = map[string]bool{} + for _, key := range keys { + a.wall.marked[key] = true + } + return a.wallStartNaming(tiles) +} + +// wallRecolor takes colour j of the settings popover's choices, at once. +func (a *app) wallRecolor(j int) { + p := &a.wall.pop + if j < 0 || j >= len(p.choices) { + return + } + p.choice = j + if err := a.teamRecolor(p.team, p.choices[j]); err != nil { + a.note("the colour is kept for this window, but " + err.Error()) + } +} + +// wallRenameFromPop saves the settings popover's name if it changed. +func (a *app) wallRenameFromPop() { + p := a.wall.pop + if t, ok := a.teamByID(p.team); !ok || p.name == t.Name { + return + } + if err := a.teamRename(p.team, p.name); err != nil { + a.note(err.Error()) + } +} + +// wallPopPress is a press on a popover's own row or swatch. +func (a *app) wallPopPress(hit wallHit, tiles []wallTile) tea.Cmd { + p := &a.wall.pop + switch { + case hit.kind == wallHitSwatch && p.kind == wallPopSettings: + a.wallRecolor(hit.arg) + case p.kind == wallPopMembers && hit.arg == wallPopNew: + return a.wallPopNewTeam(tiles) + case p.kind == wallPopMembers && hit.arg == wallPopManager: + p.cursor = len(a.wallTeams()) + 1 + a.wallPopToggleManager(tiles) + case p.kind == wallPopMembers: + if i := teamIndex(a.wallTeams(), hit.id); i >= 0 { + p.cursor = i + } + a.wallToggleTeam(hit.id, tiles) + case hit.arg == wallPopDelete: + p.confirm = true + case hit.arg == wallPopKeep: + p.confirm = false + case hit.arg == wallPopConfirm: + a.wallDeleteTeam(p.team) + case hit.arg == wallPopDone: + a.wallRenameFromPop() + a.wall.pop = wallPop{} + } + return nil +} + +// wallPopKey is a key while a popover is up. The teams popover walks its rows +// with the arrows and presses one with space or enter; the settings popover +// takes typing into the name, the arrows through the colours, and enter to +// keep the name. esc puts either away. +func (a *app) wallPopKey(msg tea.KeyPressMsg, tiles []wallTile) tea.Cmd { + p := &a.wall.pop + key := msg.String() + if key == "esc" { + if p.confirm { + p.confirm = false + return nil + } + a.wall.pop = wallPop{} + return nil + } + switch p.kind { + case wallPopMembers: + last := len(a.wallTeams()) // the + New team row + end := last + if a.wallPopManagerRow() != 0 { + end = last + 1 // the manager row under it + } + switch key { + case "up", "k": + p.cursor = max(p.cursor-1, 0) + case "down", "j": + p.cursor = min(p.cursor+1, end) + case "space", "enter": + if p.cursor > last { + a.wallPopToggleManager(tiles) + return nil + } + if p.cursor >= last { + return a.wallPopNewTeam(tiles) + } + if p.cursor >= 0 { + a.wallToggleTeam(a.wallTeams()[p.cursor].ID, tiles) + } + } + case wallPopSettings: + switch key { + case "enter": + a.wallRenameFromPop() + a.wall.pop = wallPop{} + case "backspace": + p.name = dropLastRune(p.name) + case "left", "right": + if c := len(p.choices); c > 0 { + step := 1 + if key == "left" { + step = c - 1 + } + a.wallRecolor((p.choice + step) % c) + } + default: + if t := msg.Key().Text; t != "" { + p.name += t + } + } + } + return nil +} diff --git a/internal/tui3/wallquiet_test.go b/internal/tui3/wallquiet_test.go new file mode 100644 index 0000000000..1c162b2efb --- /dev/null +++ b/internal/tui3/wallquiet_test.go @@ -0,0 +1,20 @@ +package tui3 + +import "testing" + +// THE WALL READS THE FRONT ONLY WHEN IT MOVED. A second look at a front whose +// entries have not changed is not a reason to read its whole transcript +// again; a new entry is. +func TestTheWallReadsTheFrontOnlyWhenItMoved(t *testing.T) { + a, _, _ := tabApp(t) + if !a.wallFrontMoved() { + t.Fatal("the first look at the front did not count as a change") + } + if a.wallFrontMoved() { + t.Fatal("an unchanged front counted as moved") + } + a.entries = append(a.entries, entry{kind: entryNote, text: "something new"}) + if !a.wallFrontMoved() { + t.Fatal("a new entry in front did not count as moved") + } +} diff --git a/internal/tui3/walltail.go b/internal/tui3/walltail.go new file mode 100644 index 0000000000..332bbb6b43 --- /dev/null +++ b/internal/tui3/walltail.go @@ -0,0 +1,530 @@ +package tui3 + +import ( + "strconv" + "strings" + "time" + + tea "charm.land/bubbletea/v2" + + "github.com/Agent-Field/codeaf/internal/fuzzy" + "github.com/Agent-Field/codeaf/internal/session" +) + +// ── THE WALL'S READING: WHAT EACH OPEN CONVERSATION IS SAYING ─────────────── +// +// This file turns what this process holds into tiles (wallcontract.go names +// the shapes). It has two halves and the line between them is the frame law. +// +// THE READ IS OFF THE LOOP. [session.Agent.Transcript] takes the agent's mutex +// and shapes every message it holds, and over an engine handle it crosses a +// wire. So it is only ever called inside a command ([app.wallReadCmd]), and the +// entries come back as a message the loop folds into the cache +// ([app.wallTakeRead]). A turn holding the lock stalls a goroutine, never a +// keystroke. +// +// THE TILES ARE READ OFF THE CACHE. [app.wallTiles] is called by the frame, so +// it reads the strip's own list, the cache and [app.tabSignalFor], and nothing +// else: no file, no wire, no mutex (framedisk_law_test.go). +// +// WHAT WAKES A READING is what already wakes the surface. A held conversation's +// stir ([behindStirMsg]) asks for its tile, throttled so a streaming answer is +// read four times a second rather than once per token, and a half-second tick +// reads the front and every tile that says it is working, because the +// conversation in front has no watcher to stir for it. +// +// OVER A SHARED ENGINE HANDLE ONLY THE FRONT IS LIVE ([Options.SharedAgent]). +// That handle holds one conversation at a time and the keeper holds nothing, +// so every other tile is the last reading this window took of it: a snapshot, +// drawn as one, never refreshed by pretending to read a conversation the engine +// has already let go of. + +// wallStirEvery is the fastest one conversation's tile is read on a stir. +const wallStirEvery = 250 * time.Millisecond + +// wallTickEvery is the wall's own clock while it is up. +const wallTickEvery = 500 * time.Millisecond + +// wallSparkBytes is how many bytes of growth make one step of the sparkline. +// Forty is about a line of prose, so a steady stream reads mid-height and a +// tool dumping output reads full. +const wallSparkBytes = 40 + +// wallReadMsg is one conversation's transcript, read off the loop. at is when +// the read began, so a slow read that lands after a newer one is dropped. +type wallReadMsg struct { + key string + entries []session.DisplayEntry + at time.Time + live bool +} + +// wallTickMsg is the wall's clock. +type wallTickMsg struct{ at time.Time } + +// wallTailFrom flattens a transcript into the tail a tile draws: logical lines, +// oldest first, at most [wallTailCap] of them, and the total text length the +// next reading measures growth against. +// +// IT WALKS FROM THE END and stops shaping once the cap is full, because a +// long conversation has thousands of entries and a tile shows forty lines. +// Only the length sum walks the whole list, and that is one add per entry. +func wallTailFrom(entries []session.DisplayEntry) (lines []wallLine, textLen int) { + for i := range entries { + textLen += len(entries[i].Text) + } + var chunks [][]wallLine + have := 0 + for i := len(entries) - 1; i >= 0 && have < wallTailCap; i-- { + chunk := wallEntryLines(entries[i]) + if len(chunk) == 0 { + continue + } + chunks = append(chunks, chunk) + have += len(chunk) + } + lines = make([]wallLine, 0, have) + for i := len(chunks) - 1; i >= 0; i-- { + lines = append(lines, chunks[i]...) + } + if len(lines) > wallTailCap { + lines = lines[len(lines)-wallTailCap:] + } + return lines, textLen +} + +// wallEntryLines is one entry as tail lines. A tool call is ONE line whatever +// it printed, because a tile is a glance and a glance wants what was done, not +// its output. Blank lines are dropped everywhere: a tile has a handful of rows +// and a blank one is a row spent saying nothing. +func wallEntryLines(e session.DisplayEntry) []wallLine { + switch e.Role { + case "assistant": + var out []wallLine + for _, raw := range strings.Split(e.Text, "\n") { + if text := wallProseLine(raw); text != "" { + out = append(out, wallLine{kind: wallProse, text: text}) + } + } + return out + case "tool": + what := strings.TrimSpace(e.Hint) + if what == "" { + what = wallFirstLine(e.Text) + } + name := strings.TrimSpace(e.Tool) + if name == "" { + name = "tool" + } + text := "▸ " + name + if what != "" { + text += " " + what + } + return []wallLine{{kind: wallTool, text: text}} + case "user": + var out []wallLine + for _, raw := range strings.Split(e.Text, "\n") { + text := strings.TrimSpace(raw) + if text == "" { + continue + } + lead := " " + if len(out) == 0 { + lead = "› " + } + out = append(out, wallLine{kind: wallUser, text: lead + text}) + } + return out + case "note", "aside": + // A compaction summary is pages long and a task's note a paragraph; the + // tile says that one happened, in its first line. + if text := wallFirstLine(e.Text); text != "" { + return []wallLine{{kind: wallNote, text: text}} + } + } + return nil +} + +// wallProseLine takes the markdown's scaffolding off one line, lightly: a +// fence is dropped, a heading loses its hashes, emphasis and code ticks go. +// The painter has no markdown renderer and a tile drawn with raw `**` in it +// reads as noise. +func wallProseLine(raw string) string { + text := strings.TrimSpace(raw) + if text == "" || strings.HasPrefix(text, "```") || strings.HasPrefix(text, "~~~") { + return "" + } + if strings.HasPrefix(text, "#") { + text = strings.TrimSpace(strings.TrimLeft(text, "#")) + } + text = strings.NewReplacer("**", "", "__", "", "`", "").Replace(text) + if strings.HasPrefix(text, "- ") || strings.HasPrefix(text, "* ") { + text = "• " + text[2:] + } + return strings.TrimSpace(text) +} + +// wallFirstLine is the first non-blank line of s, trimmed. +func wallFirstLine(s string) string { + for _, raw := range strings.Split(s, "\n") { + if text := strings.TrimSpace(raw); text != "" { + return text + } + } + return "" +} + +// take folds one reading into the cache: the new tail, how many of its last +// lines are fresh, and one activity sample for the second it was read in. +// +// THE FIRST READING IS NOT ACTIVITY. Opening the wall on a conversation with a +// long history reads all of it at once, and a tile that lit every line and +// spiked its sparkline for that would be saying the history just happened. +// +// A SHRINKING TRANSCRIPT IS A NEW ONE (a rewind, a compaction), so it is taken +// as a first reading too: nothing fresh, nothing sampled. +func (t *wallTail) take(entries []session.DisplayEntry, now time.Time, live bool) { + lines, textLen := wallTailFrom(entries) + first := t.seen.IsZero() || len(entries) < t.count + fresh, grew := 0, 0 + if !first && textLen > t.textLen { + grew = textLen - t.textLen + } + if !first && (len(entries) > t.count || grew > 0) { + prefix := 0 + for i := 0; i < t.count && i < len(entries); i++ { + prefix += len(entries[i].Text) + } + if prefix > t.textLen { + // The entry that was last grew: one fresh line, however it wrapped. + fresh++ + } + if t.count < len(entries) { + for i := t.count; i < len(entries); i++ { + fresh += len(wallEntryLines(entries[i])) + } + } + if fresh > len(lines) { + fresh = len(lines) + } + } + if first || len(entries) != t.count || textLen != t.textLen { + t.ver++ + from := max(len(entries)-wallRecentCap, 0) + t.recent = append([]session.DisplayEntry(nil), entries[from:]...) + } + t.lines, t.count, t.textLen, t.seen, t.live = lines, len(entries), textLen, now, live + if first { + t.fresh = 0 + return + } + if fresh > 0 { + t.fresh, t.freshAt = fresh, now + } + if grew > 0 || fresh > 0 { + sample := (grew + wallSparkBytes - 1) / wallSparkBytes + if sample < 1 { + sample = 1 + } + t.sample(now, sample) + } +} + +// sample adds activity to the ring slot for now's second, clearing every slot +// the ring skipped over since the last sample: a second nobody sampled was a +// second nothing happened, and it must read 0, not whatever was in that slot +// twenty-four seconds ago. +func (t *wallTail) sample(now time.Time, n int) { + sec := now.Unix() + if t.sparkAt.IsZero() { + t.spark = [wallSparkLen]uint8{} + } else { + last := t.sparkAt.Unix() + switch { + case sec < last: + // A reading from before the newest sample; the ring has moved on. + return + case sec-last >= wallSparkLen: + t.spark = [wallSparkLen]uint8{} + default: + for s := last + 1; s <= sec; s++ { + t.spark[s%wallSparkLen] = 0 + } + } + } + t.sparkAt = time.Unix(sec, 0) + slot := &t.spark[sec%wallSparkLen] + if v := int(*slot) + n; v > 7 { + *slot = 7 + } else { + *slot = uint8(v) + } +} + +// sparkline is the ring as the painter draws it: oldest first, one sample per +// second ending at now's second, len [wallSparkLen]. Seconds after the newest +// sample, and seconds older than the ring, read 0. +func (t *wallTail) sparkline(now time.Time) []uint8 { + out := make([]uint8, wallSparkLen) + if t.sparkAt.IsZero() { + return out + } + newest, end := t.sparkAt.Unix(), now.Unix() + for i := range out { + sec := end - int64(wallSparkLen-1-i) + if sec > newest || sec <= newest-wallSparkLen || sec < 0 { + continue + } + out[i] = t.spark[sec%wallSparkLen] + } + return out +} + +// wallAge spells a duration the way a tile has room for: one number, one unit. +func wallAge(d time.Duration) string { + if d < 0 { + d = 0 + } + switch { + case d < time.Minute: + return strconv.Itoa(int(d/time.Second)) + "s" + case d < time.Hour: + return strconv.Itoa(int(d/time.Minute)) + "m" + case d < 24*time.Hour: + return strconv.Itoa(int(d/time.Hour)) + "h" + } + return strconv.Itoa(int(d/(24*time.Hour))) + "d" +} + +// wallAgentFor is the agent behind one tab's key, and whether a reading of it +// is live, or nil when this window holds nothing it can read for that key. +// +// THE FRONT IS a.agent AND A HELD ONE IS THE KEEPER'S. Over a shared handle +// the keeper is empty by construction ([app.stow]), so every other key answers +// nil here and its tile stays the snapshot it last was. +func (a *app) wallAgentFor(key string) (Agent, bool) { + if key == "" { + return nil, false + } + if key == a.frontTabKey() { + if a.agent == nil { + return nil, false + } + return a.agent, true + } + if a.shared { + return nil, false + } + if held := a.behind[key]; held != nil && held.conv.Agent != nil { + return held.conv.Agent, true + } + return nil, false +} + +// wallReadCmd reads each key's transcript off the loop, one message per key. +// It is nil when no key resolves to an agent, so a caller can batch it blind. +func (a *app) wallReadCmd(keys ...string) tea.Cmd { + var cmds []tea.Cmd + for _, key := range keys { + agent, live := a.wallAgentFor(key) + if agent == nil { + continue + } + key := key + cmds = append(cmds, func() tea.Msg { + at := time.Now() + return wallReadMsg{key: key, entries: agent.Transcript(), at: at, live: live} + }) + } + switch len(cmds) { + case 0: + return nil + case 1: + return cmds[0] + } + return tea.Batch(cmds...) +} + +// wallTakeRead folds one reading into the cache, on the loop. +// +// A READING OLDER THAN THE CACHE IS DROPPED: two reads of one conversation can +// cross, and the tail must never step backwards. Over a shared handle a read +// that began before a swap names a key that is no longer in front, and the +// handle it read now holds a different conversation, so that one is dropped +// too rather than filed under the wrong tile. +func (a *app) wallTakeRead(msg wallReadMsg) { + if msg.key == "" { + return + } + if a.shared && msg.key != a.frontTabKey() { + return + } + if a.wall.tails == nil { + a.wall.tails = map[string]*wallTail{} + } + tail := a.wall.tails[msg.key] + if tail == nil { + tail = &wallTail{} + a.wall.tails[msg.key] = tail + } + if !tail.seen.IsZero() && !msg.at.After(tail.seen) { + return + } + tail.take(msg.entries, msg.at, msg.live) +} + +// wallStir is a held conversation's stir, as the wall hears it: a read of that +// one tile, at most once per [wallStirEvery]. A stir inside the window is not +// lost work: the tick reads every working tile anyway. +func (a *app) wallStir(key string) tea.Cmd { + if !a.wall.on { + return nil + } + if tail := a.wall.tails[key]; tail != nil && time.Since(tail.seen) < wallStirEvery { + return nil + } + return a.wallReadCmd(key) +} + +// wallTick is the wall's clock: read the front and every tile whose signal +// says it is working or waiting, and come round again. It is nil when the wall +// is down, which is what stops the clock. +func (a *app) wallTick() tea.Cmd { + if !a.wall.on { + a.wall.ticking = false + return nil + } + a.wall.ticking = true + // ONLY WHAT MOVED IS READ. The front conversation's transcript is asked for + // when the surface's own entries say it changed ([app.wallFrontMoved]); a + // held one is read on its stir ([app.wallStir]), and here only when its tile + // has never been read. A whole transcript every half second, per working + // tile, was the wall's cost with nothing on it moving. + front := a.frontTabKey() + var keys []string + if a.wall.tails[front] == nil || a.wallFrontMoved() { + keys = append(keys, front) + } + for _, tab := range a.tabList() { + if tab.start || tab.work || tab.key == front || a.wall.tails[tab.key] != nil { + continue + } + if a.tabSignalFor(tab.key, tab.here) != tabIdle { + keys = append(keys, tab.key) + } + } + next := tea.Tick(wallTickEvery, func(at time.Time) tea.Msg { return wallTickMsg{at: at} }) + // A tile that started working since the paint clock last stopped wants it + // turning again for its spinner ([app.wallSpinning]); nil when it is. + if a.wallSpinning() { + next = tea.Batch(next, a.wake()) + } + if read := a.wallReadCmd(keys...); read != nil { + return tea.Batch(read, next) + } + return next +} + +// wallFrontVer is a cheap reading of the conversation in front: how many +// entries the surface holds, how long the newest one is, and whether a turn is +// running. Two equal readings are a transcript nobody wrote to. +type wallFrontVer struct { + file string + n, last int + working, ok bool +} + +// wallFrontMoved reports whether the front has moved since the wall last read +// it, and takes the new reading. Memory only. +func (a *app) wallFrontMoved() bool { + ver := wallFrontVer{file: a.file, n: len(a.entries), working: a.state == stateWorking, ok: true} + if ver.n > 0 { + ver.last = len(a.entries[ver.n-1].text) + } + if ver == a.wall.frontVer { + return false + } + a.wall.frontVer = ver + return true +} + +// wallTiles is the wall as the painter draws it, in the strip's order. +// +// IT IS CALLED BY THE FRAME and reads only memory: the strip's list, the +// cache, the signal and the wall's own state. A tab never read yet is a tile +// with no lines, which the painter draws as an empty tile rather than a lie. +func (a *app) wallTiles(now time.Time) []wallTile { + tabs := a.tabList() + var terms []fuzzy.Term + if strings.TrimSpace(a.wall.filter) != "" { + terms = fuzzy.Terms(a.wall.filter) + } + tiles := make([]wallTile, 0, len(tabs)) + for _, tab := range tabs { + if tab.start || tab.work { + continue + } + if len(terms) > 0 { + if _, ok := fuzzy.ScoreFields([]string{tab.word, tab.full}, terms); !ok { + continue + } + } + _, live := a.wallAgentFor(tab.key) + tile := wallTile{ + tab: tab, + name: tab.word, + here: tab.here, + signal: a.tabSignalFor(tab.key, tab.here), + live: live, + marked: a.wall.marked[tab.key], + } + tail := a.wall.tails[tab.key] + if tail != nil { + tile.seen = tail.seen + tile.lines = tail.lines + tile.fresh = tail.fresh + tile.freshAt = tail.freshAt + if !tail.freshAt.IsZero() { + tile.age = wallAge(now.Sub(tail.freshAt)) + } + if live { + tile.spark = tail.sparkline(now) + } + } + if tile.signal == tabNeedsPerson { + tile.question = a.wallQuestion(tab, tail) + } + tiles = append(tiles, tile) + } + return tiles +} + +// wallQuestion is the one-line ask on a tile that needs its person, from what +// is already in memory. The front has its open questions on the surface; a +// held one has only its tail, and a last line that asks something is the best +// honest guess. Anything less than that says the word the strip says. +func (a *app) wallQuestion(tab chatTab, tail *wallTail) string { + if tab.here { + for i := range a.questions { + if head := strings.TrimSpace(a.questions[i].question.Head); head != "" { + return head + } + } + if a.task != nil && strings.TrimSpace(a.task.title) != "" { + return strings.TrimSpace(a.task.title) + } + } + if tail != nil { + for i := len(tail.lines) - 1; i >= 0; i-- { + line := tail.lines[i] + if line.kind != wallProse { + continue + } + if strings.HasSuffix(line.text, "?") { + return line.text + } + break + } + } + return tabNeedsPersonWord +} diff --git a/internal/tui3/walltail_test.go b/internal/tui3/walltail_test.go new file mode 100644 index 0000000000..5bf81e7414 --- /dev/null +++ b/internal/tui3/walltail_test.go @@ -0,0 +1,205 @@ +package tui3 + +import ( + "strconv" + "strings" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/session" +) + +func TestWallTailFrom(t *testing.T) { + many := make([]session.DisplayEntry, 0, wallTailCap+10) + for i := 0; i < wallTailCap+10; i++ { + many = append(many, session.DisplayEntry{Role: "assistant", Text: "line " + strconv.Itoa(i)}) + } + cases := []struct { + name string + entries []session.DisplayEntry + want []wallLine + }{ + { + name: "a tool call folds to one line on its hint", + entries: []session.DisplayEntry{ + {Role: "tool", Tool: "bash", Hint: "go test ./...", Text: "ok\nok\nFAIL"}, + }, + want: []wallLine{{wallTool, "▸ bash go test ./..."}}, + }, + { + name: "a tool call with no hint takes its first line", + entries: []session.DisplayEntry{ + {Role: "tool", Tool: "read", Text: "\n main.go\nmore"}, + }, + want: []wallLine{{wallTool, "▸ read main.go"}}, + }, + { + name: "blank runs and fences are dropped, markers stripped", + entries: []session.DisplayEntry{ + {Role: "user", Text: "fix it\n\nplease"}, + {Role: "assistant", Text: "## Plan\n\n\n**first** the `test`\n```go\nx := 1\n```\n- then this"}, + {Role: "aside", Text: "\ntask done\ndetails"}, + }, + want: []wallLine{ + {wallUser, "› fix it"}, + {wallUser, " please"}, + {wallProse, "Plan"}, + {wallProse, "first the test"}, + {wallProse, "x := 1"}, + {wallProse, "• then this"}, + {wallNote, "task done"}, + }, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + got, _ := wallTailFrom(tc.entries) + if len(got) != len(tc.want) { + t.Fatalf("got %d lines %v, want %v", len(got), got, tc.want) + } + for i := range got { + if got[i] != tc.want[i] { + t.Errorf("line %d = %+v, want %+v", i, got[i], tc.want[i]) + } + } + }) + } + t.Run("the cap keeps the last lines", func(t *testing.T) { + got, n := wallTailFrom(many) + if len(got) != wallTailCap { + t.Fatalf("got %d lines, want %d", len(got), wallTailCap) + } + if got[0].text != "line 10" || got[len(got)-1].text != "line "+strconv.Itoa(wallTailCap+9) { + t.Errorf("kept %q .. %q", got[0].text, got[len(got)-1].text) + } + want := 0 + for _, e := range many { + want += len(e.Text) + } + if n != want { + t.Errorf("textLen = %d, want %d", n, want) + } + }) +} + +func TestWallTakeFresh(t *testing.T) { + t0 := time.Unix(1_000_000, 0) + base := []session.DisplayEntry{{Role: "user", Text: "go"}, {Role: "assistant", Text: "one"}} + var tail wallTail + tail.take(base, t0, true) + if tail.fresh != 0 || !tail.freshAt.IsZero() { + t.Fatalf("first reading counted as fresh: %d", tail.fresh) + } + if got := tail.sparkline(t0); !allZero(got) { + t.Fatalf("first reading sampled: %v", got) + } + + // The last entry grows: one fresh line. + grown := []session.DisplayEntry{base[0], {Role: "assistant", Text: "one\ntwo"}} + tail.take(grown, t0.Add(time.Second), true) + if tail.fresh != 1 { + t.Errorf("growing last entry fresh = %d, want 1", tail.fresh) + } + + // Two new entries, one of two lines: three fresh. + more := append(append([]session.DisplayEntry(nil), grown...), + session.DisplayEntry{Role: "tool", Tool: "bash", Hint: "ls"}, + session.DisplayEntry{Role: "assistant", Text: "a\n\nb"}) + tail.take(more, t0.Add(2*time.Second), true) + if tail.fresh != 3 { + t.Errorf("new entries fresh = %d, want 3", tail.fresh) + } + + // Nothing changed: the fresh count and its time stand. + at := tail.freshAt + tail.take(more, t0.Add(3*time.Second), true) + if tail.freshAt != at { + t.Errorf("an unchanged reading moved freshAt") + } + + // A shrinking transcript is a new one. + tail.take(base, t0.Add(4*time.Second), true) + if tail.fresh != 0 { + t.Errorf("a rewind counted fresh = %d", tail.fresh) + } +} + +func TestWallTakeSparkRing(t *testing.T) { + t0 := time.Unix(2_000_000, 0) + var tail wallTail + text := "" + read := func(at time.Time, add int) { + text += strings.Repeat("x", add) + tail.take([]session.DisplayEntry{{Role: "assistant", Text: text}}, at, true) + } + read(t0, 1) // first reading, not activity + read(t0.Add(1*time.Second), 1) + read(t0.Add(2*time.Second), 81) + read(t0.Add(2*time.Second+500*time.Millisecond), 1000) + // Skip seconds 3..5, then one more. + read(t0.Add(6*time.Second), 40) + + got := tail.sparkline(t0.Add(7 * time.Second)) + if len(got) != wallSparkLen { + t.Fatalf("len = %d", len(got)) + } + // Index of second s, with now at second 7: len-1-(7-s). + at := func(s int) uint8 { return got[wallSparkLen-1-(7-s)] } + if at(1) != 1 { + t.Errorf("second 1 = %d, want 1", at(1)) + } + if at(2) != 7 { + t.Errorf("second 2 = %d, want 7 (capped)", at(2)) + } + for s := 3; s <= 5; s++ { + if at(s) != 0 { + t.Errorf("skipped second %d = %d, want 0", s, at(s)) + } + } + if at(6) != 1 || at(7) != 0 { + t.Errorf("second 6 = %d, second 7 = %d, want 1 and 0", at(6), at(7)) + } + + // A full ring past the last sample, every old slot reads 0 even where the + // ring wraps onto it. + later := t0.Add(time.Duration(6+wallSparkLen) * time.Second) + read(later, 1) + got = tail.sparkline(later) + for i, v := range got[:wallSparkLen-1] { + if v != 0 { + t.Errorf("slot %d = %d after a full wrap, want 0", i, v) + } + } + if got[wallSparkLen-1] != 1 { + t.Errorf("newest = %d, want 1", got[wallSparkLen-1]) + } +} + +func TestWallAge(t *testing.T) { + cases := []struct { + d time.Duration + want string + }{ + {-time.Second, "0s"}, + {0, "0s"}, + {12 * time.Second, "12s"}, + {59*time.Second + 900*time.Millisecond, "59s"}, + {2 * time.Minute, "2m"}, + {3*time.Hour + 59*time.Minute, "3h"}, + {4 * 24 * time.Hour, "4d"}, + } + for _, tc := range cases { + if got := wallAge(tc.d); got != tc.want { + t.Errorf("wallAge(%v) = %q, want %q", tc.d, got, tc.want) + } + } +} + +func allZero(v []uint8) bool { + for _, x := range v { + if x != 0 { + return false + } + } + return true +} diff --git a/internal/tui3/wallview.go b/internal/tui3/wallview.go new file mode 100644 index 0000000000..7bf804eddf --- /dev/null +++ b/internal/tui3/wallview.go @@ -0,0 +1,1151 @@ +package tui3 + +import ( + "strconv" + "strings" + "time" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" + "github.com/charmbracelet/x/ansi" +) + +// ── THE WALL, PAINTED ─────────────────────────────────────────────────────── +// +// This is the painting half of the wall (wallcontract.go): pure functions from +// a [wallView] to rows. Nothing here reads a clock, a file or the app. The time +// is v.now, the motion is v.spin, and everything a tile says was put on it by +// the reading half. +// +// The frame reads top to bottom as one hierarchy. A title bar says what this +// is and what the conversations on it are doing; under it the Teams control +// says which set is shown; a rule and a blank row close the head. Then the +// grid, and last the foot, the head mirrored: a blank row, a rule, and the +// toolbar (wallbar.go), whose free middle says what the control under the +// pointer does. The head and the foot end where the grid ends. Three cards can +// float over the grid: the selection tray while conversations are picked, the +// new-team card while one is named, and the Organize card while suggestions +// are up (teamorganize.go); and the help sheet (wallhelp.go) floats over +// everything while it is up. +// +// The words on screen are the person's words: a Conversation is a tile, a +// Team is a named set of them. "wall" and "tab" are this code's names and are +// never drawn. +// +// A TILE READS TITLE, STATE, NOW, HISTORY. The title is the brightest thing +// in it; one dim line under it says what the agent is doing or when it last +// moved; the body under that is the conversation's own rows, faded with age +// by the reading half (wallmini.go), so the newest rows are where the eye +// lands. +// +// A TILE HAS ONE STATE LADDER AND EVERY STEP MAKES ONE CLAIM: +// +// rest a dim rounded border and no ground +// hover the whole tile on the cursor ground, the border lifted to muted, +// and its action row drawn on the bottom border +// focus the heavy border; weight, never colour; and the action row +// selected the selected ground, a step above hover, and a ☑ at top left +// needs you the amber border, and the only amber on the wall; its body +// ends in the question and an Answer button +// +// THE ACTIONS ARE WORDS, NOT GLYPHS. A tile's bottom border carries a +// sparkline at rest, and under the pointer or the keyboard's focus it becomes +// a row of labelled buttons, each a verb and its key (wallbar.go's +// [wallTileActs]). The buttons' cells depend on the tile's width alone, so +// nothing moves as the row appears. The ☐ is drawn only in the selection +// mode, on every tile, where the mode itself says what a box is for. + +// wallChromeRows is what the frame spends outside the grid. The head is the +// title bar, the Teams row, a rule and a blank row; the foot mirrors it, a +// blank row, a rule and the toolbar, so the grid sits between two matching +// edges and no tile touches a control. +const wallChromeRows = 7 + +// wallGridTop is the first row a tile is drawn on. +const wallGridTop = 4 + +// wallFootRows is the foot's share of the chrome: the blank row, the rule and +// the toolbar. +const wallFootRows = 3 + +// wallGutter is the blank cells between two tiles on one row, wallRowGap the +// blank rows between two rows of tiles, and wallMargin the blank column kept +// either side of the grid so no tile touches the frame's edge. +const ( + wallGutter = 2 + wallRowGap = 1 + wallMargin = 1 +) + +// A tile's border is padded inside: wallPadX blank cells left and right of +// the body, wallPadY blank rows above and below it. +const ( + wallPadX = 2 + wallPadY = 1 +) + +// wallInnerW is the width a tile's body is drawn at: the tile less its two +// border cells and the padding either side. +func wallInnerW(tileW int) int { return max(tileW-2-2*wallPadX, 0) } + +// wallInnerH is the height inside a tile's padding: the tile less its two +// borders and the padding above and below. Its first row is the tile's state +// line and its second a blank, and the body has the rest. +func wallInnerH(tileH int) int { return max(tileH-2-2*wallPadY, 0) } + +// wallMetaRows is what the state line and the blank under it take. +const wallMetaRows = 2 + +// The tile height is chosen inside these bounds; the width has only a floor. +const ( + wallTileMinW = 44 + // wallTileIdealW is the width the automatic column count aims for. + wallTileIdealW = 52 + wallTileMinH = 12 + wallTileMaxH = 60 +) + +// wallFreshSettle is how long newly arrived lines stay lifted to ink. +const wallFreshSettle = 600 * time.Millisecond + +// wallMadeFor is how long the chip row says a team was just made. +const wallMadeFor = 2 * time.Second + +// wallEmptyWord is the whisper an empty wall draws beside its way back. +const wallEmptyWord = "No open conversations" + +// wallBox is one border's glyphs. +type wallBox struct{ tl, tr, bl, br, h, v string } + +var ( + wallBoxHeavy = wallBox{"┏", "┓", "┗", "┛", "━", "┃"} + wallBoxLight = wallBox{"╭", tokens.GlyphFrameTopRight, "╰", tokens.GlyphFrameBottomRight, "─", "│"} + // The ASCII floor keeps focus as weight: `#` and `=` for the focused tile, + // `+` and `-` for the rest. + wallBoxHeavyASCII = wallBox{"#", "#", "#", "#", "=", "#"} + wallBoxLightASCII = wallBox{"+", "+", "+", "+", "-", "|"} +) + +// wallSparkCells is the eight-step ramp a sample 0..7 is drawn in. +var ( + wallSparkCells = []string{"▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"} + wallSparkCellsASCII = []string{"_", ".", "-", ":", "=", "+", "*", "#"} +) + +// wallGlyphs is the handful of marks the wall draws besides its boxes, in the +// palette's tier. +type wallGlyphs struct { + sep, tool, cursor, marked, cell, seenCell, gt, more string +} + +func wallGlyphsFor(ascii bool) wallGlyphs { + if ascii { + return wallGlyphs{sep: "-", tool: ">", cursor: "_", marked: "@", cell: ".", seenCell: "o", gt: ">", more: "~"} + } + return wallGlyphs{sep: "·", tool: "▸", cursor: "▌", marked: "☑", cell: tokens.GlyphActionWork, seenCell: "▣", gt: "›", more: "…"} +} + +// wallGrid is the grid for n tiles on a frame width by height (the whole frame, +// chrome included): the column count and one tile's size. +// +// The columns come from the width alone, so a tile does not jump column when a +// conversation opens: under 100 cells one column, under 150 two, under 200 +// three, else four. cols above zero is a person's override, and either way the +// count falls until a tile is at least [wallTileMinW] wide. +// +// The height is shared out so that as many tile rows as the frame holds at +// [wallTileMinH] or more are drawn, then capped at [wallTileMaxH]; a frame that +// can hold two rows always shows two. +func wallGrid(n, width, height, cols int) (c, tileW, tileH int) { + room := width - 2*wallMargin + c = cols + if c <= 0 { + c = (room + wallGutter) / (wallTileIdealW + wallGutter) + if c > 4 { + c = 4 + } + } + // A TILE NEVER GOES UNDER ITS MINIMUM. Past it a tile stops being a + // conversation you can read and becomes a coloured stripe, so a narrow frame + // or a person's `+` loses a column instead, and the rows scroll. + for c > 1 && (room-wallGutter*(c-1))/c < wallTileMinW { + c-- + } + if c < 1 { + c = 1 + } + tileW = (room - wallGutter*(c-1)) / c + if tileW < 0 { + tileW = 0 + } + gridH := height - wallChromeRows + if gridH <= 0 { + return c, tileW, 0 + } + rows := (n + c - 1) / c + if rows < 1 { + rows = 1 + } + // The rows on screen are as many as fit at the minimum height, never more + // than there are; they then share the height out so the grid fills the + // frame. Anything past them scrolls rather than squeezing. + fit := (gridH + wallRowGap) / (wallTileMinH + wallRowGap) + if fit < 1 { + fit = 1 + } + k := min(rows, fit) + tileH = (gridH - wallRowGap*(k-1)) / k + if tileH > wallTileMaxH { + tileH = wallTileMaxH + } + return c, tileW, tileH +} + +// wallVisibleRows is how many whole tile rows the grid area holds. +func wallVisibleRows(height, tileH int) int { + gridH := height - wallChromeRows + if tileH <= 0 || gridH < tileH { + return 0 + } + return (gridH + wallRowGap) / (tileH + wallRowGap) +} + +// wallScrollFor is the first tile row to draw so the focused tile is on +// screen, moving scroll as little as it can: a focus already visible keeps the +// scroll it had. +func wallScrollFor(focus, scroll, n, width, height, cols int) int { + if n <= 0 { + return 0 + } + c, _, tileH := wallGrid(n, width, height, cols) + vis := wallVisibleRows(height, tileH) + if vis < 1 { + vis = 1 + } + if focus < 0 { + focus = 0 + } + if focus >= n { + focus = n - 1 + } + rows := (n + c - 1) / c + row := focus / c + if row < scroll { + scroll = row + } + if row >= scroll+vis { + scroll = row - vis + 1 + } + if top := rows - vis; scroll > top { + scroll = top + } + if scroll < 0 { + scroll = 0 + } + return scroll +} + +// wallMarked is how many of the drawn tiles are marked. Any at all is the +// selection mode: every tile shows its box, and a press on a tile toggles it. +func wallMarked(v wallView) int { + n := 0 + for _, t := range v.tiles { + if t.marked { + n++ + } + } + return n +} + +// renderWall is the whole wall: exactly height rows, none wider than width, +// and where every target landed. The scroll it draws is v.scroll moved just +// enough to keep the focus on screen ([wallScrollFor]), so a stale scroll never +// paints a frame with the focus off it. +func renderWall(pal palette, v wallView, width, height int) ([]string, []wallHit) { + if height <= 0 { + return nil, nil + } + if width < 0 { + width = 0 + } + rows := make([]string, height) + g := wallGlyphsFor(pal.ascii) + if len(v.tiles) == 0 && v.filter == "" && v.team == "" { + // Nothing is open at all: there is nothing to title, narrow or lay out, + // so the frame is the one sentence and the way back. + y := (height - 1) / 2 + row, hits := wallEmptyRow(pal, v, width, y) + rows[y] = row + return rows, hits + } + + n := len(v.tiles) + focus := min(max(v.focus, 0), max(n-1, 0)) + c, tileW, tileH := wallGrid(max(n, 1), width, height, v.cols) + scroll := wallScrollFor(focus, v.scroll, n, width, height, v.cols) + vis := wallVisibleRows(height, tileH) + first, last := scroll*c, min((scroll+vis)*c, n) + inset := wallInset(width, c, tileW) + + var hits []wallHit + row, h := wallTitleRow(pal, g, v, width, inset, 0) + rows[0] = row + hits = append(hits, h...) + if height > 1 { + row, h := wallTeamsRow(pal, g, v, width, height, inset, c, first, last, 1) + rows[1] = row + hits = append(hits, h...) + } + if height > 2 { + rows[2] = wallRule(pal, v, width) + } + + gridEnd := height - wallFootRows // the blank row over the foot's rule + if n == 0 { + // A filter or a team with nothing in it keeps the whole frame, so + // what narrowed it stays on screen beside the way to undo it. + if gridEnd > wallGridTop { + y := wallGridTop + (gridEnd-wallGridTop-1)/2 + row, h := wallNoneRow(pal, v, width, y) + rows[y] = row + hits = append(hits, h...) + } + } else if tileW >= 6 && tileH >= 3 { + margin := strings.Repeat(" ", wallMargin) + gap := strings.Repeat(" ", wallGutter) + top := wallGridTopFor(height, tileH, vis) + for r := 0; r < vis; r++ { + y0 := top + r*(tileH+wallRowGap) + var line []string + for col := 0; col < c; col++ { + i := (scroll+r)*c + col + if i >= n { + break + } + x0 := wallMargin + col*(tileW+wallGutter) + hits = append(hits, wallTileHits(pal, v, v.tiles[i], i, i == focus, x0, y0, tileW, tileH)...) + tile := wallPaintTile(pal, g, v, v.tiles[i], i, i == focus, tileW, tileH, y0) + if line == nil { + line = tile + for y := range line { + line[y] = margin + line[y] + } + continue + } + for y := range line { + line[y] += gap + tile[y] + } + } + for y, s := range line { + if y0+y < gridEnd { + rows[y0+y] = s + } + } + } + } + if height > wallGridTop+wallFootRows-1 { + rows[height-2] = wallFootRule(pal, width) + } + if height > 2 { + row, h := wallBarIn(pal, v, width, inset, height-1) + rows[height-1] = row + hits = append(hits, h...) + } + + // The cards float over the grid; what they cover stops answering the + // pointer, so a press lands on the card and never on the tile under it. + // A popover floats over everything, the tray included. + switch { + case v.org.on: + hits = wallOverlay(rows, hits, wallOrgCard(pal, g, v, width, height), width) + case v.naming: + hits = wallOverlay(rows, hits, wallNameCard(pal, g, v, width, height), width) + case wallMarked(v) > 0: + hits = wallOverlay(rows, hits, wallTray(pal, g, v, width, height), width) + } + if v.pop.kind != wallPopNone && !v.naming && !v.org.on { + hits = wallOverlay(rows, hits, wallPopCard(pal, g, v, width, height), width) + } + if v.help { + hits = wallOverlay(rows, hits, wallHelpCard(pal, v, width, height), width) + } + + for i, s := range rows { + if ansi.StringWidth(s) > width { + rows[i] = ansi.Truncate(s, width, "") + } + } + return rows, hits +} + +// wallGridTopFor is the first row the grid is drawn on. The rows of tiles +// rarely fill the room between the two rules exactly, and what is over is +// shared out above and below them, the odd row going below, so the grid sits +// in the middle rather than leaving a gap only over the toolbar. +func wallGridTopFor(height, tileH, vis int) int { + if vis < 1 { + return wallGridTop + } + gridH := height - wallChromeRows + over := gridH - vis*tileH - (vis-1)*wallRowGap + return wallGridTop + max(over, 0)/2 +} + +// wallInset is the blank cells kept at the frame's right edge: the margin, +// plus whatever the columns could not share out. The head and the toolbar end +// where the grid ends, so the counts, the minimap and the last button all +// line up with the right edge of the last tile. +func wallInset(width, c, tileW int) int { + used := wallMargin + c*tileW + max(c-1, 0)*wallGutter + return max(width-used, wallMargin) +} + +// wallTitleRow is the title bar: what this is on the left, and on the right +// what the conversations on it are doing, as quiet counts, each said only when +// it is not zero, three cells apart, ending inset cells from the right edge so +// a count growing a digit moves only what is left of it. The count waiting on +// a person is a button: it goes to the next one, as ? does. +// +// ▦ Conversations · open in this window · in test 2 more in test · Open them 1 open +// +// THE WALL IS WHAT IS OPEN IN THIS WINDOW, narrowed by a team, and the title +// says so in those words. A team's members this window does not have open are +// not tiles; while there are any, one quiet word button says how many and +// resumes them behind ([app.wallResumeAway]), and while there are none it is +// not drawn at all. +func wallTitleRow(pal palette, g wallGlyphs, v wallView, width, inset, y int) (string, []wallHit) { + mark := "▦" + run := "⠿" + if pal.ascii { + mark, run = "#", "*" + } + sub := wallOpenHereWord + teamName := "" + if i := v.teamRow(v.team); i >= 0 { + teamName = v.teams[i].name + sub += " " + g.sep + " in " + teamName + } + left := " " + pal.bold(pal.ink(mark+" Conversations")) + pal.dim(" "+g.sep+" "+sub) + working, needs := 0, 0 + for _, t := range v.tiles { + switch { + case t.signal == tabWorking && t.live: + working++ + case t.signal == tabNeedsPerson: + needs++ + } + } + // A pill's pad is the cells of ground it wears either side when it is a + // button; the three cells between two pills count it, so the words are + // evenly spaced whether or not a pill is pressable. + type pill struct { + s string + w int + pad int + act wallAct + away bool + } + const pillGap = 3 + var pills []pill + if working > 0 { + word := run + " " + strconv.Itoa(working) + " running" + pills = append(pills, pill{s: pal.live(word), w: ansi.StringWidth(word)}) + } + if needs > 0 { + word := tokens.GlyphNeedsHuman + " " + strconv.Itoa(needs) + " " + tabNeedsPersonWord + p := " " + pal.warn(word) + " " + if v.hover.kind == wallHitAction && v.hover.arg == int(wallActNext) { + p = pal.cursor(p, 0) + } + pills = append(pills, pill{s: p, w: ansi.StringWidth(word) + 2, pad: 1, act: wallActNext}) + } + awayAt := -1 + awayPill := func(named bool) pill { + lead := strconv.Itoa(v.away) + " more" + if named && teamName != "" { + lead += " in " + teamName + } + lead += " " + g.sep + " " + p := " " + pal.dim(lead) + pal.muted(wallResumeWord) + " " + if v.hover.kind == wallHitAction && v.hover.arg == int(wallActResume) { + p = pal.cursor(" "+pal.muted(lead)+pal.ink(wallResumeWord)+" ", 0) + } + return pill{s: p, w: ansi.StringWidth(lead+wallResumeWord) + 2, pad: 1, act: wallActResume, away: true} + } + if v.away > 0 && v.team != "" { + awayAt = len(pills) + pills = append(pills, awayPill(true)) + } + open := strconv.Itoa(len(v.tiles)) + " open" + pills = append(pills, pill{s: pal.dim(open), w: len(open)}) + gapBefore := func(i int) int { + if i == 0 { + return 0 + } + return pillGap - pills[i-1].pad - pills[i].pad + } + measure := func() int { + edge := max(inset-pills[len(pills)-1].pad, 0) + rw := edge + for i, p := range pills { + rw += gapBefore(i) + p.w + } + return rw + } + + // The last pill's pad sits in the inset, so its words end where the grid + // does. + edge := max(inset-pills[len(pills)-1].pad, 0) + rw := measure() + lw := ansi.StringWidth(left) + if lw+2+rw > width { + // The subtitle goes before any count does. + left = " " + pal.bold(pal.ink(mark+" Conversations")) + lw = ansi.StringWidth(left) + } + if lw+2+rw > width && awayAt >= 0 { + // Then the team's name in the button, which the title already said; + // then the button, whose key still works. + pills[awayAt] = awayPill(false) + if rw = measure(); lw+2+rw > width { + pills = append(pills[:awayAt], pills[awayAt+1:]...) + rw = measure() + } + } + if lw+2+rw > width { + return ansi.Truncate(left, width, ""), nil + } + var hits []wallHit + var b strings.Builder + b.WriteString(left) + b.WriteString(strings.Repeat(" ", width-lw-rw)) + x := width - rw + for i, p := range pills { + gap := gapBefore(i) + b.WriteString(strings.Repeat(" ", gap)) + x += gap + if p.pad > 0 { + hits = append(hits, wallHit{x0: x, y0: y, x1: x + p.w, y1: y + 1, kind: wallHitAction, arg: int(p.act)}) + } + b.WriteString(p.s) + x += p.w + } + b.WriteString(strings.Repeat(" ", edge)) + return b.String(), hits +} + +// wallOpenHereWord is what the wall is, in the title's words: the +// conversations open in this window, whichever team narrows them. +const wallOpenHereWord = "open in this window" + +// wallResumeWord is the title's word button that resumes the shown team's +// members this window does not have open. +const wallResumeWord = "Open them" + +// wallRule closes the head: dim, or, while a team is shown, in that team's +// colour, so the whole frame says which set it is showing. +func wallRule(pal palette, v wallView, width int) string { + if i := v.teamRow(v.team); i >= 0 { + if ink := pal.teamInk(v.teams[i].hue); ink != nil { + return ink(wallRuleLine(pal, width)) + } + } + return pal.dim(wallRuleLine(pal, width)) +} + +// wallFootRule opens the foot, the head's rule mirrored. It is always dim: +// the head already says which team is shown, and saying it twice would make +// the team's colour a frame rather than a mark. +func wallFootRule(pal palette, width int) string { + return pal.dim(wallRuleLine(pal, width)) +} + +func wallRuleLine(pal palette, width int) string { + if pal.ascii { + return strings.Repeat("-", width) + } + return strings.Repeat("─", width) +} + +// wallMinimap is one cell per tile in strip order, coloured by what the tile +// is doing, with the tiles on screen drawn as the brighter cell. Rows of the +// grid (per tiles each) are parted by a space when there is room for it. It +// also says the column each tile's cell landed on, -1 for one not drawn, so a +// press on a cell can go to its tile. +func wallMinimap(pal palette, g wallGlyphs, v wallView, per, first, last, room int) (string, []int) { + n := len(v.tiles) + if room <= 0 || n == 0 { + return "", nil + } + cells := make([]string, n) + for i, t := range v.tiles { + cell := g.cell + shown := i >= first && i < last + if shown { + cell = g.seenCell + } + switch { + case t.signal == tabNeedsPerson: + cell = pal.warn(cell) + case t.signal == tabWorking && t.live: + cell = pal.live(cell) + case shown: + cell = pal.ink(cell) + default: + cell = pal.dim(cell) + } + cells[i] = cell + } + at := make([]int, n) + for i := range at { + at[i] = -1 + } + var b strings.Builder + w := 0 + grouped := per > 0 && n+(n-1)/per <= room + for i, cell := range cells { + if grouped && i > 0 && i%per == 0 { + b.WriteString(" ") + w++ + } + if w+1 > room { + break + } + b.WriteString(cell) + at[i] = w + w++ + } + return b.String(), at +} + +// wallSpread puts left at the start of a width-cell row and right at its end, +// dropping right when the two would touch. +func wallSpread(left, right string, width int) string { + lw, rw := ansi.StringWidth(left), ansi.StringWidth(right) + if lw+1+rw > width { + return ansi.Truncate(left, width, "") + } + return left + strings.Repeat(" ", width-lw-rw) + right +} + +// wallFit pads or cuts s to exactly w cells. +func wallFit(s string, w int) string { + if w <= 0 { + return "" + } + sw := ansi.StringWidth(s) + if sw > w { + s = ansi.Truncate(s, w, "") + sw = ansi.StringWidth(s) + } + return s + strings.Repeat(" ", w-sw) +} + +// wallTileLook is one tile's place on the ladder: which box, what ink the +// border takes, and what ground the whole tile sits on. (The field is border +// and not edge: edge is the live-state seam's word, livestate.go.) +type wallTileLook struct { + box wallBox + border func(string) string + ground func(string) string + hovered bool + // boxOn says the selection box is drawn on the top border, which is the + // selection mode; rowOn says the bottom border is the action row. + boxOn, rowOn bool +} + +// wallLookFor is the ladder read for one tile. Each rung claims one thing, and +// the claims are decided in one expression each so no rung can overwrite +// another's by the order of a few assignments. +func wallLookFor(pal palette, v wallView, t wallTile, i int, focused bool) wallTileLook { + hovered := v.hover.onTile(i) + box := wallBoxLight + switch { + case focused && pal.ascii: + box = wallBoxHeavyASCII + case focused: + box = wallBoxHeavy + case pal.ascii: + box = wallBoxLightASCII + } + return wallTileLook{ + box: box, + border: wallBorderInk(pal, t, focused, hovered), + ground: wallGroundFor(pal, t, hovered), + hovered: hovered, + boxOn: wallMarked(v) > 0, + rowOn: hovered || focused, + } +} + +// wallBorderInk is the border's colour: amber for a tile waiting on a person +// (the only amber on the wall), ink for the focus, muted under the pointer, +// and dim at rest. Focus is said twice, by weight and by ink, so it survives a +// palette with no colour. +func wallBorderInk(pal palette, t wallTile, focused, hovered bool) func(string) string { + switch { + case t.signal == tabNeedsPerson: + return pal.warn + case focused: + return pal.ink + case hovered: + return pal.muted + } + return pal.dim +} + +// wallGroundFor is what the whole tile sits on: the selected ground, a step +// above hover, for a picked tile; the cursor ground under the pointer; none +// at rest. +func wallGroundFor(pal palette, t wallTile, hovered bool) func(string) string { + switch { + case t.marked: + return func(s string) string { return pal.selected(s, 0) } + case hovered: + return func(s string) string { return pal.cursor(s, 0) } + } + return func(s string) string { return s } +} + +// wallTileRoom is how a tile h rows high spends its inside: the padding above +// and below, whether the state line and its blank are drawn, and the rows left +// for the body. The painter and the pointer both read it, so a target in the +// body is where the body drew it. +func wallTileRoom(h int) (padY int, meta bool, body int) { + inner := h - 2 + padY = wallPadY + if inner < 2*wallPadY+wallMetaRows+1 { + padY = 0 + } + body = inner - 2*padY + if body >= wallMetaRows+1 { + return padY, true, body - wallMetaRows + } + return padY, false, max(body, 0) +} + +// wallAnswerButton is the button a tile waiting on a person ends in. Pressing +// it is the tile's open, the one door the prototype answers a question +// through, so it carries that key. +func wallAnswerButton(ascii bool) wallButton { + return wallButton{act: wallActOpen, label: "Answer", key: wallKeysFor(ascii).enter} +} + +// wallAnswerAt is where tile t's Answer button sits, in cells from the tile's +// top-left corner, and whether it is drawn at all. It is on the body's last +// row, and its label starts on the text's column: its ground's first cell is +// taken from the padding, as a button's ground is outside its word. +func wallAnswerAt(ascii bool, t wallTile, w, h int) (dx, dy, bw int, ok bool) { + if t.signal != tabNeedsPerson { + return 0, 0, 0, false + } + padY, _, body := wallTileRoom(h) + bw = wallButtonW(wallAnswerButton(ascii)) + if body < 1 || bw-1 > wallInnerW(w) { + return 0, 0, 0, false + } + return wallPadX, h - 2 - padY, bw, true +} + +// wallRowHot reports whether the pointer is on tile i's target of kind on +// frame row y. A waiting tile's Answer and its row's Answer answer to one +// ref, as a picked tile's ☐ and its row's Select do, and the pointer's row +// says which of the two to light; without it both are lit, which at least +// says they are one door. +func wallRowHot(v wallView, kind wallHitKind, i, y int) bool { + if v.hover.kind != kind || v.hover.arg != i { + return false + } + return !v.pointerOn || v.pointerY == y +} + +// wallPaintTile is one tile, exactly h rows of exactly w cells, its top-left +// corner on frame row y0: +// +// ╭─ ●● the tree walk ───────────────────────────╮ +// │ │ +// │ ⠸ running bash · 2m │ +// │ │ +// │ the body, oldest faded, newest in ink │ +// │ │ +// ╰─ ▁▂▃▅▇▅▃ ────────────────────────────────────╯ +// +// and under the pointer or the focus its bottom border is the action row: +// +// ╰─ Open ↵ ── Select ␣ ── Teams m ── Close x ──╯ +func wallPaintTile(pal palette, g wallGlyphs, v wallView, t wallTile, i int, focused bool, w, h, y0 int) []string { + look := wallLookFor(pal, v, t, i, focused) + box, border, ground := look.box, look.border, look.ground + out := make([]string, 0, h) + out = append(out, wallTopBorder(pal, v, t, i, look, w, y0)) + padY, meta, room := wallTileRoom(h) + innerW := wallInnerW(w) + pad := strings.Repeat(" ", wallPadX) + row := func(s string) string { + return ground(border(box.v) + pad + wallFit(s, innerW) + pad + border(box.v)) + } + blank := row("") + for y := 0; y < padY; y++ { + out = append(out, blank) + } + if meta { + out = append(out, row(wallMetaLine(pal, g, v, t, innerW)), blank) + } + body := wallTileBody(pal, g, v, t, innerW, room) + for _, s := range body { + out = append(out, row(s)) + } + if dx, dy, _, ok := wallAnswerAt(pal.ascii, t, w, h); ok && dy < len(out) { + // The button is laid over its row with the tile's ground around it and + // its own ground under it, as a control in a tile is. + btn := wallButtonPaint(pal, wallAnswerButton(pal.ascii), wallRowHot(v, wallHitOpen, i, y0+dy)) + bw := wallButtonW(wallAnswerButton(pal.ascii)) + lead := border(box.v) + strings.Repeat(" ", dx-1) + tail := strings.Repeat(" ", max(w-dx-bw-1, 0)) + border(box.v) + out[dy] = ground(lead) + btn + ground(tail) + } + for y := 0; y < padY; y++ { + out = append(out, blank) + } + if look.rowOn { + if acts := wallTileActs(pal.ascii, t, w); len(acts) > 0 { + return append(out, wallActRow(pal, v, i, look, acts, w, y0+h-1)) + } + } + out = append(out, ground(wallBottomBorder(pal, t, box, border, w))) + return out +} + +// wallMetaLine is the tile's state in one dim line that never wraps: what a +// working agent is doing and for how long, a question waiting, or when the +// conversation last moved. A conversation this window has not seen move says +// nothing rather than guess. +func wallMetaLine(pal palette, g wallGlyphs, v wallView, t wallTile, w int) string { + since := "" + if !t.moved.IsZero() { + since = wallAge(v.now.Sub(t.moved)) + } + sep := " " + g.sep + " " + var s string + switch { + case t.signal == tabNeedsPerson: + s = pal.warn(tokens.GlyphNeedsHuman + " waiting on you") + if since != "" { + s += pal.dim(sep + since) + } + case t.signal == tabWorking && !t.live: + if t.age != "" { + s = pal.dim("seen " + t.age + " ago") + } + case t.signal == tabWorking: + spin := tokens.Spinner(v.spin) + switch { + case pal.ascii: + spin = glyphRunASCII + case v.reduced: + spin = tokens.GlyphWorking + } + doing := t.doing + if doing == "" { + doing = "working" + } + s = pal.live(spin + " " + doing) + if since != "" { + s += pal.dim(sep + since) + } + case !t.live && t.age != "": + s = pal.dim("seen " + t.age + " ago") + case since != "": + s = pal.dim("updated " + since + " ago") + } + if ansi.StringWidth(s) > w { + s = ansi.Truncate(s, w, g.more) + } + return s +} + +// wallSelW is the cells the selection box takes at a tile's top left in the +// selection mode: ` ☐ ` unmarked, ` ☑ ` marked. +const wallSelW = 3 + +// wallSelFits reports whether a tile w wide carries the selection box. +func wallSelFits(w int) bool { return w >= 20 } + +// wallTitleGap is the least run of border between a title and the corner, so +// a long title reads as cut and never as touching it. +const wallTitleGap = 2 + +// wallTopBorder is the team's dots and the title, and in the selection mode +// the box before them: +// +// ╭─ ●● the tree walk ───────────────────────────────╮ +// ╭─ ☐ ●● the tree walk ─────────────────────────────╮ +// +// The title is the brightest thing on the tile and has the whole border to +// itself, less two rule cells before the corner. The box is drawn on every +// tile or on none: it comes with the mode, never with the pointer, so a +// hover changes nothing on this row but the box's own ground. +func wallTopBorder(pal palette, v wallView, t wallTile, i int, look wallTileLook, w, y0 int) string { + box, border, ground := look.box, look.border, look.ground + if w < 5 { + return ground(wallFit(border(box.tl+strings.Repeat(box.h, max(w-2, 0))+box.tr), w)) + } + var parts []wallPart + add := func(s string) { parts = append(parts, wallPart{s: s}) } + + add(border(box.tl + box.h)) + used := 2 + if look.boxOn && wallSelFits(w) { + sel := wallSelGlyph(pal.ascii, t.marked) + word := " " + sel + " " + switch { + case wallRowHot(v, wallHitSelect, i, y0): + parts = append(parts, wallPart{s: pal.ink(word), hot: true}) + case t.marked: + add(" " + pal.accent(sel) + " ") + default: + add(pal.muted(word)) + } + used += wallSelW + } else { + add(" ") + used++ + } + right := 1 + wallTitleGap // the least rule and the corner + if dots, dw := wallTileDots(pal, v, t); dw > 0 && w-used-right-dw >= 8 { + add(dots) + used += dw + } + if t.manager { + mark := teamManagerGlyph + if pal.ascii { + mark = teamManagerGlyphASCII + } + // `◆ Manager · <title>`, as the strip names the same conversation, and + // the mark alone where the word would cost the title. + switch word := teamManagerWord + " · "; { + case w-used-right-2-len(word) >= 12: + add(pal.accent(mark) + " " + pal.ink(teamManagerWord) + pal.dim(" · ")) + used += ansi.StringWidth(mark) + 1 + len(word) + case w-used-right-2 >= 8: + add(pal.accent(mark) + " ") + used += ansi.StringWidth(mark) + 1 + } + } + nameRoom := w - used - right - 1 + name := t.name + if nameRoom < 1 { + name = "" + } else if ansi.StringWidth(name) > nameRoom { + name = ansi.Truncate(name, nameRoom, wallGlyphsFor(pal.ascii).more) + } + if name != "" { + add(pal.bold(pal.ink(name)) + " ") + used += ansi.StringWidth(name) + 1 + } + add(border(strings.Repeat(box.h, max(w-used-1, 0)) + box.tr)) + return wallFit(wallCompose(pal, parts, ground), w) +} + +// wallSelGlyph is the selection box, open or filled. +func wallSelGlyph(ascii, marked bool) string { + switch { + case ascii && marked: + return "@" + case ascii: + return "o" + case marked: + return "☑" + } + return "☐" +} + +// wallBottomBorder carries the sparkline of a live tile that has moved. +func wallBottomBorder(pal palette, t wallTile, box wallBox, border func(string) string, w int) string { + if w < 5 { + return wallFit(border(box.bl+strings.Repeat(box.h, max(w-2, 0))+box.br), w) + } + s := border(box.bl + box.h) + used := 2 + cells := wallSparkCells + if pal.ascii { + cells = wallSparkCellsASCII + } + moved := false + if t.live { + for _, x := range t.spark { + if x > 0 { + moved = true + break + } + } + } + if moved { + room := w - used - 4 // space, the spark, space, one rule and the corner + spark := t.spark + if len(spark) > room { + spark = spark[len(spark)-max(room, 0):] + } + if len(spark) > 0 { + var b strings.Builder + for _, x := range spark { + if x > 7 { + x = 7 + } + b.WriteString(cells[x]) + } + s += " " + pal.muted(b.String()) + " " + used += 2 + len(spark) + } + } + fill := max(w-used-1, 0) + s += border(strings.Repeat(box.h, fill)) + border(box.br) + return wallFit(s, w) +} + +// wallTileBody is the tail fit to the tile, h rows of w cells. +// +// THE BODY HANGS FROM THE TOP. Under the state line and its one blank row the +// body starts at once, in every tile, so the eye finds the same rhythm down +// the whole grid; a short tail leaves its room empty at the bottom, and a long +// one shows its newest rows. Blank rows at either end of what is shown are +// dropped, so a turn break never doubles the blank under the state line. +// +// A tile waiting on a person keeps its last rows for the ask, pinned to the +// bottom where a dialog keeps its buttons: a blank row, the question in ink, a +// blank row, and the row the Answer button is laid on (wallPaintTile). +// A working tile's last row ends in the cursor. +func wallTileBody(pal palette, g wallGlyphs, v wallView, t wallTile, w, h int) []string { + body := make([]string, h) + if w <= 0 || h <= 0 { + return body + } + var ask []string + if t.signal == tabNeedsPerson { + ask = wallAskRows(pal, g, t.question, w, h) + } + + lift := !v.reduced && t.fresh > 0 && !t.freshAt.IsZero() && v.now.Sub(t.freshAt) < wallFreshSettle + freshFrom := len(t.lines) - t.fresh + var tail []string + lines := t.lines + if t.rows != nil { + // The chat's own rows, drawn once per reading (wallmini.go). + tail = append(tail, t.rows...) + lines = nil + } + for i, ln := range lines { + text := ln.text + if ln.kind == wallTool { + text = strings.TrimPrefix(strings.TrimPrefix(text, "▸"), ">") + text = g.tool + " " + strings.TrimLeft(text, " ") + } + paint := wallLineInk(pal, ln.kind) + if lift && i >= freshFrom { + paint = pal.ink + } + for _, r := range wallWrap(text, w) { + tail = append(tail, paint(r)) + } + } + tail = wallTrimBlank(tail) + if room := h - len(ask); len(tail) > room { + tail = wallTrimBlank(tail[len(tail)-room:]) + } + // The chat's own rows are already faded by age (wallmini.go) and say + // nothing more; the cursor is for the flattened lines alone. + if t.rows == nil && t.signal == tabWorking && t.live && len(tail) > 0 && len(ask) == 0 { + lastRow := tail[len(tail)-1] + if ansi.StringWidth(lastRow) >= w { + lastRow = ansi.Truncate(lastRow, w-1, "") + } + tail[len(tail)-1] = lastRow + pal.ink(g.cursor) + } + copy(body, tail) + copy(body[h-len(ask):], ask) + return body +} + +// wallAskRows is the foot of a tile waiting on a person, at most h rows: a +// blank row parting it from the tail, the question in ink, a blank row, and a +// blank last row the Answer button is laid on. Short of room the blanks go +// first, then the question's last rows, the cut one ending in an ellipsis; +// the button's row is the last thing to go. +func wallAskRows(pal palette, g wallGlyphs, question string, w, h int) []string { + if h <= 0 { + return nil + } + var q []string + if question != "" { + q = wallWrap(question, w) + } + lead, mid := len(q) > 0, len(q) > 0 + for 1+len(q)+b2i(lead)+b2i(mid) > h { + switch { + case lead: + lead = false + case mid: + mid = false + default: + q = q[:len(q)-1] + if len(q) > 0 { + last := q[len(q)-1] + q[len(q)-1] = ansi.Truncate(last, max(w-1, 0), "") + g.more + } + } + } + var rows []string + if lead { + rows = append(rows, "") + } + for _, r := range q { + rows = append(rows, pal.ink(r)) + } + if mid { + rows = append(rows, "") + } + return append(rows, "") +} + +func b2i(b bool) int { + if b { + return 1 + } + return 0 +} + +// wallTrimBlank drops blank rows from both ends of rows. +func wallTrimBlank(rows []string) []string { + blank := func(s string) bool { return strings.TrimSpace(ansi.Strip(s)) == "" } + for len(rows) > 0 && blank(rows[0]) { + rows = rows[1:] + } + for len(rows) > 0 && blank(rows[len(rows)-1]) { + rows = rows[:len(rows)-1] + } + return rows +} + +// wallLineInk is the hue one kind of line is drawn in. +func wallLineInk(pal palette, k wallLineKind) func(string) string { + switch k { + case wallTool, wallUser: + return pal.dim + case wallNote: + return func(s string) string { return pal.italic(pal.dim(s)) } + } + return pal.muted +} + +// wallWrap cleans one logical line and wraps it to w cells. A tail line is +// plain text by contract; anything that looks like an escape is dropped so a +// transcript cannot paint over the tile. +func wallWrap(s string, w int) []string { + s = ansi.Strip(s) + s = strings.ReplaceAll(s, "\t", " ") + s = strings.ReplaceAll(s, "\r", "") + var out []string + for _, r := range strings.Split(ansi.Wrap(s, w, ""), "\n") { + out = append(out, ansi.Truncate(strings.TrimRight(r, " "), w, "")) + } + return out +} diff --git a/internal/tui3/wallview_test.go b/internal/tui3/wallview_test.go new file mode 100644 index 0000000000..036de9df96 --- /dev/null +++ b/internal/tui3/wallview_test.go @@ -0,0 +1,1161 @@ +package tui3 + +import ( + "fmt" + "strings" + "testing" + "time" + + "github.com/Agent-Field/codeaf/internal/tui2/tokens" + "github.com/charmbracelet/x/ansi" +) + +// wallTestNow is the fixture's clock; the painter reads no other. +var wallTestNow = time.Date(2026, 9, 23, 12, 0, 0, 0, time.UTC) + +// wallFixture is n tiles cycling through every state the painter draws: +// working, waiting on a person, idle, frozen, marked, and one with no spark; +// in three teams, some tiles in several. +// wallTestIDs are the fixture's teams' ids, port, infra and research in that +// order. +var wallTestIDs = []string{"a1b2c3d4e5f6", "0f9e8d7c6b5a", "123456abcdef"} + +// wallViewHues is the colour of every team in v, in order. +func wallViewHues(v wallView) []teamHueSpec { + out := make([]teamHueSpec, 0, len(v.teams)) + for _, t := range v.teams { + out = append(out, t.hue) + } + return out +} + +func wallFixture(n int) wallView { + names := []string{"the tree walk", "cut the goldens", "ship the port", "relay audit", "footprint table", "crew reprice", "suite lock"} + v := wallView{team: wallTestIDs[0], now: wallTestNow, spin: 3} + reserved := teamReservedFrom(darkRamp) + var hues []teamHueSpec + for i, name := range []string{"port", "infra", "research"} { + hue := nextTeamHue(hues, reserved) + hues = append(hues, hue) + v.teams = append(v.teams, wallTeamRow{id: wallTestIDs[i], name: name, hue: hue, count: 3 - i, members: 4 - i}) + } + v.total = n + for i := 0; i < n; i++ { + t := wallTile{ + tab: chatTab{key: fmt.Sprintf("k%d", i)}, + name: names[i%len(names)], + live: true, + age: fmt.Sprintf("%dm", i+2), + lines: []wallLine{ + {wallUser, "look at the watcher and tell me whether it caches both facts"}, + {wallTool, "▸ read internal/tui3/keeper.go"}, + {wallProse, "the watcher already caches the two facts at the transitions it computes, so the strip can read both as atomics without taking the agent's mutex"}, + {wallNote, "compacted 12 turns"}, + {wallTool, "bash go test ./internal/tui3 -run TestWall"}, + {wallProse, "writing the change note"}, + }, + spark: []uint8{0, 1, 2, 4, 6, 4, 2, 1, 4, 6, 7, 3}, + moved: wallTestNow.Add(-time.Duration(i+2) * time.Minute), + } + switch i % 6 { + case 0: + t.signal = tabWorking + t.doing = "running bash" + t.fresh, t.freshAt = 2, wallTestNow.Add(-200*time.Millisecond) + t.teams = []string{wallTestIDs[0], wallTestIDs[1]} + case 1: + t.signal = tabNeedsPerson + t.doing = "waiting on you" + t.question = "needs your ok to run bash: go test ./internal/tui3" + t.teams = []string{wallTestIDs[0]} + case 2: + t.signal = tabWorking + t.doing = "writing" + t.marked = true + t.teams = []string{wallTestIDs[0], wallTestIDs[1], wallTestIDs[2]} + case 3: + t.signal = tabIdle + t.spark = nil + case 4: + t.signal = tabWorking + t.live = false + case 5: + t.signal = tabIdle + t.marked = true + t.spark = []uint8{0, 0, 0} + t.teams = []string{wallTestIDs[2]} + } + v.tiles = append(v.tiles, t) + } + return v +} + +// wallUnmarked is v with nothing picked, so no tray floats over the grid. +func wallUnmarked(v wallView) wallView { + tiles := append([]wallTile(nil), v.tiles...) + for i := range tiles { + tiles[i].marked = false + } + v.tiles = tiles + return v +} + +func wallTestPalettes() map[string]palette { + return map[string]palette{ + "unicode": newPalette(tokens.TrueColor, false), + "ascii": newPalette(tokens.TrueColor, true), + } +} + +var wallTestSizes = [][2]int{{80, 24}, {120, 40}, {180, 50}} + +// wallPlainFrame is the frame as text, one row per line. +func wallPlainFrame(rows []string) string { + var b strings.Builder + for _, r := range rows { + b.WriteString(ansi.Strip(r)) + b.WriteString("\n") + } + return b.String() +} + +func TestWallViewFrames(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, n := range []int{1, 6, 13} { + for _, sz := range wallTestSizes { + w, h := sz[0], sz[1] + for _, focus := range []int{0, n / 2, n - 1} { + v := wallUnmarked(wallFixture(n)) + v.focus = focus + name := fmt.Sprintf("%s/n%d/%dx%d/f%d", pname, n, w, h, focus) + rows, hits := renderWall(pal, v, w, h) + wallCheckRows(t, name, rows, w, h) + wallCheckHits(t, name, hits, w, h) + wallCheckFocus(t, name, pal, rows, hits, focus) + } + } + } + } +} + +// wallCheckRows: exactly h rows, none wider than w. +func wallCheckRows(t *testing.T, name string, rows []string, w, h int) { + t.Helper() + if len(rows) != h { + t.Fatalf("%s: %d rows, want %d", name, len(rows), h) + } + for y, r := range rows { + if got := ansi.StringWidth(r); got > w { + t.Fatalf("%s: row %d is %d cells wide, frame is %d: %q", name, y, got, w, ansi.Strip(r)) + } + } +} + +// wallCheckHits: every hit inside the frame, none overlapping another. +func wallCheckHits(t *testing.T, name string, hits []wallHit, w, h int) { + t.Helper() + for i, a := range hits { + if a.x0 < 0 || a.y0 < 0 || a.x1 > w || a.y1 > h || a.x0 >= a.x1 || a.y0 >= a.y1 { + t.Fatalf("%s: hit %d out of bounds: %+v", name, i, a) + } + for j, b := range hits[:i] { + if a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1 { + t.Fatalf("%s: hits %d and %d overlap: %+v %+v", name, j, i, b, a) + } + } + } +} + +// wallCheckFocus: the focused tile is on screen, and it and only it is heavy. +// Each tile's first hit is the one on its top-left corner (wallTileHits). +func wallCheckFocus(t *testing.T, name string, pal palette, rows []string, hits []wallHit, focus int) { + t.Helper() + heavyTL, lightTL := "┏", "╭" + if pal.ascii { + heavyTL, lightTL = "#", "+" + } + found := false + seen := map[int]bool{} + for _, hit := range hits { + if hit.kind != wallHitTile || seen[hit.arg] { + continue + } + seen[hit.arg] = true + corner := ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0, hit.x0+1)) + want := lightTL + if hit.arg == focus { + found = true + want = heavyTL + } + if corner != want { + t.Fatalf("%s: tile %d corner %q, want %q", name, hit.arg, corner, want) + } + } + if !found { + t.Fatalf("%s: focused tile %d not on screen", name, focus) + } +} + +func TestWallScrollKeepsFocus(t *testing.T) { + for _, n := range []int{1, 6, 13} { + for _, sz := range wallTestSizes { + w, h := sz[0], sz[1] + c, _, tileH := wallGrid(n, w, h, 0) + vis := wallVisibleRows(h, tileH) + scroll := 0 + // Walk the focus down and back up; every step stays on screen. + path := make([]int, 0, 2*n) + for f := 0; f < n; f++ { + path = append(path, f) + } + for f := n - 1; f >= 0; f-- { + path = append(path, f) + } + for _, f := range path { + scroll = wallScrollFor(f, scroll, n, w, h, 0) + row := f / c + if row < scroll || row >= scroll+vis { + t.Fatalf("n%d %dx%d: focus %d (row %d) off screen at scroll %d, %d rows visible", n, w, h, f, row, scroll, vis) + } + } + // A focus already visible does not move the scroll. + if got := wallScrollFor(0, 0, n, w, h, 0); got != 0 { + t.Fatalf("n%d %dx%d: scroll moved to %d for a visible focus", n, w, h, got) + } + } + } +} + +func TestWallGridShape(t *testing.T) { + for _, tc := range []struct { + w, cols, want int + }{ + {80, 0, 1}, {120, 0, 2}, {180, 0, 3}, {220, 0, 4}, + // An override past the minimum tile width loses columns instead of + // squeezing: the rows scroll. + {120, 4, 2}, {80, 4, 1}, {40, 3, 1}, {200, 4, 4}, + } { + c, tileW, _ := wallGrid(13, tc.w, 40, tc.cols) + if c != tc.want { + t.Errorf("width %d cols %d: %d columns, want %d", tc.w, tc.cols, c, tc.want) + } + if c > 1 && tileW < wallTileMinW { + t.Errorf("width %d cols %d: tile %d wide", tc.w, tc.cols, tileW) + } + // The grid keeps a margin either side. + if used := c*tileW + (c-1)*wallGutter; used > tc.w-2*wallMargin { + t.Errorf("width %d cols %d: the grid takes %d cells and leaves no margin", tc.w, tc.cols, used) + } + } + for _, h := range []int{24, 40, 50} { + _, _, tileH := wallGrid(13, 120, h, 0) + gridH := h - wallChromeRows + if tileH > wallTileMaxH || (tileH < wallTileMinH && gridH >= wallTileMinH) { + t.Errorf("height %d: tile %d high", h, tileH) + } + // A frame that can hold two rows at the floor always shows two. + if vis := wallVisibleRows(h, tileH); vis < 2 && gridH >= 2*wallTileMinH+wallRowGap { + t.Errorf("height %d: %d rows visible, want at least 2", h, vis) + } + } +} + +func TestWallRenderStates(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallFixture(6) + rows, _ := renderWall(pal, v, 180, 50) + frame := wallPlainFrame(rows) + for _, want := range []string{ + "▦ Conversations", "open in this window · in port", "⠿ 2 running", "? 1 needs you", "6 open", + "Teams", "All 6", "port 3", "+ New team", + "Answer ↵", "seen 6m ago", "running bash " + wallGlyphsFor(false).sep + " 2m", "? waiting on you", + "updated 5m ago", "☑", "▌", tokens.Spinner(v.spin), + } { + if !strings.Contains(frame, want) { + t.Errorf("frame lacks %q\n%s", want, frame) + } + } + // A frozen tile draws no spinner, and the ages left the borders. + if got := strings.Count(frame, tokens.Spinner(v.spin)); got != 2 { + t.Errorf("want two spinners (the live working tiles), got %d", got) + } + for _, r := range rows { + if top := ansi.Strip(r); strings.Contains(top, "╭─") && strings.Contains(top, " 2m ") { + t.Errorf("an age is still on a border: %q", top) + } + } + // "wall" and "tab" are never drawn. + for _, word := range []string{" wall ", " tab "} { + if strings.Contains(strings.ToLower(frame), word) { + t.Errorf("the frame says %q", word) + } + } + + empty, hits := renderWall(pal, wallView{}, 80, 24) + if len(empty) != 24 || len(hits) != 1 || hits[0].kind != wallHitAction || hits[0].arg != int(wallActBack) { + t.Fatalf("empty: %d rows, hits %+v", len(empty), hits) + } + if got := ansi.Strip(ansi.Cut(empty[hits[0].y0], hits[0].x0, hits[0].x1)); !strings.Contains(got, "Back") { + t.Fatalf("the empty frame's way back is drawn as %q", got) + } + if !strings.Contains(wallPlainFrame(empty), "No open conversations") { + t.Fatalf("the empty frame says nothing") + } + + v.filtering, v.filter = true, "port" + rows, _ = renderWall(pal, v, 120, 40) + if got := ansi.Strip(rows[1]); !strings.Contains(got, "/ port▌") || !strings.Contains(got, "Clear esc") { + t.Errorf("filter row: %q", got) + } + v.filtering, v.filter, v.naming, v.name = false, "", true, "night" + v.choices = teamHueChoices(wallViewHues(v), teamReservedFrom(darkRamp), 6) + rows, _ = renderWall(pal, v, 120, 40) + card := wallPlainFrame(rows) + for _, want := range []string{"─ New team ─", "Name night▌", "Colour ◉ ● ● ● ● ●", "2 · ship the port, crew reprice", "Cancel esc", "Create ↵", "Shuffle"} { + if !strings.Contains(card, want) { + t.Errorf("the new-team card lacks %q\n%s", want, card) + } + } + // Too short for the card, the prompt falls back to the Teams row. + rows, _ = renderWall(pal, v, 120, 9) + if got := ansi.Strip(rows[1]); !strings.Contains(got, "New team › night▌") || !strings.Contains(got, "2 picked") { + t.Errorf("naming row: %q", got) + } +} + +func TestWallRenderPrintsFrame(t *testing.T) { + for pname, pal := range wallTestPalettes() { + base := wallFixture(6) + base.focus = 0 + + v := wallUnmarked(base) + rows, _ := renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, at rest, tiles dotted by their teams:\n%s", pname, wallPlainFrame(rows)) + + v.hover = wallHitRef{kind: wallHitTile, arg: 1} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, tile 1 hovered:\n%s", pname, wallPlainFrame(rows)) + + v = wallUnmarked(base) + v.hover = wallHitRef{kind: wallHitSelect, arg: 3} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, tile 3's Select hovered, its action row up:\n%s", pname, wallPlainFrame(rows)) + + v = wallUnmarked(base) + v.help = true + v.hover = wallHitRef{kind: wallHitHelp, arg: 3} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, the help sheet, Next needing you hovered:\n%s", pname, wallPlainFrame(rows)) + rows, _ = renderWall(pal, v, 80, 21) + t.Logf("%s 80x21 (an 80x24 window's wall), the help sheet scrolling:\n%s", pname, wallPlainFrame(rows)) + v.helpTop = 99 + rows, _ = renderWall(pal, v, 80, 21) + t.Logf("%s 80x21, the help sheet scrolled to its end:\n%s", pname, wallPlainFrame(rows)) + + v = base + v.hover = wallHitRef{kind: wallHitAction, arg: int(wallActAddTo)} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, tiles 2 and 5 selected, the tray up, every tile's box on its top border:\n%s", pname, wallPlainFrame(rows)) + + v = wallUnmarked(base) + v.pop = wallPop{kind: wallPopMembers, x: 90, y0: 4, y1: 5, targets: []string{"k1"}, cursor: -1} + v.hover = wallHitRef{kind: wallHitPopRow, id: wallTestIDs[1]} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, the teams popover of tile 1:\n%s", pname, wallPlainFrame(rows)) + + v = base + v.naming, v.name, v.nameFresh = true, "harbor", true + v.choices = teamHueChoices(wallViewHues(v), teamReservedFrom(darkRamp), 6) + v.hover = wallHitRef{kind: wallHitAction, arg: int(wallActSave)} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, naming a team:\n%s", pname, wallPlainFrame(rows)) + + v.asking, v.hover = true, wallHitRef{} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, naming a team while a name is asked for:\n%s", pname, wallPlainFrame(rows)) + + v = wallUnmarked(base) + v.hover = wallHitRef{kind: wallHitTeams, arg: 0} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, tile 0's teams control hovered, the toolbar saying what it does:\n%s", pname, wallPlainFrame(rows)) + + v = wallUnmarked(base) + v.focus, v.hover = 1, wallHitRef{kind: wallHitOpen, arg: 1} + v.pointerOn, v.pointerY = true, wallAnswerHit(t, pal, v, 120, 40).y0 + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, the waiting tile focused, its Answer hovered:\n%s", pname, wallPlainFrame(rows)) + + v = wallUnmarked(base) + v.pop = wallPop{kind: wallPopSettings, x: 20, y0: 1, y1: 2, team: wallTestIDs[1], name: "infra", + choices: teamHueChoices(wallViewHues(v), teamReservedFrom(darkRamp), 6)} + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, a team's settings:\n%s", pname, wallPlainFrame(rows)) + + for _, sz := range [][2]int{{80, 24}, {180, 50}} { + rows, _ = renderWall(pal, wallUnmarked(wallFixture(13)), sz[0], sz[1]) + t.Logf("%s %dx%d, 13 conversations:\n%s", pname, sz[0], sz[1], wallPlainFrame(rows)) + } + v = wallUnmarked(base) + v.tiles, v.filter = nil, "xyz" + rows, _ = renderWall(pal, v, 120, 40) + t.Logf("%s 120x40, a filter matching nothing:\n%s", pname, wallPlainFrame(rows)) + } +} + +// wallFrameVariants is the fixture in every state a pointer can put it in: +// each target of the resting frame hovered in turn, with and without picks, +// naming, and with each popover up. +func wallFrameVariants(t *testing.T, pal palette, n, w, h int, each func(name string, v wallView, rows []string, hits []wallHit)) { + t.Helper() + type state struct { + name string + v wallView + } + base := wallFixture(n) + naming := base + naming.naming, naming.name = true, "harbor" + naming.choices = teamHueChoices(wallViewHues(base), teamReservedFrom(darkRamp), 6) + members := wallUnmarked(base) + members.pop = wallPop{kind: wallPopMembers, x: w / 2, y0: 5, y1: 6, targets: []string{"k0", "k1"}, cursor: -1} + settings := wallUnmarked(base) + settings.pop = wallPop{kind: wallPopSettings, x: 10, y0: 1, y1: 2, team: wallTestIDs[1], name: "infra", choices: naming.choices} + confirm := settings + confirm.pop.confirm = true + help := wallUnmarked(base) + help.help = true + scrolled := help + scrolled.helpTop = 99 + for _, s := range []state{ + {"rest", wallUnmarked(base)}, {"picked", base}, {"naming", naming}, + {"members", members}, {"settings", settings}, {"confirm", confirm}, + {"help", help}, {"help scrolled", scrolled}, + } { + _, rest := renderWall(pal, s.v, w, h) + refs := []wallHitRef{{}} + for _, hit := range rest { + refs = append(refs, hit.ref()) + } + for _, ref := range refs { + v := s.v + v.hover = ref + rows, hits := renderWall(pal, v, w, h) + each(fmt.Sprintf("n%d/%dx%d/%s/hover=%+v", n, w, h, s.name, ref), v, rows, hits) + } + } +} + +// EVERY TARGET SITS ON WHAT IT DRAWS, and no two targets share a cell, in every +// state the pointer can put the frame in. +func TestWallClickHitsSitOnTheirLabels(t *testing.T) { + labels := map[wallAct]string{ + wallActBack: "Back", wallActNewTeam: "New team", wallActFilter: "Filter", wallActNext: "needs you", + wallActColsLess: "−", wallActColsMore: "+", wallActMakeTeam: "Make team", wallActAddTo: "Add to", + wallActCloseViews: "Close views", wallActClear: "Clear", wallActSave: "Create", wallActCancel: "Cancel", + wallActFilterClear: "Clear", wallActShuffle: "Shuffle", wallActHelp: "Help", + } + for pname, pal := range wallTestPalettes() { + for _, sz := range wallTestSizes { + wallFrameVariants(t, pal, 6, sz[0], sz[1], func(name string, v wallView, rows []string, hits []wallHit) { + name = pname + "/" + name + wallCheckRows(t, name, rows, sz[0], sz[1]) + wallCheckHits(t, name, hits, sz[0], sz[1]) + for _, hit := range hits { + drawn := ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0, hit.x1)) + if strings.TrimSpace(drawn) == "" && hit.kind != wallHitTile { + t.Fatalf("%s: a %d target over blank cells %+v", name, hit.kind, hit) + } + if hit.kind == wallHitAction && hit.y1-hit.y0 == 1 && hit.arg != int(wallActFilter) { + want := labels[wallAct(hit.arg)] + if pal.ascii && want == "−" { + want = "-" + } + if !strings.Contains(drawn, want) { + t.Fatalf("%s: button %d drawn as %q, want %q", name, hit.arg, drawn, want) + } + } + } + }) + } + } +} + +// THE TRAY IS UP IF AND ONLY IF SOMETHING IS PICKED, and the toolbar under it +// keeps its buttons either way. +func TestWallBarTrayIffMarked(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + for _, sz := range wallTestSizes { + for _, marks := range []bool{false, true} { + v := wallFixture(6) + if !marks { + v = wallUnmarked(v) + } + rows, hits := renderWall(pal, v, sz[0], sz[1]) + frame := wallPlainFrame(rows) + if tray := strings.Contains(frame, "2 selected"); tray != marks { + t.Fatalf("%dx%d marks=%v: tray drawn=%v\n%s", sz[0], sz[1], marks, tray, frame) + } + makes, adds := false, false + for _, hit := range hits { + if hit.kind == wallHitAction && hit.arg == int(wallActMakeTeam) { + makes = true + } + if hit.kind == wallHitAction && hit.arg == int(wallActAddTo) { + adds = true + } + } + if makes != marks || (marks && !adds) { + t.Fatalf("%dx%d marks=%v: make team=%v add to=%v\n%s", sz[0], sz[1], marks, makes, adds, frame) + } + if bar := ansi.Strip(rows[len(rows)-1]); !strings.Contains(bar, "Back esc") { + t.Fatalf("%dx%d: the toolbar lost its way back: %q", sz[0], sz[1], bar) + } + } + } +} + +// THE TOOLBAR NEVER WRAPS AND DROPS WHOLE BUTTONS, keeping the way back longest. +func TestWallBarDropsWholeButtons(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallFixture(6) + for w := 20; w <= 200; w += 7 { + row, hits := wallBar(pal, v, w, 0) + if ansi.StringWidth(row) > w { + t.Fatalf("width %d: bar is %d cells", w, ansi.StringWidth(row)) + } + for _, hit := range hits { + if hit.x1 > w { + t.Fatalf("width %d: a button past the edge %+v", w, hit) + } + } + if !strings.Contains(ansi.Strip(row), "Back esc") { + t.Fatalf("width %d: the way back left before the rest: %q", w, ansi.Strip(row)) + } + if w >= 80 && !strings.Contains(ansi.Strip(row), "Columns") { + t.Fatalf("width %d: no room was found for the columns: %q", w, ansi.Strip(row)) + } + } +} + +// A HINT IS SAID WHOLE, KEY AND ALL. While the pointer rests on a control +// the status line outranks the columns and the acts, which step aside for it +// (the one under the pointer and Help never do); at 80 it read `Resume the …`. +func TestWallBarHintOutranksTheButtons(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallUnmarked(wallFixture(6)) + v.away = 2 + v.hover = wallHitRef{kind: wallHitAction, arg: int(wallActResume)} + want := wallHint(v, pal.ascii) + if !strings.HasSuffix(want, "· r") { + t.Fatalf("the fixture's hint is %q", want) + } + for _, w := range []int{80, 110, 160} { + row, _ := wallBar(pal, v, w, 0) + plainRow := ansi.Strip(row) + if ansi.StringWidth(row) > w || !strings.Contains(plainRow, want) || !strings.Contains(plainRow, "Help ?") { + t.Fatalf("width %d: the hint is not whole beside Help: %q", w, plainRow) + } + } + // The button under the pointer keeps its place while its own hint shows. + v.hover = wallHitRef{kind: wallHitAction, arg: int(wallActFilter)} + row, _ := wallBar(pal, v, 80, 0) + if !strings.Contains(ansi.Strip(row), "Filter /") { + t.Fatalf("the hovered button stepped aside: %q", ansi.Strip(row)) + } + // And with the pointer gone every button is back. + v.hover = wallHitRef{} + if row, _ := wallBar(pal, v, 80, 0); !strings.Contains(ansi.Strip(row), "Columns") { + t.Fatalf("the columns did not come back: %q", ansi.Strip(row)) + } +} + +// A TILE'S ACTIONS ARE WORDS ON ITS BOTTOM BORDER, drawn under the pointer or +// the focus and nowhere else, into cells that depend on the width alone: +// hovering a tile moves nothing in it, and its top border carries no control. +func TestWallTileActionRowReservesCells(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, sz := range wallTestSizes { + v := wallUnmarked(wallFixture(6)) + v.focus = 0 + _, tileW, tileH := wallGrid(len(v.tiles), sz[0], sz[1], 0) + g := wallGlyphsFor(pal.ascii) + k := wallKeysFor(pal.ascii) + name := fmt.Sprintf("%s %dx%d", pname, sz[0], sz[1]) + for _, i := range []int{1, 3, 5} { // waiting, no teams, one team + rest := wallPaintTile(pal, g, v, v.tiles[i], i, false, tileW, tileH, wallGridTop) + hv := v + hv.hover = wallHitRef{kind: wallHitTile, arg: i} + hover := wallPaintTile(pal, g, hv, v.tiles[i], i, false, tileW, tileH, wallGridTop) + if len(rest) != tileH || len(hover) != tileH { + t.Fatalf("%s: %d rows at rest, %d hovered, tile is %d", name, len(rest), len(hover), tileH) + } + for y := range rest { + if ansi.StringWidth(rest[y]) != tileW || ansi.StringWidth(hover[y]) != tileW { + t.Fatalf("%s row %d: %d then %d cells, tile is %d", name, y, + ansi.StringWidth(rest[y]), ansi.StringWidth(hover[y]), tileW) + } + } + // The top border is the same row at rest and hovered: dots and a + // title, and no box outside the selection mode. + top, topHover := ansi.Strip(rest[0]), ansi.Strip(hover[0]) + if top != topHover { + t.Fatalf("%s: the top border changed under the pointer:\n%q\n%q", name, top, topHover) + } + if strings.Contains(ansi.Cut(top, 0, 5), wallSelGlyph(pal.ascii, false)) || strings.Contains(top, "open") { + t.Fatalf("%s: the top border carries a control: %q", name, top) + } + // Every row but the bottom one is the same; the bottom one is the + // action row, its buttons where the layout put them. + for y := 1; y < tileH-1; y++ { + if ansi.Strip(rest[y]) != ansi.Strip(hover[y]) { + t.Fatalf("%s row %d moved under the pointer:\n%q\n%q", name, y, ansi.Strip(rest[y]), ansi.Strip(hover[y])) + } + } + bottom, bottomHover := ansi.Strip(rest[tileH-1]), ansi.Strip(hover[tileH-1]) + if strings.Contains(bottom, "Close") { + t.Fatalf("%s: the action row is drawn at rest: %q", name, bottom) + } + acts := wallTileActs(pal.ascii, v.tiles[i], tileW) + if len(acts) == 0 || acts[0].kind != wallHitOpen { + t.Fatalf("%s: tile %d keeps no Open: %+v", name, i, acts) + } + first := "Open " + k.enter + if v.tiles[i].signal == tabNeedsPerson { + first = "Answer " + k.enter + } + if !strings.Contains(bottomHover, first) { + t.Fatalf("%s: tile %d's action row does not start with %q: %q", name, i, first, bottomHover) + } + for _, act := range acts { + got := ansi.Strip(ansi.Cut(hover[tileH-1], act.x+1, act.x+1+ansi.StringWidth(act.btn.label))) + if got != act.btn.label { + t.Fatalf("%s: %q drawn as %q at %d: %q", name, act.btn.label, got, act.x, bottomHover) + } + } + } + // The focused tile shows its row with no pointer at all. + focused := ansi.Strip(wallPaintTile(pal, g, v, v.tiles[0], 0, true, tileW, tileH, wallGridTop)[tileH-1]) + if !strings.Contains(focused, "Open "+k.enter) { + t.Fatalf("%s: the focused tile hides its actions: %q", name, focused) + } + } + } +} + +// A NARROW TILE LOSES ITS BUTTONS FROM THE RIGHT AND KEEPS OPEN, and the row +// never runs past the tile. +func TestWallTileActionRowDropsFromTheRight(t *testing.T) { + for pname, pal := range wallTestPalettes() { + v := wallUnmarked(wallFixture(6)) + prev := 5 + for w := 60; w >= 12; w-- { + acts := wallTileActs(pal.ascii, v.tiles[0], w) + if len(acts) > prev { + t.Fatalf("%s width %d: %d buttons, more than the %d at a wider tile", pname, w, len(acts), prev) + } + prev = len(acts) + if len(acts) > 0 && acts[0].kind != wallHitOpen { + t.Fatalf("%s width %d: Open was dropped before %+v", pname, w, acts) + } + if n := len(acts); n > 0 && acts[n-1].x+wallButtonW(acts[n-1].btn)+2 > w { + t.Fatalf("%s width %d: the last button runs into the corner", pname, w) + } + hv := v + hv.hover = wallHitRef{kind: wallHitTile, arg: 0} + rows := wallPaintTile(pal, wallGlyphsFor(pal.ascii), hv, v.tiles[0], 0, false, w, 12, wallGridTop) + if got := ansi.StringWidth(rows[len(rows)-1]); got != w { + t.Fatalf("%s width %d: the action row is %d cells", pname, w, got) + } + } + if n := len(wallTileActs(pal.ascii, v.tiles[0], 200)); n != 4 { + t.Fatalf("%s: a wide tile carries %d buttons, want 4", pname, n) + } + } +} + +// A TILE CARRIES ITS TEAMS AS DOTS: up to three, then a count, and no cells at +// all for a tile in none. Colourless, a dot is the team's initial. +func TestWallTileDotsName(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallUnmarked(wallFixture(6)) + g := wallGlyphsFor(false) + _, tileW, tileH := wallGrid(6, 120, 40, 0) + top := func(p palette, t wallTile, i int) string { + return ansi.Strip(wallPaintTile(p, g, v, t, i, false, tileW, tileH, wallGridTop)[0]) + } + if got := top(pal, v.tiles[2], 2); !strings.Contains(got, "●●● ship the port") { + t.Fatalf("three teams: %q", got) + } + four := v.tiles[2] + four.teams = []string{wallTestIDs[0], wallTestIDs[1], wallTestIDs[2], wallTestIDs[0]} + if got := top(pal, four, 2); !strings.Contains(got, "●●●+1 ship the port") { + t.Fatalf("four teams: %q", got) + } + if got := top(pal, v.tiles[3], 3); strings.Contains(got, "●") || !strings.HasPrefix(got, "╭─ relay audit") { + t.Fatalf("no teams: %q", got) + } + plain := newPalette(tokens.ANSI16, false) + if got := top(plain, v.tiles[2], 2); !strings.Contains(got, "pir ship the port") { + t.Fatalf("no colour: %q", got) + } +} + +// ONE PICK IS THE SELECTION MODE: every tile shows its box, filled or not. +func TestWallClickSelectionModeShowsEveryBox(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallFixture(4) // tile 2 is picked + _, tileW, tileH := wallGrid(4, 180, 50, 0) + g := wallGlyphsFor(false) + for i, tile := range v.tiles { + top := ansi.Strip(wallPaintTile(pal, g, v, tile, i, false, tileW, tileH, wallGridTop)[0]) + want := wallSelGlyph(false, tile.marked) + if !strings.HasPrefix(top, "╭─ "+want) { + t.Fatalf("tile %d in selection mode: %q, want the box %q", i, top, want) + } + } + rows, hits := renderWall(pal, v, 180, 50) + boxes := map[int]bool{} + for _, hit := range hits { + if hit.kind == wallHitSelect && strings.Contains(ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0, hit.x1)), wallSelGlyph(false, v.tiles[hit.arg].marked)) { + boxes[hit.arg] = true + } + } + if len(boxes) != 4 { + t.Fatalf("%d selection boxes answer the pointer, want all 4", len(boxes)) + } + // Out of the selection mode no tile draws a box, hovered or not. + v = wallUnmarked(v) + v.hover = wallHitRef{kind: wallHitTile, arg: 1} + for i, tile := range v.tiles { + top := ansi.Strip(wallPaintTile(pal, g, v, tile, i, false, tileW, tileH, wallGridTop)[0]) + if strings.Contains(top, wallSelGlyph(false, false)) { + t.Fatalf("tile %d draws a box out of the selection mode: %q", i, top) + } + } +} + +// THE TEAMS ROW IS A ROW OF DOORS: All, each team and + New team; a +// segment's dot and, under the pointer, its ⋯ open its settings. The minimap +// is there only when the conversations do not all fit. +func TestWallClickTeamsAndMinimap(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + for _, n := range []int{6, 13} { + v := wallUnmarked(wallFixture(n)) + rows, hits := renderWall(pal, v, 120, 40) + chips, menus, minis, add := map[string]bool{}, 0, 0, false + for _, hit := range hits { + switch hit.kind { + case wallHitChip: + chips[hit.id] = true + case wallHitChipMenu: + menus++ + case wallHitMini: + minis++ + case wallHitAddTeam: + add = true + } + } + c, _, tileH := wallGrid(n, 120, 40, 0) + overflow := (n+c-1)/c > wallVisibleRows(40, tileH) + if len(chips) != 4 || !add || menus != 3 || (minis > 0) != overflow { + t.Fatalf("n%d: chips %v, + New team %v, %d dots, %d minimap cells\n%s", n, chips, add, menus, minis, ansi.Strip(rows[1])) + } + } + v := wallUnmarked(wallFixture(6)) + v.hover = wallHitRef{kind: wallHitChip, id: wallTestIDs[1]} + rows, hits := renderWall(pal, v, 120, 40) + if !strings.Contains(ansi.Strip(rows[1]), "infra ⋯ │") { + t.Fatalf("the hovered segment shows no ⋯: %q", ansi.Strip(rows[1])) + } + tails := 0 + for _, hit := range hits { + if hit.kind == wallHitChipMenu && hit.id == wallTestIDs[1] { + tails++ + } + } + if tails != 2 || strings.Count(ansi.Strip(rows[1]), "⋯") != 1 { + t.Fatalf("the hovered segment: %d settings targets, row %q", tails, ansi.Strip(rows[1])) + } +} + +// THE TEAMS POPOVER SAYS, PER TEAM, WHETHER ITS TARGETS ARE IN IT: all, none, +// or some. +func TestWallPopoverBoxesAreTriState(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallUnmarked(wallFixture(6)) + // k0 is in port and infra, k1 in port alone. + v.pop = wallPop{kind: wallPopMembers, x: 60, y0: 4, y1: 5, targets: []string{"k0", "k1"}, cursor: -1} + rows, hits := renderWall(pal, v, 120, 40) + frame := wallPlainFrame(rows) + for _, want := range []string{"─ Teams ─", "☑ ● port", "▣ ● infra", "☐ ● research", "+ New team…"} { + if !strings.Contains(frame, want) { + t.Fatalf("the popover lacks %q\n%s", want, frame) + } + } + rowsHit := 0 + for _, hit := range hits { + if hit.kind == wallHitPopRow { + rowsHit++ + } + } + if rowsHit != 4 { + t.Fatalf("%d popover rows answer the pointer, want 4", rowsHit) + } +} + +func TestTeamFreshNameAvoidsTakenNames(t *testing.T) { + first := func(int) int { return 0 } + shared := []chatTab{{key: "a", where: "/w/harbor-app"}, {key: "b", where: "/w/harbor-app"}} + if got := teamFreshName(shared, nil, "", first); got != "harbor-app" { + t.Fatalf("shared folder: %q", got) + } + if got := teamFreshName(shared, []string{"Harbor-App"}, "", first); got != "harbor" { + t.Fatalf("a taken folder name should fall to a word: %q", got) + } + apart := []chatTab{{key: "a", where: "/w/one"}, {key: "b", where: "/w/two"}} + if got := teamFreshName(apart, []string{"harbor", "orbit"}, "", first); got != "lumen" { + t.Fatalf("a word already a team's name was offered: %q", got) + } + if got := teamFreshName(shared, nil, "harbor-app", first); got != "harbor" { + t.Fatalf("a shuffle should leave the folder and the current name: %q", got) + } + if got := teamFreshName(apart, teamWords, "", first); got != "harbor2" { + t.Fatalf("every word taken: %q", got) + } +} + +func TestTeamAddAndRemoveKeepOrderAndSave(t *testing.T) { + dir := t.TempDir() + a := newTestAppWithProfile(dir, nil) + i, err := a.teamMake("port", []chatTab{{key: "k1", word: "one"}}) + if err != nil { + t.Fatal(err) + } + if err := a.teamAdd(i, []chatTab{{key: "k1"}, {key: "k2", word: "two"}, {key: "k3", word: "three"}}); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + got, _ := loadTeams(dir, nil) + if len(got) != 1 || len(got[0].Members) != 3 || got[0].Members[1].Key != "k2" { + t.Fatalf("after add: %+v", got) + } + if err := a.teamRemove(i, []string{"k1", "k3"}); err != nil { + t.Fatal(err) + } + teamsFlush(t, a) + got, _ = loadTeams(dir, nil) + if len(got[0].Members) != 1 || got[0].Members[0].Key != "k2" { + t.Fatalf("after remove: %+v", got) + } +} + +// wallAnswerHit is where tile 1's Answer button landed: the open target that +// is not on the tile's top border. +func wallAnswerHit(t *testing.T, pal palette, v wallView, w, h int) wallHit { + t.Helper() + rows, hits := renderWall(pal, v, w, h) + for _, hit := range hits { + if hit.kind == wallHitOpen && hit.arg == 1 && strings.Contains(ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0, hit.x1)), "Answer") { + return hit + } + } + t.Fatalf("no Answer button on the waiting tile:\n%s", wallPlainFrame(rows)) + return wallHit{} +} + +// EVERY TILE KEEPS ONE RHYTHM: its state line, exactly one blank row, then the +// body from the top, whatever the body's length. +func TestWallTileBodyHangsFromTheTop(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, sz := range wallTestSizes { + v := wallUnmarked(wallFixture(6)) + // Tile 3 has a tail far shorter than its room. + v.tiles[3].lines = v.tiles[3].lines[:1] + _, tileW, tileH := wallGrid(len(v.tiles), sz[0], sz[1], 0) + g := wallGlyphsFor(pal.ascii) + padY, meta, _ := wallTileRoom(tileH) + if !meta { + continue + } + for i, tile := range v.tiles { + rows := wallPaintTile(pal, g, v, tile, i, false, tileW, tileH, wallGridTop) + inner := func(y int) string { return strings.TrimSpace(ansi.Strip(ansi.Cut(rows[y], 1, tileW-1))) } + state, gap, first := 1+padY, 2+padY, 3+padY + if inner(gap) != "" || inner(first) == "" { + t.Fatalf("%s %dx%d tile %d: state %q, then %q, then %q", pname, sz[0], sz[1], i, inner(state), inner(gap), inner(first)) + } + } + } + } +} + +// A WAITING TILE ENDS IN A BUTTON: the question, a blank row, and Answer, +// which is the tile's open and sits on its own label. +func TestWallNeedsYouTileAnswers(t *testing.T) { + for pname, pal := range wallTestPalettes() { + v := wallUnmarked(wallFixture(6)) + hit := wallAnswerHit(t, pal, v, 120, 40) + rows, _ := renderWall(pal, v, 120, 40) + above := strings.TrimSpace(ansi.Strip(ansi.Cut(rows[hit.y0-1], hit.x0, hit.x0+50))) + question := ansi.Strip(rows[hit.y0-2]) + if above != "" || !strings.Contains(question, "needs your ok") { + t.Fatalf("%s: over the button %q, then %q", pname, question, above) + } + // The label starts on the text's column, its ground in the padding. + if got := ansi.Strip(ansi.Cut(rows[hit.y0], hit.x0+1, hit.x0+7)); got != "Answer" { + t.Fatalf("%s: the label is %q one cell into the button", pname, got) + } + if col := ansi.StringWidth(question[:strings.Index(question, "needs")]); col != hit.x0+1 { + t.Fatalf("%s: the question and the button's label do not share a column: %q at %d", pname, question, hit.x0+1) + } + // With the pointer's row known, the Answer lights and the corner's + // open does not, though both answer to the same target. + v.hover = hit.ref() + v.pointerOn, v.pointerY = true, hit.y0 + lit, _ := renderWall(pal, v, 120, 40) + if lit[hit.y0] == rows[hit.y0] { + t.Fatalf("%s: the hovered Answer is drawn as at rest", pname) + } + } +} + +// THE TOOLBAR SAYS WHAT THE CONTROL UNDER THE POINTER DOES, and says nothing +// with the pointer on no control. +func TestWallToolbarExplainsTheHover(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallUnmarked(wallFixture(6)) + bar := func(v wallView) string { + rows, _ := renderWall(pal, v, 120, 40) + return ansi.Strip(rows[len(rows)-1]) + } + rest := bar(v) + for ref, want := range map[wallHitRef]string{ + {kind: wallHitTeams, arg: 0}: "Add this conversation to teams · m", + {kind: wallHitOpen, arg: 0}: "Open conversation · enter", + {kind: wallHitClose, arg: 0}: "Close this view; the work keeps running · x", + {kind: wallHitSelect, arg: 0}: "Select for a team · space", + {kind: wallHitChip, id: wallTestIDs[1]}: "infra · 2 open here · 3 members", + {kind: wallHitAction, arg: int(wallActColsMore)}: "More columns · +", + } { + hv := v + hv.hover = ref + got := bar(hv) + if !strings.Contains(got, want) { + t.Fatalf("hover %+v: toolbar %q, want %q", ref, got, want) + } + // The status line moves no button. + col := func(s string) int { return ansi.StringWidth(s[:strings.Index(s, "Filter /")]) } + if col(got) != col(rest) { + t.Fatalf("hover %+v moved the toolbar's buttons:\n%q\n%q", ref, rest, got) + } + } + if strings.Contains(rest, " · ") { + t.Fatalf("the toolbar explains a hover with none: %q", rest) + } +} + +// THE TEAMS ROW IS ONE SEGMENTED CONTROL: every separator has one blank cell +// either side, and + New team is its last segment. +func TestWallTeamsRowIsEvenlyPadded(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, hover := range []wallHitRef{{}, {kind: wallHitChip, id: wallTestIDs[1]}} { + v := wallUnmarked(wallFixture(6)) + v.hover = hover + rows, _ := renderWall(pal, v, 120, 40) + row := ansi.Strip(rows[1]) + sep := "│" + if pal.ascii { + sep = "|" + } + parts := strings.Split(row, sep) + if len(parts) != 5 { + t.Fatalf("%s: %d segments in %q", pname, len(parts), row) + } + for i, p := range parts { + if i > 0 && (!strings.HasPrefix(p, " ") || strings.HasPrefix(p, " ")) { + t.Fatalf("%s: segment %d is %q", pname, i, p) + } + if i < len(parts)-1 && (!strings.HasSuffix(p, " ") || strings.HasSuffix(p, " ")) { + t.Fatalf("%s: segment %d is %q", pname, i, p) + } + } + if !strings.HasPrefix(parts[4], " + New team ") { + t.Fatalf("%s: + New team is not the last segment: %q", pname, row) + } + } + } +} + +// THE HEAD AND THE FOOT END WHERE THE GRID ENDS, and a count growing a digit +// moves nothing to its right. +func TestWallChromeAlignsWithTheGrid(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + for _, sz := range wallTestSizes { + var ends []int + for _, n := range []int{6, 13} { + v := wallUnmarked(wallFixture(n)) + rows, _ := renderWall(pal, v, sz[0], sz[1]) + c, tileW, _ := wallGrid(n, sz[0], sz[1], 0) + edge := wallMargin + c*tileW + (c-1)*wallGutter + title := strings.TrimRight(ansi.Strip(rows[0]), " ") + bar := strings.TrimRight(ansi.Strip(rows[len(rows)-1]), " ") + if ansi.StringWidth(title) != edge || ansi.StringWidth(bar) != edge { + t.Fatalf("%dx%d n%d: title ends at %d, toolbar at %d, the grid at %d", sz[0], sz[1], n, ansi.StringWidth(title), ansi.StringWidth(bar), edge) + } + ends = append(ends, ansi.StringWidth(title)) + // The foot mirrors the head: a blank row over a rule over the toolbar. + if strings.TrimSpace(ansi.Strip(rows[len(rows)-3])) != "" || !strings.HasPrefix(ansi.Strip(rows[len(rows)-2]), "───") { + t.Fatalf("%dx%d n%d: the foot is not a blank row and a rule:\n%s", sz[0], sz[1], n, wallPlainFrame(rows)) + } + } + if ends[0] != ends[1] { + t.Fatalf("%dx%d: the counts end at %d, then %d", sz[0], sz[1], ends[0], ends[1]) + } + } +} + +// A LONG TITLE IS CUT WITH AN ELLIPSIS AND KEEPS TWO RULE CELLS BEFORE THE +// CORNER, at rest, hovered and in the selection mode alike. +func TestWallLongTitleKeepsItsDistance(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + g := wallGlyphsFor(false) + v := wallUnmarked(wallFixture(6)) + v.tiles[3].name = strings.Repeat("a very long title ", 8) + for _, sz := range wallTestSizes { + _, tileW, tileH := wallGrid(6, sz[0], sz[1], 0) + for _, state := range []string{"rest", "hover", "picking"} { + hv := v + switch state { + case "hover": + hv.hover = wallHitRef{kind: wallHitTile, arg: 3} + case "picking": + hv.tiles = append([]wallTile(nil), v.tiles...) + hv.tiles[0].marked = true + } + top := ansi.Strip(wallPaintTile(pal, g, hv, hv.tiles[3], 3, false, tileW, tileH, wallGridTop)[0]) + cut := strings.Index(top, "…") + if cut < 0 { + t.Fatalf("%dx%d %s: the long title is not cut: %q", sz[0], sz[1], state, top) + } + runes := []rune(top) + at := len([]rune(top[:cut])) + gap := runes[at+2 : len(runes)-1] + if len(gap) < wallTitleGap || strings.Trim(string(gap), "─") != "" { + t.Fatalf("%dx%d %s: %d rule cells between the title and the corner: %q", sz[0], sz[1], state, len(gap), top) + } + } + } +} + +// A POPOVER STAYS INSIDE THE FRAME AND OFF THE FOOT, and flips over its +// control when there is no room under it. +func TestWallPopoverStaysInTheFrame(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + for _, sz := range wallTestSizes { + w, h := sz[0], sz[1] + for _, at := range []wallPop{{x: w - 3, y0: 4, y1: 5}, {x: 0, y0: h - 5, y1: h - 4}} { + v := wallUnmarked(wallFixture(6)) + at.kind, at.targets, at.cursor = wallPopMembers, []string{"k0"}, -1 + v.pop = at + card := wallPopCard(pal, wallGlyphsFor(false), v, w, h) + if len(card.rows) == 0 { + t.Fatalf("%dx%d: no popover", w, h) + } + bottom := card.y + len(card.rows) + if card.x < wallMargin || card.x+card.w > w-wallMargin || bottom > h-wallFootRows+1 { + t.Fatalf("%dx%d anchor %+v: popover at %d,%d %dx%d", w, h, at, card.x, card.y, card.w, len(card.rows)) + } + if at.y1 > h/2 && bottom > at.y0 { + t.Fatalf("%dx%d: a popover with no room below did not flip over its control: rows %d..%d, control on %d", w, h, card.y, bottom, at.y0) + } + // One blank row and two blank cells inside the border. + if got := ansi.Strip(card.rows[1]); strings.Trim(got, "│ ") != "" { + t.Fatalf("%dx%d: the popover's first inner row is %q", w, h, got) + } + if got := ansi.Strip(card.rows[2]); !strings.HasPrefix(got, "│ ") { + t.Fatalf("%dx%d: the popover's first line is %q", w, h, got) + } + } + } +} + +// A NARROWED GRID WITH NOTHING IN IT KEEPS ITS HEAD AND SAYS SO, beside the +// one button that undoes the narrowing. +func TestWallNarrowedToNothing(t *testing.T) { + for pname, pal := range wallTestPalettes() { + for _, sz := range wallTestSizes { + v := wallUnmarked(wallFixture(6)) + v.tiles, v.filter = nil, "xyz" + rows, hits := renderWall(pal, v, sz[0], sz[1]) + name := fmt.Sprintf("%s %dx%d", pname, sz[0], sz[1]) + wallCheckRows(t, name, rows, sz[0], sz[1]) + wallCheckHits(t, name, hits, sz[0], sz[1]) + frame := wallPlainFrame(rows) + if !strings.Contains(frame, `No conversations match "xyz"`) || !strings.Contains(ansi.Strip(rows[1]), "/ xyz") { + t.Fatalf("%s: the empty filter:\n%s", name, frame) + } + clears := 0 + for _, hit := range hits { + if hit.kind == wallHitAction && hit.arg == int(wallActFilterClear) { + clears++ + } + } + if clears != 2 { + t.Fatalf("%s: %d Clear buttons, want the filter row's and the message's", name, clears) + } + v.filter = "" + rows, _ = renderWall(pal, v, sz[0], sz[1]) + if !strings.Contains(wallPlainFrame(rows), "No open conversations in port") { + t.Fatalf("%s: the empty team:\n%s", name, wallPlainFrame(rows)) + } + } + } +} + +// THE WALL IS WHAT IS OPEN IN THIS WINDOW, and a team's members that are not +// open here are one quiet word button on the title, never tiles: `2 more in +// port · Open them`, with its key on the hint line, and no mark at all when +// every member is open (the emptiness law). +func TestWallTitleOffersTheTeamsMembersNotOpenHere(t *testing.T) { + pal := newPalette(tokens.TrueColor, false) + v := wallUnmarked(wallFixture(6)) + v.away = 2 + rows, hits := renderWall(pal, v, 180, 50) + title := ansi.Strip(rows[0]) + for _, want := range []string{"open in this window · in port", "2 more in port · Open them", "6 open"} { + if !strings.Contains(title, want) { + t.Fatalf("title %q lacks %q", title, want) + } + } + var hit *wallHit + for i := range hits { + if hits[i].kind == wallHitAction && hits[i].arg == int(wallActResume) { + hit = &hits[i] + } + } + if hit == nil || hit.y0 != 0 { + t.Fatalf("Open them is not a target on the title: %+v", hits) + } + if got := ansi.Strip(ansi.Cut(rows[0], hit.x0, hit.x1)); strings.TrimSpace(got) != "2 more in port · Open them" { + t.Fatalf("the target covers %q", got) + } + hv := v + hv.hover = hit.ref() + hrows, _ := renderWall(pal, hv, 180, 50) + if hrows[0] == rows[0] { + t.Fatal("the button takes no ground under the pointer") + } + if bar := ansi.Strip(hrows[len(hrows)-1]); !strings.Contains(bar, "Resume the 2 not open here · r") { + t.Fatalf("hint line %q", bar) + } + v.away = 0 + rows, _ = renderWall(pal, v, 180, 50) + if title := ansi.Strip(rows[0]); strings.Contains(title, "more") || strings.Contains(title, wallResumeWord) { + t.Fatalf("every member open, yet the title offers more: %q", title) + } + // Narrow, the name goes from the button before the button goes. + v.away = 2 + rows, _ = renderWall(pal, v, 80, 30) + if title := ansi.Strip(rows[0]); strings.Contains(title, "in port · Open") { + t.Fatalf("80 wide keeps the long button: %q", title) + } +} diff --git a/internal/tui3/welcome.go b/internal/tui3/welcome.go index 0cf5206e97..3f91ffe5e4 100644 --- a/internal/tui3/welcome.go +++ b/internal/tui3/welcome.go @@ -1053,7 +1053,7 @@ func (a *app) welcomeUnit(width int) ([]string, []welcomeMark, int, int) { // nobody had spoken in yet went onto the screen in the clear. block, x, row := a.secretDraftBlock(unit) if block == nil { - block, x, row = draftBlockWithTags(&a.input, pal, unit, box, "", a.roomLead(unit), a.input.demotedTags, a.draftInk()) + block, x, row = draftBlockWithTags(&a.input, pal, unit, box, a.trafficHint(), a.roomLead(unit), a.input.demotedTags, a.draftInk()) } caretX, caretRow = lead+x, len(rows)+row for _, line := range block { diff --git a/internal/tui3/workfold.go b/internal/tui3/workfold.go index b4fcd032d1..877d6c9825 100644 --- a/internal/tui3/workfold.go +++ b/internal/tui3/workfold.go @@ -269,6 +269,12 @@ func deriveWorkfolds(es []entry, runningTurn int) map[int]workfold { if es[i].kind == entrySeam { blocked = true } + // NOR IS A MANAGER'S QUESTION TO ITS TEAM. Its answers land under + // it after the turn has ended (teamthreadcard.go), and a chip that + // swallowed the card would hide the one place they arrive. + if es[i].kind == entryTool && es[i].tool == "team_send" && es[i].status == toolOK { + blocked = true + } } // THE END OF WHAT THE CHIP SWALLOWS. An ordinary fold stops at the answer // and leaves it standing; a stopped turn's fold runs to the end of the