bdtui 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [0.5.1] - 2026-06-14
+
+### Fixed
+
+- Blocked tab now also lists beads whose status was explicitly set to `blocked`. Previously it ran only `bd blocked` (which returns *derived*-blocked beads — open beads with unclosed blockers), so explicitly-blocked beads were missing from the tab; the filter now merges `bd blocked` with `bd list --status blocked`.
+- List rows for open beads that are derived-blocked now show the `blocked` status label and color, matching the detail view's effective-status logic.
+
+## [0.5.0] - 2026-06-13
+
+### Added
+
+- `h` key: dedicated parent-picker to reparent a bead under a different epic or detach it as standalone (epics listed newest-updated-first; current parent excluded).
+- `chore` and `bug` added to the `t` type-filter cycle (`all → epic → task → chore → bug → all`).
+- `x` key in the epic-filter picker clears the filter immediately (same as selecting ✗ Clear).
+
+### Changed
+
+- All tabs now sort beads by `updated_at` DESC (most-recently-touched first), preserving the epic→children tree grouping for tree tabs and ordering children within each epic the same way.
+- `r` (reload) now also clears any active epic filter before reloading; status bar shows "Epic filter cleared" when it does.
+
+### Removed
+
+- `D` dependency menu — replaced by the focused `h` reparent picker.
+
 ## [0.4.0] - 2026-06-07
 
 ### Added

package/package.json

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

package/src/app.js

@@ -3,12 +3,12 @@ import { execFile } from 'child_process';
 import { state, loadList, loadDetail, applyMutation, applyTypeFilter, isPaged, ensureSelectedVisible } from './state.js';
 import { createList, renderList } from './views/list.js';
 import { createDetail, renderDetail } from './views/detail.js';
-import { statusPicker, priorityPicker, textPrompt, depMenu, skillPicker, epicPicker } from './views/modals.js';
+import { statusPicker, priorityPicker, textPrompt, parentPicker, skillPicker, epicPicker } from './views/modals.js';
 import { showHelp } from './keys.js';
-import { bdUpdate, bdClose, bdClaim, bdReopen, bdDepAdd, bdDepRemove, bdEpics } from './bd.js';
+import { bdUpdate, bdClose, bdClaim, bdReopen, bdDepAdd, bdDepRemove, bdDepListDown, bdEpics } from './bd.js';
 
 const FILTERS = ['blocked', 'ready', 'in_progress', 'closed', 'all'];
