72dbdec2ec24ccc31503cfe5a531bf0f0f227b00
22
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
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> |
||
|
|
88918b2f8a |
(c628759) Show a page indicator on the detail overlay's border, and bump to 0.16.1
The overlay has scrolled since 1b78a24 and nothing said where you were: a long ticket opened looking exactly like a short one, so the only way to learn there was more below was to press pgdn and watch whether anything moved. `pg 2/8` now sits on the bottom right of the border, through `Block::title_bottom` with a right-aligned line, which spends no text row. That is the trade the title already makes on the top border, and the two cannot crowd each other because they are on opposite borders. Both of the things this had to get right are arithmetic. `wrapped_height` is now the one measurement: `last_offset` is it less the viewport and `page_indicator` takes the same two numbers, so the clamp and the indicator cannot disagree. A second `line_count` call would be a number free to drift, and an indicator claiming there is more to read where the scroll refuses to move is worse than none. The furthest offset is the last page by definition rather than by division. The clamp stops at the wrapped height less the viewport, which is not a page boundary, so the final screenful is partial and dividing reads `pg 2/3` at the bottom of the ticket. The pages are counted in `scroll_step`, a screenful less the overlap line, because that is the step the keys take: counting whole screenfuls names a page pgdn cannot land on, and puts a 30 row ticket in a 10 row viewport at `pg 3/3` two rows short of its end. Grey, the colour the footer keys and a rendered checkbox take, since this says where you are in the ticket rather than anything about the ticket. Dropped whole on an overlay too narrow for it and absent entirely when nothing scrolls, the rules a corner and the tags row already follow. `page_indicator` is four numbers in and an `Option<String>` out, so the arithmetic is pinned without a terminal. The drawn tests answer the two things it cannot: which border it landed on and what colour it reached the screen in. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
ae3ee1bb9e |
Show the target's status beside the relation kind, and bump to 0.15.2
A row now carries two marks, kind then status: what sort of edge this is, then
how far the ticket at the other end has got. `blocked by × ◐ (6ce2c47) Title`.
Two questions are asked of this block, which rows hold this ticket up and
whether the ones that do are finished, and one glyph could not answer both.
○ not started, ◐ under way, ● finished, in grey, orange, cyan and green: the
shape says how far the target has got and the colour tells the two middle
stages apart, since committed and reviewing are both half circles. Green is the
colour the priority ramp deliberately leaves out because it means a title; on a
one-cell mark with no title behind it nothing else wants it, and it is the
obvious colour for done. Orange keeps the meaning it already has, Status.
These are the priority meter's own circles, and what keeps a status from
reading as a level is width: the meter is always two cells, a status mark is
one. the_status_mark_is_one_cell_where_the_meter_is_two pins both halves, and a
card carries the meter and never a status mark while the block carries the
status mark and never a meter.
The kind mark survives a target the board cannot find and the status mark
cannot, since a kind is read from the ticket's own file and a status from the
board. ? holds the column so the id does not move when one target has gone, and
_missing_ is what says it is gone.
Committed and reviewing are told apart by colour alone, so a pipe cannot tell
them apart: both read as under way. Accepted, since ● and ○ are the two answers
usually wanted and show on the target settles the rest, and assets/SKILL.md now
says so outright rather than leaving an agent to work it out from a colourless
half circle.
RelationTarget is back, carrying the title and the status in one Option because
they come from the same lookup. It went out in
|
||
|
|
5ae9c7fe00 |
Mark a relation by its kind rather than its target's status, and bump to 0.15.1
A column of ▁▄▆█ read as undifferentiated blocks. What is worth seeing at a glance is which kind of edge a row is: × for blocked by and blocks, → for relates to, ← for regression of and regressed by. The labels are five long words that blur when one ticket carries several, and the rows holding it up are now the crosses. Both directions of a kind carry one mark, since blocked by and blocks are the same edge read from two ends and the label is what says which end you are on. × is BLOCKED_MARK, the constant a held-up card already draws, in the same brightred. On a card it says this ticket is held up, in the block that this edge is what holds one, which is one word, so one glyph and one definition: the constant moved to util.rs, where both renderers can reach it. Brightred rather than the red asked for, because the id one cell to the right is red and the two would have blended. The arrows are the ones the footer already draws, so they render wherever it does, and no_relation_mark_is_a_priority_glyph pins all three against every level of the meter: the circles belong to priority. The mark now survives a target the board cannot find, because a kind is read from the ticket's own file rather than from the board. Only the name is gone, and `_missing_` in grey is what says so. That is one case fewer than the status mark had, which needed a `?` for a target with no status to show. What this gives up is the status: 6ce2c47's motivation was reading whether a blocker is finished without leaving the overlay, and nothing in the block shows that now. Its criteria 1 and 3 describe the commit before this one, and the ticket says so. RelationTarget went with it. Nothing read the status field once the mark stopped keying on it, and a field written but never shown is a field that goes stale unnoticed, so RelationRow carries the kind and the title and the status is one lookup away on the index if a later ticket wants it. A patch, not a second minor: 0.15.0 was the arrival of a mark and settling which glyph it is belongs to that, where a second minor would read as two features. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
ce32b42ae4 |
(dbf7b61) Guard the overlay's relation colours, and bump to 0.15.0
The mechanism arrived with 6ce2c47, as this ticket said it would: the block is
laid out once as cells, the id carries the red the guideline gives a uuid, and
the board turns the same cells into spans. So the id is red in the overlay
without anything here asking the terminal for a decision, and the three
criteria about what is drawn were true the moment
|
||
|
|
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> |
||
|
|
0ce3fdb246 |
(0546fc5) Copy the selected id with y in the tui, and bump to 0.13.7
The board is where a ticket is found and the CLI is where it is acted on, and the only thing joining them was seven characters retyped off the screen. y reads as yank to the readers a keyboard board is for, and was the letter left after q, esc, enter, space, hjkl, the arrows, pgup, pgdn, tab, backtab, d and / took theirs. The mechanism was chosen against ssh, which is where a board is often read. OSC 52 crosses the connection, because it is the terminal at the reader's own end that owns the clipboard. A crate wants X11 and Wayland libraries at build time and, on X11, hands the selection to the process that set it: copy an id, quit, and the paste buffer is empty, which is precisely the flow this key exists for. Shelling out to wl-copy, xclip or pbcopy is platform sniffing plus a spawn, and does nothing where none of them is installed. crossterm 0.28 is what ratatui 0.29 pins and ships no clipboard command, so the sequence and its base64 are twenty lines in src/clipboard.rs, pinned on the RFC 4648 vectors. The cost is recorded rather than hidden, in AGENTS.md under The Copy Key: a terminal that ignores OSC 52 ignores it silently, and tmux needs set-clipboard on. What clipboard::copy reports is whether the sequence was written, and the footer says no more than that. There is no reply to read either, since the query form is refused by most emulators. What is copied is ticket.id, the seven characters the card already prints and every command already resolves, decided by Board::copy_text so the string is a question the suite can ask without a clipboard. None on an empty column: an empty string would take away whatever the reader had there and give nothing back. The project is left off even on the merge tab, since a second word would have to be deleted out of every paste. Board::copy_selected_id takes the clipboard as an argument, clipboard::copy from the dispatch and a closure from a test, which is what makes the hit and the refusal both drivable. A failure is said in the footer rather than returned: there is nobody above it to handle one, and an error swallowed there would look exactly like a copy that worked until the paste came out wrong. Notice is the board's first channel for saying something in words, and it has to be, because a copy leaves nothing on screen to look at. failed means nothing reached the clipboard, so an empty column and a refused write are one answer to the reader, both in brightred like the search's no match. It takes the whole footer row, since a message squeezed in beside the keys would move every key in it. Cleared by the next keypress rather than on a timer: no clock on the board, no wakeup in the loop, and never in tick, which runs four times a second. clear_notice goes ahead of search_key as well as the arms, because a key typed into a query is still a key. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
37dbd722e0 |
(3b16540) Open a search with / in the tui, and bump to 0.13.6
Finding a ticket meant scrolling four columns and reading, which is what the id and the title are for. The real work was the input mode: every key in the dispatch was a single-shot action, and a query needs one that swallows the keys bound to them. That is Board::search_key, offered every key ahead of the action arms and reporting what it took. With no prompt open it takes nothing, so every other state's dispatch is unchanged. On Board for the reason dismiss is: the arm is not reachable from a test. ctrl-c is the one key the prompt declines, since a terminal application always honours it. Every other control combination is swallowed and does nothing: it must not type its letter, and it must not fall through either, because the action arms match on the code alone and ctrl-d would reach the arm bound to d. first_match runs over every card in the visible columns, in reading order, not the rows on screen: a query that answered differently on a tall terminal and a short one is not a search, and the jump scrolls the match into view. A hidden done column stays out, or the highlight would land on a ticket that is not on the board. Id and title only, both lowercased. The jump goes through select_at, extracted as the tail select_card already used, so follow_selection scrolls the match's own column and refresh_detail keeps an open overlay on it. Nothing calculates either a second way. A hit closes the prompt; a miss keeps it open, marked in brightred beside the query it is about, with the selection untouched, so the query can be corrected in place rather than retyped from /. The mark clears on the next edit. An empty query matches nothing rather than everything. The prompt takes the whole footer row, since the key list it replaces describes nothing that works while every key goes into the buffer. The real terminal cursor sits after the query: ratatui shows it only for a frame that asked, so it is also what says "you are typing" on an empty query. Both closed footers now name / search. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
4502de7ee3 |
(e7612de) Close the detail overlay on q instead of quitting, and bump to 0.13.5
q set should_quit outright, so a reader who pressed it to put a ticket away lost the whole board instead. That is not what q means anywhere else that lays a document over a list, and esc two arms below already did the right thing. The rule is Board::dismiss: close what is open, quit when there is nothing left to close. On Board rather than in the match arm because the dispatch in main.rs is not reachable from a test, so a rule written there is a rule nothing can check. q and esc now share one arm, since two arms carrying one rule is how a later edit changes it for one key and not the other. The footer is the other half. Its last slot answers the same question in both states, how to get out, and with a ticket open the honest answer is ctrl-c: it is the only key left that quits in one press. Going on saying q quit there would be 1b78a24 in the other direction, a footer describing a key by what it used to do. The close entry names both keys as enter/q close rather than repeating close twice. Criteria 3 and 7 live in a dispatch no test can reach, so the_dispatch_gives_q_and_esc_one_arm_and_leaves_ctrl_c_quitting scans main.rs for them, over whitespace-collapsed source so rustfmt cannot fail it, the way util.rs is already scanned for colour_text callers. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
a16169ce8c |
(b8ce18c) Show a blocked marker on the tui card, and bump to 0.13.4
A ticket held up by an open blocker looked exactly like one that is ready, and the board is where the next thing to pick up is chosen. The mark is × in brightred, after the short id. Not a fourth Geometric Shapes glyph: those are the priority meter's, two cells away, and another circle there reads as part of that ramp. × is Latin-1, like the middle dot the unset priority draws, so it renders wherever the meter does. After the id rather than before it, because ahead of it the mark would push every id in the column out of line whenever one card was blocked. It is measured before the project label and the due date, so both give way to it: those are context for a ticket somebody can start, and this is the one thing on a card that says not to. Dropped whole when the row cannot hold the identity and the mark together. No scan of the board per tick was needed after all. collect_ticket_items also reads the ticket's own uuid and the targets of its blocked by lines, off the file it is already holding, and mark_blocked walks the four columns once for a uuid-to-status map and once to answer every card. The flag is on Card rather than TicketItem: the answer is about two tickets at once, so no card can reach it alone, and it is settled at reload the way project is. The merge carries each card's flag from the board it came from. relate resolves its target inside one .worklane, so a blocker in another project is not a relation anything can record, and recomputing over the merged columns would let one project's uuid match another project's ticket. project_label now takes the width the row has actually spent, measured off the spans, instead of adding up the widths those spans are supposed to have. The hand-written sum left out the space after the priority mark, so a cut label was handed one cell more than the column had. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
7a0dd625ce |
(1e7b1a9) Colour a tag by its name, and bump to 0.13.2
FNV-1a over the tag bytes into an eight-colour reserved palette, so the same tag is the same colour on every card and on every board with nothing stored. The hash is written out rather than taken from std, whose output is not promised stable across releases. The index is multiply-shift, not `% len`. The length is a power of two, so a modulus keeps the low three bits of the hash, and FNV-1a's low bits carry only the low bits of the input bytes: nothing moves information downwards. Every pair of tags differing above bit 2 landed in one slot, `bug` and `BUG` among them. It looked like a good palette, two colliding cards in sixty-four on this board, because the vocabulary had been folded into a handful of slots. Using the whole hash gives 14/64, which is the real arithmetic for eight colours. The palette is reserved as a list and disjoint from the seven colours that already mean something: a tag in red reads as a uuid, in green as a title. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
91bbc19c32 |
(e41802b) Show a ticket's tags on its tui card, and bump to 0.12.1
The Tags field was invisible on the board: a card carried the mark, the short id, the due date, the owner and the criteria count, and nothing said a ticket was tagged bug without opening it. TicketItem gains a tags field, filled in collect_ticket_items through parse_tags where the file is already being read, for the reason the criteria count is: the board draws them on every card, and asking per card would re-read every ticket body on every draw. parse_tags splits the comma-separated field into whole trimmed values, so a caller asking for bug is not answered by bugfix, and reads absent, _None_ and empty as one answer. That is step one of 2f3796e5, lifted here because the board cannot read the field before it exists. The row sits under the title, dimmed like the owner and the count, each tag prefixed with # so it does not read as a third line of the title. It is dropped whole when the column will not hold it, the rule a corner follows, and an untagged ticket spends no row at all. 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> |
||
|
|
3085b0226f |
(4179958) Add a Relations section for blocked by, regression of and relates to, and bump to 0.11.0
`relate` is the only writer of the section, the way `chown` is the only writer of Owner: a relation names a target that has to be resolved to a uuid first, so `set` and `append` are deliberately kept out of it. One flag per kind, so an unknown kind is a usage error rather than a line refused on the way back out. One direction is stored and the inverse is derived by a scan. `blocked by` goes on the gated ticket, whose move `mv` now refuses while the target is not done, naming every open blocker; `-f` bypasses it beside the backward and skipping moves. A target that is not on the board warns and allows the move. The rendered block is built outside `content_trim` and passed in, since half of it comes from other tickets. The section is created on demand rather than by `add`, so a ticket written before it existed gains it without being regenerated. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
e6fe51e31e |
(996afd7) Monitor several boards in the tui as tabs, and bump to 0.9.0
`worklane tui` takes any number of paths, each resolved to the first `.worklane` at or above it the way the working directory always was. With more than one board there is a tab per project plus an `all` tab merging them, and `tab`/`shift+tab` between them. The selection moves onto `Tab`: sharing one column and card index across projects would point it at whatever unrelated ticket sat in the same place. The merge is sorted through `by_priority_then_title`, now exported, rather than concatenated, so its order does not depend on the order of the arguments. On the merge a card and the overlay border name the project after the id, since across boards seven characters of uuid are not an address. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
c606b5ba43 |
(4edc7fa) Lay the tui card out as corners, with a due date and a criteria count, and bump to 0.8.5
A card was three left-aligned rows: mark and id, one row of title, then owner
and due as prose. The title got one row, so worklane's own titles, routinely
longer than a quarter of a terminal, were cut mid-word with nothing to say so.
The due sat at the end of the bottom row where nothing drew the eye to it, and
nothing showed how far along a ticket was.
●◐ (1b78a24) 2026-12-31
The tui detail view cannot
scroll, and the footer says…
Ansho Rei [3/9]
The title takes one row or two, wrapped on spaces, ellipsis when even two are
not enough, one row when one is enough. A card's height therefore depends on the
column's width, so `card_lines` and `card_height` take it, and `column_areas` is
now shared between the draw and `follow_selection`: `Ratio` hands its remainder
column to whichever slot it likes, and reproducing that arithmetic by hand is
how a measurement and a draw come to disagree about where a card starts.
A corner that will not fit is dropped whole rather than truncated or moved to a
row of its own. Half a date reads as a different date, and a card that reflows
in a narrow column changes height, which the scroll would then have to chase.
The left corner is the ticket's identity and always stays. Checked by eye at
120, 76 and 52 columns; at 52 the due goes and the count still fits.
The criteria count is a field on `TicketItem`, filled in `collect_ticket_items`
where the file is already being read, so a rescan pays for it once rather than
every draw re-reading every ticket body. Counted through `criteria()`, so a
checkbox in a description is neither counted here nor numbered by `show`, and
`None` rather than `[0/0]` when a ticket has none.
`due_date` cuts a due value back to its date only when it has one. The field is
not validated, see daa0e79, so it holds whatever was typed; taking the first
word regardless would turn "next friday" into "next". A set due is now the
timestamp colour per the colour guideline, which is what makes the corner worth
looking at, and an unset one stays grey like everywhere else.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
|
||
|
|
580e3cf7f0 |
(0721739) Show the ticket id and title on the detail overlay's border
The modal named nothing. It showed a description, criteria and a metadata table belonging to a ticket whose title is nowhere in the text, because content_trim drops the `# ` heading on purpose: `cmd_show` prints it. The card behind the overlay carries it, but the overlay covers most of the board, and the seven characters of id in the metadata table were the only thing identifying what was open. The id and the name now sit on the block title, `(1111111) · First one`. The id goes first because that is how every other view addresses a ticket, and both sit on the border rather than at the head of the paragraph, so reading to the end of a long ticket cannot carry them off the screen. The string is cut here rather than left to the renderer, which truncates an overlong block title at whatever cell it reaches and would take the id with it. Cut against the inner width, the id survives whole and the name ends in an ellipsis where it was trimmed. `Board::detail` is now a `Detail` carrying the title, the id and the text, since the title has to travel beside the body rather than inside it. Written in an opencode session, lost from the working tree to a `git checkout src/tui.rs` that Claude ran to drop a scratch test, and recovered from the opencode snapshot store. The diff is unchanged from what was written, bar one rebase conflict where both sides had added a test helper in the same place. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
2298d3373a |
(8528c50) Hide the done column in the tui until d asks for it, and bump to 0.8.2
Done only grows. It already holds more tickets than the other three columns
together, so a quarter of the width was going to the column least often read
while the ones being worked got squeezed for it.
Not a new opinion: `ls` already counts done in its summary and leaves it out of
the listing below. The board now does the same, and the footer carries the
count while the column is hidden, which is the board's version of that summary
line. It reads `d show done (17)` while hidden and `d hide done` while shown,
so the count only appears where a column heading is not already carrying it.
The modal footer names the key too, since it works with a ticket open.
Hiding is a change to what is drawn, never to what is read. `reload` still
scans the done directory and `digest` still watches it, so the count is right
and revealing the column needs no rescan.
`visible()` returns a prefix of the columns rather than a filter, which is what
keeps `column` and `offsets` valid as indices into either. It is derived from
where DONE actually sits rather than assuming the last slot, and a test pins
done as last: a status inserted after it would otherwise hide two columns in
silence. DONE is now a constant, since `ls` and the board are two readers of
the same rule.
Hiding the column under the selection moves the selection to the last drawn
column and closes an open detail view. Refreshing the modal onto whichever
ticket the selection landed on was the alternative, and it swaps what someone
is reading without saying so, which is how a person acts on the wrong ticket.
Showing done again is a no-op for the selection, since a column is appended
rather than inserted.
Three existing tests asserted a column heading with `screen.contains("done
(0)")` over the whole render, and the new footer holds that string whether the
column is drawn or not, so all three passed for the wrong reason the moment
done was hidden. They now assert against the top border row through a
`headings()` helper, with `footer()` beside it.
The choice is not remembered between runs: worklane has no config file, and one
flag is not a reason to start one.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
|
||
|
|
220789efea | (6b8f4d13) Scroll the tui board columns with the selection, and bump to 0.7.2 | ||
|
|
c1137f29cf |
(1b78a24) Scroll the tui detail view on pgup and pgdn, and bump to 0.7.1
The detail view had no scrolling at all: no offset on Board, nothing passed to Paragraph::scroll, so anything past the height of the overlay was unreachable. Every ticket in this repo is longer than that. The footer read "↑↓ scroll" while up and down moved the selection, so it named a key that did nothing and sent the reader looking for their own mistake. The scroll goes on pgup and pgdn rather than taking up and down. Up and down stay on the selection with the modal open, so a whole column can be read without closing it and the modal follows the selection. That is worth more than the two keys. The offset is clamped against the wrapped line count from Paragraph::line_count, which is why ratatui now carries the unstable-rendered-line-info feature. The paragraph wraps on words, so a clamp on the raw lines would stop short of the end or run past it into blank space, and counting the wrapping by hand would only agree with the widget until one of the two changed. The clamp runs on the keypress and again in the draw, since the terminal can be resized between them and a tick can shorten the ticket under a reader who is already at the end. The offset resets when the selection moves and when the modal is closed, so a ticket opens at its top. It deliberately does not reset on a tick: an edit elsewhere in the tree must not throw the reader back to the top of what they are reading. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |
||
|
|
78831f1a39 |
(f6af387) Add the board view, and bump to 0.7.0
worklane was one-shot commands only, so reading the board meant running ls again and again and nothing ever showed the four statuses side by side, which is the one view a kanban flow is for. Four columns, a card per ticket carrying the priority mark, short id, title, owner and due. Arrows or hjkl to move, enter for the detail view, q to quit. Read only: moving a card by keypress is a follow-up, kept out until the watch and render loop were solid. Modelled on frig throughout, same crates and same shape: event poll on a 250ms timeout so the tick runs when nobody is typing, a panic hook that leaves the alternate screen before the backtrace, and the terminal restored on the error path as well as on quit. A bare worklane opens it, as a bare frig does, so Cli::command is now an Option. The watch looks at files, not directories. A directory's mtime only moves on create and rename, so a ticket edited in place would be missed; the digest hashes every ticket and comment file's path, length and mtime. Comment files are in it because a comment added elsewhere has to reach the detail view. It guards the rescan rather than the draw, since ratatui diffs its buffer but reading the tree every frame would not be free. notify is deliberately not a dependency, and the reason is on the ticket. Two orderings are deliberate. The worklane directory is looked for before the terminal, so running outside one gives the usual message rather than a complaint about the tty, and both errors stay testable without a pty. And a missing tty is refused by name, since raw mode on a pipe fails with a bare "No such device or address" that explains nothing. The palette is now a Color enum rather than a string, so the escape the CLI writes and the ratatui colour the board draws come from one definition and a colour missing from either is a compile error. That retires the test which existed only to catch a name with no entry, the failure that once left magenta undefined. Cards come from collect_ticket_items, so there is no second parser; TicketItem gained the path the detail view opens. content_trim and format_comments_with take the colour decision, because ratatui draws spans and would print an escape as literal bytes. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> |