bdtui 0.3.2 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [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
+
+- Lazy pagination for the `all` and `closed` tabs: every bead loads in a single `bd` call (flat, no per-bead dependency fetch) and rows are revealed in batches as you scroll to the bottom, with a "showing X of Y" count. This lifts the previous silent 50-row cap so the full history is reachable. `G` jumps to the true bottom; `/` searches the whole list.
+
+### Changed
+
+- Epic filter picker now lists the most recently created epics first.
+
+### Fixed
+
+- `stdout maxBuffer length exceeded` error when a `bd list` payload exceeded 1 MB (e.g. the `all` tab on a large repo) — the output buffer is now 64 MB.
+- Epic filter picker could miss epics beyond the first 50 results; it now enumerates all epics.
+
 ## [0.3.2] - 2026-05-24
 
 ### Changed

package/package.json

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

package/src/app.js

@@ -1,14 +1,14 @@
 import blessed from 'blessed';
 import { execFile } from 'child_process';
-import { state, loadList, loadDetail, applyMutation, applyTypeFilter } from './state.js';
+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;
@@ -88,9 +88,23 @@ export async function run(cwd) {
     screen.render();
   }
 
+  // Lazy "load more": the paged tabs (all / closed) load every bead but render
+  // them pageSize at a time; reveal the next batch once selection reaches the
+  // last visible row (infinite-scroll style).
+  function maybeLoadMore() {
+    if (!isPaged()) return;
+    if (state.visibleCount >= state.listOrder.length) return;
+    if (list.selected < state.visibleCount - 1) return;
+    state.visibleCount = Math.min(state.visibleCount + state.pageSize, state.listOrder.length);
+    renderList(list);
+    setStatus(`Showing ${state.visibleCount} of ${state.listOrder.length}`, false, true);
+    screen.render();
+  }
+
   // When list selection changes, update selectedId and debounce detail fetch
   function onNav() {
     setImmediate(() => {
+      maybeLoadMore();
       const idx = list.selected;
       const id = state.listOrder[idx];
       if (!id || id === state.selectedId) return;
@@ -125,6 +139,7 @@ export async function run(cwd) {
       if (state.selectedId && !state.listOrder.includes(state.selectedId)) {
         state.selectedId = state.listOrder[0] || null;
       }
+      ensureSelectedVisible();
       if (state.selectedId) await loadDetail(state.selectedId);
       render();
       setStatus('Ready');
@@ -158,6 +173,7 @@ export async function run(cwd) {
     } else if (!state.selectedId) {
       state.selectedId = state.listOrder[0] || null;
     }
+    ensureSelectedVisible();
     render();
     if (state.selectedId) {
       try {
@@ -185,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);
@@ -246,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);
@@ -259,6 +333,11 @@ export async function run(cwd) {
 
   key(['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) {
+      state.visibleCount = state.listOrder.length;
+      renderList(list);
+    }
     list.select(state.listOrder.length - 1);
     onNav();
     screen.render();
@@ -275,6 +354,9 @@ export async function run(cwd) {
         const b = state.beadsById.get(id);
         return b?.title?.toLowerCase().includes(q);
       });
+      state.visibleCount = isPaged()
+        ? Math.min(state.pageSize, state.listOrder.length)
+        : state.listOrder.length;
       state.selectedId = state.listOrder[0] || null;
       renderList(list);
       renderDetail(detail);
@@ -315,6 +397,10 @@ export async function run(cwd) {
       setStatus(`Closing ${id}…`);
       await applyMutation(id, () => bdClose(id, reason, state.cwd));
       await loadList();
+      if (state.selectedId && !state.listOrder.includes(state.selectedId)) {
+        state.selectedId = state.listOrder[0] || null;
+      }
+      ensureSelectedVisible();
       render();
       setStatus(`Closed ${id}`, false, true);
     } catch (err) {
@@ -345,6 +431,10 @@ export async function run(cwd) {
     try {
       await applyMutation(id, () => bdReopen(id, state.cwd));
       await loadList();
+      if (state.selectedId && !state.listOrder.includes(state.selectedId)) {
+        state.selectedId = state.listOrder[0] || null;
+      }
+      ensureSelectedVisible();
       render();
       setStatus(`Reopened ${id}`, false, true);
     } catch (err) {
@@ -370,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

@@ -3,24 +3,33 @@ import { promisify } from 'util';
 
 const execFileP = promisify(execFile);
 
+// Default execFile maxBuffer is 1MB; bd JSON output (esp. `list --all` with many
+// closed beads) can exceed that and throw "stdout maxBuffer length exceeded".
+const MAX_BUFFER = 64 * 1024 * 1024; // 64MB
+
 async function runBd(args, cwd) {
   try {
-    const { stdout } = await execFileP('bd', args, { cwd });
+    const { stdout } = await execFileP('bd', args, { cwd, maxBuffer: MAX_BUFFER });
     return JSON.parse(stdout);
   } catch (err) {
     throw new Error(err.stderr?.trim() || err.message);
   }
 }
 
-export const bdList = (filter, cwd) => {
+export const bdList = (filter, cwd, { unlimited = false } = {}) => {
   if (filter === 'ready') return runBd(['ready', '--json'], cwd);
   if (filter === 'blocked') return runBd(['blocked', '--json'], cwd);
   const args = ['list', '--json'];
   if (filter === 'all') args.push('--all');
   else if (filter) args.push('--status', filter);
+  // `--limit 0` lifts bd's default 50-row cap for the paginated flat views.
+  if (unlimited) args.push('--limit', '0');
   return runBd(args, cwd);
 };
 
+// bdList('all') with the 50-row cap lifted — used for enumerating every epic.
+export const bdListAll = (cwd) => bdList('all', cwd, { unlimited: true });
+
 export const bdShow = async (id, cwd) => {
   const res = await runBd(['show', id, '--json'], cwd);
   return Array.isArray(res) ? res[0] : res;
@@ -69,6 +78,6 @@ export const bdDepRemove = (child, parent, cwd) =>
 export const bdChildren = (id, cwd) => runBd(['children', id, '--json'], cwd);
 
 export const bdEpics = async (cwd) => {
-  const all = await runBd(['list', '--all', '--json'], cwd);
+  const all = await bdListAll(cwd);
   return Array.isArray(all) ? all.filter((b) => b.issue_type === 'epic') : [];
 };

package/src/keys.js

@@ -9,16 +9,17 @@ 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)',
   '',
   '  Mutations',
   '  ──────────────────────────────────────',
@@ -27,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)
@@ -10,9 +16,32 @@ export const state = {
   typeFilter: 'all',   // 'all' | 'epic' | 'task'
   epicFilter: null,    // null or epic bead id — when set, list is scoped to that epic + its children
   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)
   cwd: process.cwd(),
 };
 
+// The "all" and "closed" tabs (no epic filter) can hold huge numbers of beads,
+// so they use a flat, lazily-revealed list; every other view loads fully and
+// renders the epic→children tree.
+export function isPaged() {
+  return (state.filter === 'all' || state.filter === 'closed') && !state.epicFilter;
+}
+
+// Paged mode only renders the first visibleCount rows. After a reload that keeps
+// a deep selection, grow the window (to its batch boundary) so the selected bead
+// stays rendered — otherwise the cursor and state.selectedId desync and mutation
+// keys would act on an off-screen bead. Call AFTER selectedId is finalized.
+export function ensureSelectedVisible() {
+  if (!isPaged() || !state.selectedId) return;
+  const idx = state.listOrder.indexOf(state.selectedId);
+  if (idx < state.visibleCount) return;
+  state.visibleCount = Math.min(
+    state.listOrder.length,
+    Math.ceil((idx + 1) / state.pageSize) * state.pageSize,
+  );
+}
+
 function scopeToEpic(items, epicId) {
   const out = [];
   let inside = false;
@@ -39,10 +68,14 @@ 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);
   state.treeMeta = new Map(items.map((t) => [t.id, { depth: t.depth, isLast: t.isLast }]));
+  state.visibleCount = isPaged()
+    ? Math.min(state.pageSize, state.listOrder.length)
+    : state.listOrder.length;
 }
 
 function buildTreeOrder(beads, parentOf) {
@@ -58,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) {
@@ -76,7 +110,27 @@ function buildTreeOrder(beads, parentOf) {
   return ordered;
 }
 
+// Flat load for the paged tabs ("all" / "closed"). Skips the per-bead
+// parent-child dep fetch (which spawns one bd subprocess per bead) and the tree
+// build, so even very large repos load in a single bd call; the UI reveals rows
+// in pageSize batches.
+async function loadListFlat() {
+  const [beads, blocked] = await Promise.all([
+    bdList(state.filter, state.cwd, { unlimited: true }),
+    bdList('blocked', state.cwd).catch(() => []),
+  ]);
+  state.blockedIds = new Set((blocked || []).map((b) => b.id));
+  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;
+}
+
 export async function loadList() {
+  if (isPaged()) return loadListFlat();
   const [beads, blocked] = await Promise.all([
     bdList(state.filter, state.cwd),
     bdList('blocked', state.cwd).catch(() => []),

package/src/views/list.js

@@ -67,17 +67,28 @@ export function createList(screen) {
 }
 
 export function renderList(list) {
-  const items = state.listOrder.map((id) => {
+  const total = state.listOrder.length;
+  // In paged ("load more") mode only the first visibleCount rows are rendered;
+  // everything else renders the full list.
+  const shown = state.visibleCount > 0 && state.visibleCount < total
+    ? state.visibleCount
+    : total;
+  const ids = state.listOrder.slice(0, shown);
+
+  const items = ids.map((id) => {
     const b = state.beadsById.get(id);
     const { depth = 0, isLast = false } = state.treeMeta.get(id) ?? {};
     return b ? formatRow(b, depth, isLast) : t('gray', id);
   });
 
   const selIdx = state.selectedId
-    ? Math.max(0, state.listOrder.indexOf(state.selectedId))
+    ? Math.max(0, ids.indexOf(state.selectedId))
     : 0;
 
-  list.setLabel(` Beads ${t('gray', `(${state.listOrder.length})`)} `);
+  const label = shown < total
+    ? ` Beads ${t('gray', `(showing ${shown} of ${total})`)} `
+    : ` Beads ${t('gray', `(${total})`)} `;
+  list.setLabel(label);
   list.setItems(items);
-  if (state.listOrder.length > 0) list.select(selIdx);
+  if (ids.length > 0) list.select(Math.min(selIdx, ids.length - 1));
 }

package/src/views/modals.js

@@ -91,7 +91,15 @@ const CLEAR_FILTER_TAG = '__clear__';
 
 export function epicPicker(screen, epics, currentEpicId = null) {
   return new Promise((resolve, reject) => {
-    const sorted = [...epics].sort((a, b) => a.id.localeCompare(b.id));
+    // Newest epics on top: sort by created_at descending (ISO-8601 UTC strings
+    // sort lexicographically in chronological order). Fall back to id for ties
+    // or missing timestamps.
+    const sorted = [...epics].sort((a, b) => {
+      const ta = a.created_at || '';
+      const tb = b.created_at || '';
+      if (ta !== tb) return tb.localeCompare(ta);
+      return b.id.localeCompare(a.id);
+    });
     const rows = [];
     const ids = [];
 
@@ -158,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);
+    });
   });
 }
 
@@ -172,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);
+      });
+
+    const rows = ['{yellow-fg}Standalone bead{/}'];
+    const ids = [null];
 
-export async function depMenu(screen) {
-  const action = await listPicker(
-    screen,
-    'Dependency',
-    ['Add dep', 'Remove dep'],
-    'magenta',
-  );
+    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);
+    }
+
+    const width = 72;
+    const height = Math.min(rows.length + 4, Math.max(8, screen.height - 4));
+
+    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 },
+      },
+    });
 
-  const targetId = await textPrompt(screen, 'Target bead ID');
-  if (!targetId) throw new Error('cancelled');
+    picker.focus();
+    screen.render();
 
-  if (action === 'Add dep') {
-    const type = await listPicker(screen, 'Dep type', DEP_TYPES, 'magenta');
-    return { action: 'add', targetId, type };
-  }
+    picker.once('select', (_item, index) => {
+      picker.destroy();
+      screen.render();
+      resolve(ids[index]);
+    });
 
-  return { action: 'remove', targetId };
+    picker.key(['escape', 'q'], () => {
+      picker.destroy();
+      screen.render();
+      reject(new Error('cancelled'));
+    });
+  });
 }