-const TYPE_FILTERS = ['all', 'epic', 'task'];
+const TYPE_FILTERS = ['all', 'epic', 'task', 'chore', 'bug'];
 
 export async function run(cwd) {
   state.cwd = cwd;
@@ -201,7 +201,12 @@ export async function run(cwd) {
 
   key(['q', 'C-c'], () => { screen.destroy(); process.exit(0); });
 
-  key(['r'], refresh);
+  key(['r'], async () => {
+    const wasEpic = !!state.epicFilter;
+    state.epicFilter = null;
+    await refresh();
+    if (wasEpic) setStatus('Epic filter cleared', false, true);
+  });
   key(['tab'], () => cycleFilter(1));
   key(['S-tab'], () => cycleFilter(-1));
   key(['t'], cycleTypeFilter);
@@ -262,10 +267,63 @@ export async function run(cwd) {
     if (screen.focused === list) { setFocusBorder('detail'); detail.focus(); screen.render(); }
   });
 
-  key(['h', 'escape'], () => {
+  key(['escape'], () => {
     if (screen.focused !== list) { setFocusBorder('list'); list.focus(); screen.render(); }
   });
 
+  key(['h'], async () => {
+    if (screen.focused === detail) { setFocusBorder('list'); list.focus(); screen.render(); return; }
+    if (screen.focused !== list) return;
+    if (!state.selectedId) return;
+    const id = state.selectedId;
+    const bead = state.beadsById.get(id);
+    if (bead?.issue_type === 'epic') {
+      setStatus(`${id} is an epic — epics are top-level`, true, true);
+      return;
+    }
+    setStatus('Loading parents…');
+    let epics, downDeps;
+    try {
+      [epics, downDeps] = await Promise.all([bdEpics(state.cwd), bdDepListDown(id, state.cwd)]);
+    } catch (err) {
+      setStatus(err.message, true, true);
+      return;
+    }
+    const currentParentId = downDeps.find((d) => d.dependency_type === 'parent-child')?.id ?? null;
+    let newParent;
+    try {
+      newParent = await parentPicker(screen, epics, { selfId: id, currentParentId });
+    } catch (err) {
+      list.focus();
+      if (err.message !== 'cancelled') setStatus(err.message, true, true);
+      return;
+    }
+    list.focus();
+    setStatus(`Reparenting ${id}…`);
+    try {
+      await applyMutation(id, async () => {
+        if (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();
+      ensureSelectedVisible();
+      render();
+      setStatus(
+        newParent ? `Reparented ${id} → ${newParent}` : `${id} is now standalone`,
+        false,
+        true,
+      );
+    } catch (err) {
+      setStatus(err.message, true, true);
+    }
+  });
+
   key(['g'], () => {
     if (screen.focused !== list) return;
     list.select(0);
@@ -402,29 +460,6 @@ export async function run(cwd) {
     }
   });
 
-  key(['D'], async () => {
-    if (screen.focused !== list || !state.selectedId) return;
-    const id = state.selectedId;
-    try {
-      const result = await depMenu(screen);
-      list.focus();
-      if (result.action === 'add') {
-        setStatus(`Adding dep: ${id} → ${result.targetId} [${result.type}]…`);
-        await applyMutation(id, () => bdDepAdd(id, result.targetId, result.type, state.cwd));
-        setStatus(`Added: ${id} → ${result.targetId} [${result.type}]`, false, true);
-      } else {
-        setStatus(`Removing dep: ${id} → ${result.targetId}…`);
-        await applyMutation(id, () => bdDepRemove(id, result.targetId, state.cwd));
-        setStatus(`Removed dep: ${id} → ${result.targetId}`, false, true);
-      }
-      renderDetail(detail);
-      screen.render();
-    } catch (err) {
-      list.focus();
-      if (err.message !== 'cancelled') setStatus(err.message, true, true);
-    }
-  });
-
   async function copyToClipboard(text, { okMsg, busyMsg } = {}) {
     setStatus(busyMsg || `Copying…`);
     const write = (cmd, args) => new Promise((resolve, reject) => {

package/src/bd.js

@@ -16,9 +16,24 @@ async function runBd(args, cwd) {
   }
 }
 
+// `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.
+async function bdBlocked(cwd) {
+  const [derived, explicit] = await Promise.all([
+    runBd(['blocked', '--json'], cwd).catch(() => []),
+    runBd(['list', '--status', 'blocked', '--json', '--limit', '0'], cwd).catch(() => []),
+  ]);
+  const byId = new Map();
+  for (const b of [...(derived || []), ...(explicit || [])]) {
+    if (b?.id && !byId.has(b.id)) byId.set(b.id, b);
+  }
+  return [...byId.values()];
+}
+
 export const bdList = (filter, cwd, { unlimited = false } = {}) => {
   if (filter === 'ready') return runBd(['ready', '--json'], cwd);
-  if (filter === 'blocked') return runBd(['blocked', '--json'], cwd);
+  if (filter === 'blocked') return bdBlocked(cwd);
   const args = ['list', '--json'];
   if (filter === 'all') args.push('--all');
   else if (filter) args.push('--status', filter);

package/src/keys.js

@@ -9,15 +9,15 @@ export const HELP_TEXT = [
   '  g           Jump to top',
   '  G           Jump to bottom',
   '  Enter / l   Focus detail pane',
-  '  h / Esc     Back to list',
+  '  h / Esc     Back to list (from detail)',
   '',
   '  Filters & refresh',
   '  ──────────────────────────────────────',
   '  Tab         Next status filter (blocked/ready/in_progress/closed/all)',
   '  Shift+Tab   Previous status filter',
-  '  t           Cycle type filter (all/epic/task)',
-  '  e           Filter by epic (modal picker; switches status to all)',
-  '  r           Reload current filter from bd',
+  '  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',
   '  (all & closed tabs load more rows as you scroll to the bottom)',
   '',
@@ -28,7 +28,7 @@ export const HELP_TEXT = [
   '  C           Claim bead (in_progress + assign self)',
   '  o           Reopen',
   '  p           Change priority',
-  '  D           Dependency menu (add / remove)',
+  '  h           Change parent (epic / standalone)',
   '',
   '  Other',
   '  ──────────────────────────────────────',

package/src/state.js

@@ -1,5 +1,11 @@
 import { bdList, bdShow, bdDeps, bdDepListDown } from './bd.js';
 
+function byUpdatedDesc(a, b) {
+  const ta = a?.updated_at || '', tb = b?.updated_at || '';
+  if (ta !== tb) return tb.localeCompare(ta);
+  return (b?.id || '').localeCompare(a?.id || '');
+}
+
 export const state = {
   beadsById: new Map(),
   fullTreeItems: [],   // unfiltered ordered tree items (before typeFilter)
@@ -62,6 +68,7 @@ export function applyTypeFilter() {
   if (state.typeFilter !== 'all') {
     items = items
       .filter((t) => state.beadsById.get(t.id)?.issue_type === state.typeFilter)
+      .sort((x, y) => byUpdatedDesc(state.beadsById.get(x.id), state.beadsById.get(y.id)))
       .map((t) => ({ id: t.id, depth: 0, isLast: false }));
   }
   state.listOrder = items.map((t) => t.id);
@@ -84,11 +91,12 @@ function buildTreeOrder(beads, parentOf) {
   }
 
   for (const children of childrenOf.values()) {
-    children.sort((a, b) => (a.priority ?? 2) - (b.priority ?? 2) || a.id.localeCompare(b.id));
+    children.sort(byUpdatedDesc);
   }
 
   const childIds = new Set([...childrenOf.values()].flat().map((b) => b.id));
   const roots = beads.filter((b) => !childIds.has(b.id));
+  roots.sort(byUpdatedDesc);
 
   const ordered = [];
   for (const root of roots) {
@@ -115,6 +123,7 @@ async function loadListFlat() {
   for (const b of beads) {
     state.beadsById.set(b.id, { ...state.beadsById.get(b.id), ...b });
   }
+  beads.sort(byUpdatedDesc);
   state.fullTreeItems = beads.map((b) => ({ id: b.id, depth: 0, isLast: false }));
   applyTypeFilter();
   return beads;

package/src/views/list.js

@@ -31,7 +31,12 @@ function t(color, text) {
 function formatRow(bead, depth = 0, isLast = false) {
   const id   = bead.id.padEnd(14);
   const p    = `P${bead.priority ?? 2}`;
-  const stat = bead.status || 'open';
+  // Effective status mirrors how `bd blocked` derives the Blocked tab:
+  // an open bead whose blockers aren't all closed reads as "blocked",
+  // not "open". The raw `bd list` rows only carry the stored status.
+  const stat = (bead.status === 'open' && state.blockedIds.has(bead.id))
+    ? 'blocked'
+    : (bead.status || 'open');
   const s    = (STATUS_SHORT[stat] || stat.slice(0, 7)).padEnd(7);
   const badge = TYPE_BADGE[bead.issue_type] ?? t('gray', '?');
   const prefix = depth > 0 ? t('gray', isLast ? ' └ ' : ' ├ ') : '   ';

package/src/views/modals.js

@@ -166,6 +166,12 @@ export function epicPicker(screen, epics, currentEpicId = null) {
       screen.render();
       reject(new Error('cancelled'));
     });
+
+    picker.key(['x'], () => {
+      picker.destroy();
+      screen.render();
+      resolve(null);
+    });
   });
 }
 
@@ -180,26 +186,62 @@ export function skillPicker(screen, beadId) {
   return listPicker(screen, 'Copy workflow command', items, 'magenta', 56, 1);
 }
 
-const DEP_TYPES = [
-  'blocks', 'tracks', 'related', 'relates-to',
-  'validates', 'caused-by', 'parent-child',
-];
+export function parentPicker(screen, epics, { selfId, currentParentId } = {}) {
+  return new Promise((resolve, reject) => {
+    const sorted = [...epics]
+      .filter((e) => e.id !== selfId && e.id !== currentParentId)
+      .sort((a, b) => {
+        const ta = a.updated_at || '', tb = b.updated_at || '';
+        if (ta !== tb) return tb.localeCompare(ta);
+        return b.id.localeCompare(a.id);
+      });
 
-export async function depMenu(screen) {
-  const action = await listPicker(
-    screen,
-    'Dependency',
-    ['Add dep', 'Remove dep'],
-    'magenta',
-  );
+    const rows = ['{yellow-fg}Standalone bead{/}'];
+    const ids = [null];
 
-  const targetId = await textPrompt(screen, 'Target bead ID');
-  if (!targetId) throw new Error('cancelled');
+    for (const e of sorted) {
+      const id = e.id.padEnd(12);
+      const title = (e.title || '').slice(0, 60);
+      rows.push(`{gray-fg}${id}{/} ${title}`);
+      ids.push(e.id);
+    }
 
-  if (action === 'Add dep') {
-    const type = await listPicker(screen, 'Dep type', DEP_TYPES, 'magenta');
-    return { action: 'add', targetId, type };
-  }
+    const width = 72;
+    const height = Math.min(rows.length + 4, Math.max(8, screen.height - 4));
 
-  return { action: 'remove', targetId };
+    const picker = blessed.list({
+      parent: screen,
+      label: ' Change Parent ',
+      border: { type: 'line' },
+      top: 'center',
+      left: 'center',
+      width,
+      height,
+      items: rows,
+      keys: true,
+      vi: true,
+      tags: true,
+      scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'magenta' } },
+      style: {
+        selected: { bg: 'blue', fg: 'white', bold: true },
+        border: { fg: 'magenta' },
+        label: { fg: 'magenta', bold: true },
+      },
+    });
+
+    picker.focus();
+    screen.render();
+
+    picker.once('select', (_item, index) => {
+      picker.destroy();
+      screen.render();
+      resolve(ids[index]);
+    });
+
+    picker.key(['escape', 'q'], () => {
+      picker.destroy();
+      screen.render();
+      reject(new Error('cancelled'));
+    });
+  });
 }