239d951b8cd6ccbf20e7c7e3e94702972e0e3ed2
6
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
b1dbf3ed75 |
(4e4d88d) Split and search the campaign picker, and bump to 0.24.2
One flat list ordered by title put the completed campaigns among the open ones forever. The tail only grows, so on a board that has run for a while the campaigns worth picking were pushed towards the bottom of the box and eventually off it, and nothing in the picker helped find one. The rows are now two sections, open above completed, with completed by Created At newest first and truncated to a couple behind a grey line naming how many older ones are hidden. `/` starts a query, the key that already searches the board's cards, filtering case insensitively on short id, codename and title, and a query turns the truncation off: the campaign a reader is searching for is exactly the one it hid. `picker_list` is the one place that decides what a row is, so `Picker::row` counts drawn rows and `stepped_picker_row` walks past the headings and the truncation line rather than stopping on one. The highlight is placed by uuid, the answer `Tab::campaign` already gives for the filter, so typing, clearing the query and a tick that finishes a campaign all move it with its campaign instead of leaving it at a number that now names another. Every campaign's standing is settled at reload, counted by `standings_of` in one pass over the cards the reload already holds rather than the walk per campaign `campaign ls` pays. `Tab::standing` goes with it: the frame reads the row's, since two counts of one number are two numbers free to drift. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
cbc20848f6 |
(1845355) Order each status column by its entry stamp, and bump to 0.23.0
Every view read its rows out of `collect_ticket_items`, which sorts by `by_priority_then_title` because it sees one directory and no status. That is the right order for the backlog, where priority is the clock. Past the backlog the question changes: committed asks what has waited longest, reviewing what was handed over first, done what just landed. All four columns answering the first question is why a finished p5 sat above the p1 nobody had read yet. So each column takes its own order, through one `by_status_order` keyed on the `Status` rather than four comparators at four call sites. Backlog delegates to the comparator it already used. Committed sorts by `Committed On` ascending and reviewing by `Submitted On` ascending, so the longest wait is at the head where the reader picks next from; done sorts by `Completed On` descending, newest first, the way a changelog reads. Ascending twice and once descending is one rule said three ways: the head of every column is what the reader acts on next. A ticket carrying no stamp sinks below every stamped one in its column and falls back to priority then title among its own kind, as do equal stamps -- `mv` writes whole seconds, so a tie is real. A missing time is unknown, not ancient, and unknown must not claim the head of a queue ahead of a wait somebody can point at. Reading absence as the epoch would have come free from the comparison and put every ticket filed before f460853 first. The comparison is a string comparison. `%Y-%m-%d %H:%M:%S` is lexicographic in chronological order, the property `Due` already relies on, so nothing parses a date at sort time. The stamps are read on the pass `collect_ticket_items` already makes over each file, the rule `criteria` and `tags` already hold, and never per comparison. Both `cmd_ls` branches, `list_ids`, `columns_of` and `campaign::members` take it, which is why those loops walk `Status::ALL` rather than `status_dirs()`: the directory name does not say which stamp governs it. The merge tab keeps priority then title outright and is pinned there -- it spans statuses, so no single stamp governs it. `cmd_tags` is left alone; it counts into a `BTreeMap` and never reads an order. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
528566d103 |
(61879a4) Surface campaigns on the board, and bump to 0.20.0
A card label and a frame, not a campaign tab. A tab had to say what its columns are, and a campaign groups across the flow rather than within one status, so the answer is the four columns filtered: a filter on the board it already has, not a fifth tab. So a card names its campaign on the label row, before the tags, marked ~ and bold, and the row drops the tags whole before it drops the campaign. `c` opens a picker; taking a campaign filters every column to its members and draws a frame above them carrying the id, the codename, the name, the opening line of the description and the standing. The standing comes from the columns, since while a campaign is selected the columns are its members. `q` takes off one layer at a time: the overlay, the filter, the board. The label needs something to say, which the stored uuid is not, so campaigns gained `Codename`: one word, `v1` or `beaver`, written by `campaign add --codename` and validated at parse time. `campaign ls` prints it and `resolve_in` gained an exact-codename tier above the uuid prefix, or it would be a field you can read and cannot type. Only campaigns carry the field, so the tier is empty for a ticket and ticket resolution is unchanged. The campaigns index is read once per project in `columns_of`, on the pass that already builds the cards, and `digest` now watches the campaigns directory: without it a campaign filed elsewhere never reached the picker. `frame_rows` grew a row, so the two bools deciding the geometry became one `Chrome` and the row indices are named. Left out and filed as d637288: nothing can give a codename to a campaign that is already on the board. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
73ffcad733 |
Reformat with cargo fmt, and nothing else
Layout only, no behaviour and no wording. 161 hunks across 22 files, 98 of them rustfmt joining a call or a message onto the one line it fits on. The config it formats to, and how its four numbers were arrived at, is the commit before this one. Separate so that it is reviewable by not being read: nothing here is a decision, and every decision is next door. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
ece201e3ab |
(6ce2c47) Mark each relation with the status of the ticket it names
The Relations block named each target and said nothing about where it was, so the question actually asked of it, whether a blocker is finished, meant closing the overlay and going to find the other ticket. Each row now carries a mark for its target's status, ahead of the id, where it describes the target rather than the row. A rising bar, U+2581 through U+2588 for backlog to done, and ? for a target the board no longer holds. Not a circle: the cards spend those on the priority meter two cells from nothing at all, and another circle would be read as a level. The ramp is also the meaning, so the shape says which status it is. The colour could not. Every colour in the guideline already means one thing and the eight tag slots are reserved, so four status colours could only have come out of something else's meaning. So the shape carries the status and the colour says only that it is one: orange, which is what Status already means, and grey on the missing mark, beside the _missing_ that grey already spells. An unrecognised status reads as missing rather than as a fifth stage, and every_status_has_a_mark pins the pairing against status_dirs so a status added later fails a test instead of quietly reading as ?. The plain text was the real cost. Detail.text was one String drawn by a Paragraph, deliberately uncoloured because an escape sequence there is drawn as literal bytes, which is 6d327df. So the block cannot arrive pre-painted. Resolved.relations is now rows, content_parts returns the body as BodyPart::Text and BodyPart::Relations with the text painted and the rows untouched, and the two renderers take it from there: content_trim paints the rows into escapes, and the board styles the same cells as spans. One builder, two painters. relation_rows decides which edges there are, what they are called and which direction leads; relation_cells decides the layout, the mark and the colours; paint_cells and span_of are the only things that differ. Cell is the unit both take, the same shape the palette uses to stop a colour existing for one renderer and not the other. reference_cells is now the one spelling of a cross reference, shared with the Campaign field. Detail.body is a ratatui Text and is the only thing measured, so last_offset and the Paragraph cannot wrap the body two ways. Detail::plain() flattens it for the suite and is cfg(test): a second representation carried beside the spans is a second thing to disagree. show carries the same mark, decided here rather than discovered later. The rows are one builder so it was free, and two views disagreeing about what a relation shows is a difference nobody can explain afterwards. That is a change to what the CLI prints, so the minor goes on the last commit of this pair. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
5b0bac9c2d |
(7bfb9fc) Add campaigns, a ticket container assigned through worklane assign, and bump to 0.12.0
There was no way to group the tickets that have to be finished together. A goal such as a v1 release was either one ticket that could not describe its parts, or a set of tickets with the goal restated in every description and nothing tying them together. A campaign is a file of its own under `.worklane/campaigns/`, with a title, a description and metadata, and it sits in no status directory. Its state is derived instead: open until every member is done. Deriving it means there is no such thing as a done campaign holding an open ticket, and no second forward-only ruleset beside `mv`'s. An empty campaign is neither open nor done, since calling it done would make a container nothing has been filed against the most complete thing on the board. Membership is one field on the *member*, Campaign in the ticket Metadata, written only by `assign`. The member list is deliberately not on the campaign: that would put membership in two places and make one file that every assignment edits, contended the moment two agents share a board. So `add` gains no `--campaign` and neither does `set`. `add` does not write the field either. Every ticket written before campaigns existed has none, so the insertion path has to exist regardless, and leaving it out of `add` means one path that is always exercised rather than two. That is the Relations argument from 4179958, applied to a field instead of a section. `set_or_insert_metadata_field` is the upsert and `METADATA_ORDER` is its anchor list, the way `SECTION_ORDER` is `ensure_section`'s, so Campaign lands beside Status rather than at the end and Status stays last. A file with no Metadata heading is an error rather than an insertion, per 641e3d5. The three tiers came out of `resolve_ticket` into `resolve_in`, shared by both kinds. A campaign is addressed exactly the way a ticket is, and a second resolver would be a second copy of the precedence rules to keep in step. Two things fell out of that. `Found.dir` is the status for a ticket and empty for a campaign, which is what drops the bracket from the ambiguity listing for one. And `resolve_ticket` can now explain a search that names a campaign, so `mv`, `show`, `chown` and everything else that takes a ticket give the same reason instead of a bare "no ticket found" — one place rather than a check per command. Only on the zero-match path, so an ambiguous ticket error is never replaced by a complaint about a directory the caller never mentioned. The stored value is the full uuid, per the same rule the Relations section follows, and the title is resolved for display. `reference_cell` is now shared between the two, so a dangling campaign and a dangling relation target are both `_missing_` rather than each inventing a spelling. `Resolved` carries what `content_trim` cannot render from the file alone: a struct rather than two more parameters, so the next such field is one entry instead of an edit at every call site. `campaign show` lists done members, unlike `ls`, which leaves the done column out of its listing. What is finished against what is left is the whole question a campaign asks. `ls --campaign` is the other way round and keeps every rule `ls` already has. Deliberately out of scope. The derived progress figure is 1cb999f, now recorded as blocked by this, since nothing here can compute it yet. Unassigning needs a field cleared back to unset, which is 74904dc. And the board gets neither a campaign tab nor a card marker: the detail view resolves the field because it renders the body, and that is all. A marker would want a read per reload and the four corners are already spent, which is the b8ce18c reasoning; filed as 61879a4. Twenty-four integration tests and eleven unit tests, covering assign, reassign, the no-op, a dangling campaign, the ls filter, `mv` refusing a campaign, insertion placement, and a handwritten section and unknown metadata field surviving an assignment verbatim. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |