bdtui 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -4,6 +4,35 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.7.1] - 2026-06-21
+
+### Fixed
+
+- The **Keybindings** (`?`) help can now be dismissed after a mouse click moves focus to the Beads list or Detail pane. Its close keys were bound to the help box itself, so once a click stole focus the modal became unclosable (every global key is suppressed while a modal is open). `q`/`Esc`/`h` are now bound at the screen level and dismiss it regardless of which pane holds focus.
+- Reopening the Keybindings help with `?` works again. `?` is now a single open/close toggle, fixing a re-entrancy where the freshly-registered `?` close handler fired on the very keypress that opened the modal and slammed it shut.
+- The boot status bar no longer shows the `? help` hint twice. `setStatus` already appends it, so the redundant hint baked into the "Ready" message was removed.
+
+## [0.7.0] - 2026-06-21
+
+### Added
+
+- `Shift+r`: reset all narrowing filters (title search, epic scope, type) and reload fresh.
+- The status bar now summarizes every active narrowing filter together — e.g. `"login"  ·  epic: bd-12  ·  type: task — 3 results | Shift+r to reset` — instead of only the most recent one. The epic filter now shows the same result-count/reset hint that title search did.
+- The tab bar gains a persistent `search:` indicator for the active title filter, alongside the existing `type:` and `epic:` indicators.
+
+### Changed
+
+- `r` (reload) now **keeps** active filters instead of clearing the epic filter; use `Shift+r` to clear filters. This reverses the `0.5.0` behavior where `r` cleared the epic filter.
+- The `/` title filter is now persistent state: it survives a reload (`r`) and composes with the epic and type filters. The prompt pre-fills with the current search, and submitting an empty value clears just the title filter.
+
+### Fixed
+
+- `Shift+c` (claim) and `Shift+g` (jump to bottom) now actually fire. They were registered as bare uppercase `C`/`G`, but blessed reports a shifted letter as `S-<lower>`, so the handlers were dead — claim did nothing and `Shift+g` only reached the last *loaded* page instead of revealing all rows and jumping to the true bottom.
+- Reloading or filtering while scoped to an epic on the **All**/**Closed** tabs no longer caps the fetch at bd's default 50 rows, which could drop an epic's children from the scoped view.
+- The title search is now tag-escaped before it reaches the status bar, so a query containing `{`/`}` no longer corrupts the status line.
+- Reparenting with `h` no longer throws `Unexpected token '✓' … is not valid JSON`. `bd dep add`/`bd dep remove` print a human-readable line rather than JSON, so their output is no longer parsed as JSON.
+- `h` (change parent) now **detaches every existing parent first, then attaches** the chosen one — previously it added the new parent before removing the old, so the JSON error above left the bead with two parents. It also clears *all* existing parent-child links (not just the first), repairing beads that already ended up with multiple parents.
+
 ## [0.6.0] - 2026-06-14
 
 ### Fixed

package/README.md

@@ -66,18 +66,21 @@ be-12  P2 ready   T  └ Another child
 |-----|--------|
 | `j` / `↓` | Move down |
 | `k` / `↑` | Move up |
-| `g` / `G` | Jump to top / bottom |
+| `g` / `Shift+g` | Jump to top / bottom |
 | `Enter` / `l` | Focus detail pane |
-| `h` / `Esc` | Back to list |
-| `f` | Cycle filter: ready → open → in_progress → all |
-| `r` | Reload current filter |
-| `/` | In-memory title filter |
+| `h` / `Esc` | Back to list (from detail) |
+| `Tab` / `Shift+Tab` | Next / previous status filter (blocked/ready/in_progress/closed/all) |
+| `t` | Cycle type filter (all/epic/task/chore/bug) |
+| `e` | Filter by epic (modal picker; `x` clears) |
+| `/` | In-memory title filter (empty submit clears it) |
+| `r` | Reload (keeps active filters) |
+| `Shift+r` | Reset all filters (title / epic / type) and reload |
 | `s` | Change status |
 | `c` | Close with reason |
-| `C` | Claim (in_progress + assign self) |
+| `Shift+c` | Claim (in_progress + assign self) |
 | `o` | Reopen |
 | `p` | Change priority |
-| `D` | Dependency menu (add / remove) |
+| `h` | Change parent (epic / standalone) |
 | `y` | Yank bead ID to clipboard |
 | `w` | Pick a workflow skill (`/executor-task`, `/executor-task-worktree`, `/executor-epic-task`, `/executor-epic-task-worktree`) and copy it with the selected task's ID. Disabled for epics. See [workflow-template](https://github.com/jsiovn/workflow-template). |
 | `?` | Help overlay |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bdtui",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Terminal UI for the bd beads issue tracker",
   "type": "module",
   "bin": {

package/src/app.js

@@ -1,6 +1,6 @@
 import blessed from 'blessed';
 import { execFile } from 'child_process';
-import { state, loadList, loadDetail, applyMutation, applyTypeFilter, isPaged, ensureSelectedVisible } from './state.js';
+import { state, loadList, loadDetail, applyMutation, applyFilters, isPaged, ensureSelectedVisible } from './state.js';
 import { createList, renderList } from './views/list.js';
 import { createDetail, renderDetail } from './views/detail.js';
 import { statusPicker, priorityPicker, textPrompt, parentPicker, skillPicker, epicPicker } from './views/modals.js';
@@ -10,6 +10,11 @@ import { bdUpdate, bdClose, bdClaim, bdReopen, bdDepAdd, bdDepRemove, bdDepListD
 const FILTERS = ['blocked', 'ready', 'in_progress', 'closed', 'all'];
 const TYPE_FILTERS = ['all', 'epic', 'task', 'chore', 'bug'];
 
+// Neutralize blessed tag markup in free text before it lands in a tags:true
+// box (mirrors esc() in views/detail.js). The title search is user-typed, so a
+// query like "{bold}" would otherwise corrupt the status line.
+const escTags = (s) => String(s ?? '').replace(/\{/g, '{open}').replace(/\}/g, '{close}');
+
 export async function run(cwd) {
   state.cwd = cwd;
 
@@ -38,8 +43,19 @@ export async function run(cwd) {
   let debounceTimer = null;
 
   let statusTimer = null;
+  // Describe every active narrowing filter (title search, epic scope, type) in
+  // one line with the result count and reset hint. Returns null when none are
+  // active so the caller can fall back to a plain "Ready".
+  function filterSummary() {
+    const parts = [];
+    if (state.textFilter) parts.push(`"${escTags(state.textFilter)}"`);
+    if (state.epicFilter) parts.push(`epic: ${state.epicFilter}`);
+    if (state.typeFilter !== 'all') parts.push(`type: ${state.typeFilter}`);
+    if (parts.length === 0) return null;
+    return `${parts.join('  ·  ')} — ${state.listOrder.length} results | Shift+r to reset`;
+  }
   function defaultStatus() {
-    return state.filter ? `Filter: ${state.filter}` : 'Ready';
+    return filterSummary() || 'Ready';
   }
   function setStatus(msg, isError = false, transient = false) {
     if (statusTimer) { clearTimeout(statusTimer); statusTimer = null; }
@@ -67,8 +83,11 @@ export async function run(cwd) {
     const epicInfo = state.epicFilter
       ? `  {gray-fg}│{/}  {magenta-fg}epic:{/} ${state.epicFilter}`
       : '';
+    const textInfo = state.textFilter
+      ? `  {gray-fg}│{/}  {green-fg}search:{/} "${escTags(state.textFilter)}"`
+      : '';
     const info  = count > 0 ? `{gray-fg}  │  ${count} beads{/}` : '';
-    tabBar.setContent(tabs.join('{gray-fg}│{/}') + typeInfo + epicInfo + info);
+    tabBar.setContent(tabs.join('{gray-fg}│{/}') + typeInfo + epicInfo + textInfo + info);
   }
 
   function setFocusBorder(focused) {
@@ -142,7 +161,7 @@ export async function run(cwd) {
       ensureSelectedVisible();
       if (state.selectedId) await loadDetail(state.selectedId);
       render();
-      setStatus('Ready');
+      setStatus(defaultStatus());
     } catch (err) {
       setStatus(err.message, true, true);
     }
@@ -158,7 +177,7 @@ export async function run(cwd) {
       state.selectedId = state.listOrder[0] || null;
       if (state.selectedId) await loadDetail(state.selectedId);
       render();
-      setStatus(`Filter: ${state.filter}`);
+      setStatus(defaultStatus());
     } catch (err) {
       setStatus(err.message, true, true);
     }
@@ -167,7 +186,7 @@ export async function run(cwd) {
   async function cycleTypeFilter() {
     const idx = TYPE_FILTERS.indexOf(state.typeFilter);
     state.typeFilter = TYPE_FILTERS[(idx + 1) % TYPE_FILTERS.length];
-    applyTypeFilter();
+    applyFilters();
     if (state.selectedId && !state.listOrder.includes(state.selectedId)) {
       state.selectedId = state.listOrder[0] || null;
     } else if (!state.selectedId) {
@@ -185,7 +204,7 @@ export async function run(cwd) {
         return;
       }
     }
-    setStatus(`Type: ${state.typeFilter}`, false, true);
+    setStatus(defaultStatus());
   }
 
   // ── Global keys ────────────────────────────────────────────────────────────
@@ -201,11 +220,20 @@ export async function run(cwd) {
 
   key(['q', 'C-c'], () => { screen.destroy(); process.exit(0); });
 
+  // r reloads data while preserving every active filter; Shift+r clears all
+  // narrowing filters (title search, epic scope, type) and reloads fresh.
+  // blessed reports a shifted letter as `S-<lower>` (never bare uppercase), so
+  // the binding must be 'S-r' — 'R' would be dead. Same for S-c / S-g below.
   key(['r'], async () => {
-    const wasEpic = !!state.epicFilter;
+    await refresh();
+  });
+  key(['S-r'], async () => {
+    const had = !!(state.textFilter || state.epicFilter || state.typeFilter !== 'all');
+    state.textFilter = null;
     state.epicFilter = null;
+    state.typeFilter = 'all';
     await refresh();
-    if (wasEpic) setStatus('Epic filter cleared', false, true);
+    if (had) setStatus('Filters reset', false, true);
   });
   key(['tab'], () => cycleFilter(1));
   key(['S-tab'], () => cycleFilter(-1));
@@ -241,7 +269,7 @@ export async function run(cwd) {
         return;
       }
     } else {
-      applyTypeFilter();
+      applyFilters();
     }
     state.selectedId = state.listOrder[0] || null;
     if (state.selectedId) {
@@ -251,12 +279,22 @@ export async function run(cwd) {
       }
     }
     render();
-    setStatus(picked ? `Epic: ${picked}` : 'Epic filter cleared', false, true);
+    setStatus(defaultStatus());
   });
 
-  key(['?'], () => {
+  // '?' toggles the help modal. Registered directly (NOT through key(), which
+  // swallows every global while a modal is open) so the same key that opens the
+  // help can also close it. Driving open AND close from this one handler — kept
+  // out of showHelp's own close keys — avoids re-entrancy: a separate '?' close
+  // binding would fire on the very keypress that registered it and slam the
+  // modal shut again. closeHelp is non-null exactly while the help is open.
+  let closeHelp = null;
+  screen.key(['?'], () => {
+    if (closeHelp) { closeHelp(); return; }
+    if (modalOpen) return; // another modal (a picker) owns the screen
     modalOpen = true;
-    showHelp(screen, () => {
+    closeHelp = showHelp(screen, () => {
+      closeHelp = null;
       modalOpen = false;
       list.focus();
       screen.render();
@@ -289,10 +327,15 @@ export async function run(cwd) {
       setStatus(err.message, true, true);
       return;
     }
-    const currentParentId = downDeps.find((d) => d.dependency_type === 'parent-child')?.id ?? null;
+    // A bead should have at most one parent, but a prior bug could leave it with
+    // several parent-child deps — collect them all so we can clear every one.
+    const currentParentIds = downDeps
+      .filter((d) => d.dependency_type === 'parent-child')
+      .map((d) => d.id)
+      .filter(Boolean);
     let newParent;
     try {
-      newParent = await parentPicker(screen, epics, { selfId: id, currentParentId });
+      newParent = await parentPicker(screen, epics, { selfId: id, currentParentIds });
     } catch (err) {
       list.focus();
       if (err.message !== 'cancelled') setStatus(err.message, true, true);
@@ -302,13 +345,13 @@ export async function run(cwd) {
     setStatus(`Reparenting ${id}…`);
     try {
       await applyMutation(id, async () => {
-        if (newParent) {
+        // Detach every existing parent first so the bead is never left with two
+        // parents, then attach the chosen one (skip if it's already a parent).
+        for (const pid of currentParentIds) {
+          if (pid !== newParent) await bdDepRemove(id, pid, state.cwd);
+        }
+        if (newParent && !currentParentIds.includes(newParent)) {
           await bdDepAdd(id, newParent, 'parent-child', state.cwd);
-          if (currentParentId && currentParentId !== newParent) {
-            await bdDepRemove(id, currentParentId, state.cwd);
-          }
-        } else if (currentParentId) {
-          await bdDepRemove(id, currentParentId, state.cwd);
         }
       });
       await loadList();
@@ -331,7 +374,7 @@ export async function run(cwd) {
     screen.render();
   });
 
-  key(['G'], () => {
+  key(['S-g'], () => {
     if (screen.focused !== list) return;
     // Jump to the true bottom — in paged mode reveal every remaining batch first.
     if (isPaged() && state.visibleCount < state.listOrder.length) {
@@ -346,27 +389,20 @@ export async function run(cwd) {
   key(['/'], async () => {
     if (screen.focused !== list) return;
     try {
-      const query = await textPrompt(screen, 'Filter by title');
+      // Pre-fill with the active search so it can be edited; an empty submit
+      // clears the title filter (other filters stay put).
+      const query = await textPrompt(screen, 'Filter by title', state.textFilter || '');
       list.focus();
-      if (!query) { render(); return; }
-      const q = query.toLowerCase();
-      state.listOrder = state.listOrder.filter((id) => {
-        const b = state.beadsById.get(id);
-        return b?.title?.toLowerCase().includes(q);
-      });
-      // A title-search result set is no longer a tree, so flatten every surviving
-      // row to depth 0 — otherwise a matched child whose parent was filtered out
-      // renders as an orphan indented under a branch glyph (mirrors how
-      // applyTypeFilter flattens the type-filtered list).
-      state.treeMeta = new Map(state.listOrder.map((id) => [id, { depth: 0, isLast: false }]));
-      state.visibleCount = isPaged()
-        ? Math.min(state.pageSize, state.listOrder.length)
-        : state.listOrder.length;
-      state.selectedId = state.listOrder[0] || null;
+      state.textFilter = query || null;
+      applyFilters();
+      if (!state.selectedId || !state.listOrder.includes(state.selectedId)) {
+        state.selectedId = state.listOrder[0] || null;
+      }
+      ensureSelectedVisible();
       renderList(list);
       renderDetail(detail);
       screen.render();
-      setStatus(`"${query}" — ${state.listOrder.length} results | r to reset`);
+      setStatus(defaultStatus());
     } catch {
       list.focus();
     }
@@ -414,7 +450,7 @@ export async function run(cwd) {
     }
   });
 
-  key(['C'], async () => {
+  key(['S-c'], async () => {
     if (screen.focused !== list || !state.selectedId) return;
     const id = state.selectedId;
     setStatus(`Claiming ${id}…`);
@@ -538,5 +574,7 @@ export async function run(cwd) {
     setStatus(err.message, true);
   }
   render();
-  setStatus('Ready | ? help');
+  // setStatus already appends "? help · q quit"; defaultStatus() yields "Ready"
+  // (or the active-filter summary) without duplicating the help hint.
+  setStatus(defaultStatus());
 }

package/src/bd.js

@@ -16,6 +16,18 @@ async function runBd(args, cwd) {
   }
 }
 
+// Run a bd command whose stdout we don't consume (e.g. `dep add`/`dep remove`,
+// which print a human-readable "✓ Added dependency…" line, not JSON). We can't
+// JSON.parse that — doing so was the source of the "Unexpected token '✓'" error.
+// Failures still surface: a non-zero exit rejects execFile and we throw stderr.
+async function runBdVoid(args, cwd) {
+  try {
+    await execFileP('bd', args, { cwd, maxBuffer: MAX_BUFFER });
+  } catch (err) {
+    throw new Error(err.stderr?.trim() || err.message);
+  }
+}
+
 // `bd blocked` only returns *derived*-blocked beads (open beads whose blockers
 // aren't all closed); it omits beads whose status was explicitly set to
 // "blocked". The Blocked tab should show both, so merge the two sources, deduped.
@@ -83,11 +95,11 @@ export const bdReopen = (id, cwd) => runBd(['reopen', id, '--json'], cwd);
 export const bdDepAdd = (child, parent, type, cwd) => {
   const args = ['dep', 'add', child, parent];
   if (type && type !== 'blocks') args.push('--type', type);
-  return runBd(args, cwd);
+  return runBdVoid(args, cwd);
 };
 
 export const bdDepRemove = (child, parent, cwd) =>
-  runBd(['dep', 'remove', child, parent], cwd);
+  runBdVoid(['dep', 'remove', child, parent], cwd);
 
 // Returns all children of an epic (all statuses — bd children includes closed by default)
 export const bdChildren = (id, cwd) => runBd(['children', id, '--json'], cwd);

package/src/keys.js

@@ -7,7 +7,7 @@ export const HELP_TEXT = [
   '  j / ↓       Move down in list',
   '  k / ↑       Move up in list',
   '  g           Jump to top',
-  '  G           Jump to bottom',
+  '  Shift+g     Jump to bottom',
   '  Enter / l   Focus detail pane',
   '  h / Esc     Back to list (from detail)',
   '',
@@ -17,15 +17,16 @@ export const HELP_TEXT = [
   '  Shift+Tab   Previous status filter',
   '  t           Cycle type filter (all/epic/task/chore/bug)',
   '  e           Filter by epic (modal picker; x clears; switches status to all)',
-  '  r           Reload (also clears epic filter)',
-  '  /           In-memory title filter',
+  '  /           In-memory title filter (empty submit clears it)',
+  '  r           Reload (keeps active filters)',
+  '  Shift+r     Reset all filters (title / epic / type) and reload',
   '  (all & closed tabs load more rows as you scroll to the bottom)',
   '',
   '  Mutations',
   '  ──────────────────────────────────────',
   '  s           Change status',
   '  c           Close with reason',
-  '  C           Claim bead (in_progress + assign self)',
+  '  Shift+c     Claim bead (in_progress + assign self)',
   '  o           Reopen',
   '  p           Change priority',
   '  h           Change parent (epic / standalone)',
@@ -64,11 +65,34 @@ export function showHelp(screen, onClose) {
   box.focus();
   screen.render();
 
+  // '?' is deliberately NOT a close key here — the caller (app.js) drives it as
+  // an open/close toggle. Binding '?' as a close key would re-enter on the very
+  // keypress that opens the modal: the toggle adds this listener mid-dispatch
+  // and blessed's emitter would then fire it in the same 'key ?' pass, slamming
+  // the help shut the instant it opened. q/Esc/h are safe — they never open the
+  // help, so they can only ever close it.
+  const CLOSE_KEYS = ['q', 'escape', 'h'];
+  let closed = false;
   const close = () => {
+    if (closed) return;
+    closed = true;
+    screen.unkey(CLOSE_KEYS, close);
     box.destroy();
     screen.render();
     onClose?.();
   };
 
-  box.key(['?', 'q', 'escape', 'h'], close);
+  // Bind the close keys on the screen, not the box. A box-level binding only
+  // fires while the box holds keyboard focus, but the Beads list and Detail
+  // pane are both mouse:true — a click on either steals focus from the help
+  // box. app.js suppresses every global key while a modal is open, so a
+  // focus-stealing click would otherwise leave the help permanently stuck
+  // open (its own close keys dead, every global key inert). Screen-level keys
+  // fire regardless of which pane holds focus, so q/Esc/h always dismiss it.
+  // unkey() on close keeps the binding from leaking across repeated opens.
+  screen.key(CLOSE_KEYS, close);
+
+  // Returned so the caller's '?' toggle can dismiss the help regardless of
+  // which pane currently holds focus.
+  return close;
 }

package/src/state.js

@@ -15,6 +15,7 @@ export const state = {
   filter: 'ready',
   typeFilter: 'all',   // 'all' | 'epic' | 'task'
   epicFilter: null,    // null or epic bead id — when set, list is scoped to that epic + its children
+  textFilter: null,    // null or lowercase-matched title substring (in-memory)
   blockedIds: new Set(), // ids that appear in `bd blocked` — derived state, not raw status
   pageSize: 100,        // lazy "load more" batch size for the flat all view
   visibleCount: 0,     // how many of listOrder are currently rendered (paged mode)
@@ -60,7 +61,11 @@ function scopeToEpic(items, epicId) {
   return out;
 }
 
-export function applyTypeFilter() {
+// Apply every active narrowing filter (epic → type → text) to fullTreeItems and
+// rebuild listOrder/treeMeta. Kept in one place so a reload (`r`) can replay the
+// same filters and the status bar can describe them. Filters compose: an epic
+// scope, a type filter, and a title search can all be active at once.
+export function applyFilters() {
   let items = state.fullTreeItems;
   if (state.epicFilter) {
     items = scopeToEpic(items, state.epicFilter);
@@ -71,6 +76,15 @@ export function applyTypeFilter() {
       .sort((x, y) => byUpdatedDesc(state.beadsById.get(x.id), state.beadsById.get(y.id)))
       .map((t) => ({ id: t.id, depth: 0, isLast: false }));
   }
+  if (state.textFilter) {
+    const q = state.textFilter.toLowerCase();
+    // A title-search result set is no longer a tree, so flatten every surviving
+    // row to depth 0 — otherwise a matched child whose parent was filtered out
+    // renders as an orphan indented under a branch glyph.
+    items = items
+      .filter((t) => state.beadsById.get(t.id)?.title?.toLowerCase().includes(q))
+      .map((t) => ({ id: t.id, depth: 0, isLast: false }));
+  }
   state.listOrder = items.map((t) => t.id);
   state.treeMeta = new Map(items.map((t) => [t.id, { depth: t.depth, isLast: t.isLast }]));
   state.visibleCount = isPaged()
@@ -122,11 +136,15 @@ function buildTreeOrder(beads, parentOf) {
 }
 
 export async function loadList() {
-  const paged = isPaged();
+  // The all/closed tabs lift bd's 50-row cap so the full tree is available; the
+  // renderer still reveals rows in pageSize batches (see isPaged). This is keyed
+  // off the tab itself, NOT isPaged(): an epic filter makes isPaged() false but
+  // we still need every bead fetched so scopeToEpic can find the epic's children
+  // (otherwise reloading while epic-scoped would silently drop children past
+  // row 50).
+  const unlimited = state.filter === 'all' || state.filter === 'closed';
   const [beads, blocked] = await Promise.all([
-    // Paged tabs (all / closed) lift bd's 50-row cap; rows are still revealed in
-    // pageSize batches by the renderer.
-    bdList(state.filter, state.cwd, { unlimited: paged }),
+    bdList(state.filter, state.cwd, { unlimited }),
     bdList('blocked', state.cwd).catch(() => []),
   ]);
   state.blockedIds = new Set((blocked || []).map((b) => b.id));
@@ -180,7 +198,7 @@ export async function loadList() {
   }
 
   state.fullTreeItems = buildTreeOrder(beads, parentOf);
-  applyTypeFilter();
+  applyFilters();
   return beads;
 }
 

package/src/views/modals.js

@@ -186,10 +186,11 @@ export function skillPicker(screen, beadId) {
   return listPicker(screen, 'Copy workflow command', items, 'magenta', 56, 1);
 }
 
-export function parentPicker(screen, epics, { selfId, currentParentId } = {}) {
+export function parentPicker(screen, epics, { selfId, currentParentIds = [] } = {}) {
   return new Promise((resolve, reject) => {
+    const exclude = new Set([selfId, ...currentParentIds]);
     const sorted = [...epics]
-      .filter((e) => e.id !== selfId && e.id !== currentParentId)
+      .filter((e) => !exclude.has(e.id))
       .sort((a, b) => {
         const ta = a.updated_at || '', tb = b.updated_at || '';
         if (ta !== tb) return tb.localeCompare(ta);