feat(ui): double-click row to drill down, click selects column (#647)

## Summary

- Replace single-click-on-selected-row drilldown with double-click
detection (300ms threshold)
- Single click now selects both the row and the column of the clicked
cell
- Same double-click pattern applied to dashboard overlay row clicks
- Added `selectClickedColumn` to map click X position to column header
zones

closes #625

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: cpcloud

internal/app/model.go

@@ -204,6 +204,8 @@ type Model struct {
 	magMode               bool // easter egg: display numbers as order-of-magnitude
 	confirmHardDelete     bool // true while waiting for y/n on permanent delete
 	hardDeleteID          uint // entity ID pending permanent deletion
+	lastRowClick          rowClickState
+	lastDashClick         rowClickState
 	cur                   locale.Currency
 	status                statusMsg
 	projectTypes          []data.ProjectType

internal/app/mouse.go

@@ -5,10 +5,21 @@ package app
 
 import (
 	"fmt"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 )
 
+// doubleClickThreshold is the maximum duration between two clicks on the
+// same row for them to count as a double-click.
+const doubleClickThreshold = 300 * time.Millisecond
+
+// rowClickState tracks the last row click for double-click detection.
+type rowClickState struct {
+	at  time.Time
+	row int
+}
+
 // Zone ID prefixes for clickable UI regions.
 const (
 	zoneTab        = "tab-"
@@ -92,7 +103,7 @@ func (m *Model) handleLeftClick(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
 		}
 	}
 
-	// Row click.
+	// Row click: single click selects row+column, double-click drills down.
 	if tab := m.effectiveTab(); tab != nil {
 		total := len(tab.CellRows)
 		if total > 0 {
@@ -112,18 +123,19 @@ func (m *Model) handleLeftClick(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
 			start, end := visibleRange(total, height, cursor)
 			for i := start; i < end; i++ {
 				if m.zones.Get(fmt.Sprintf("%s%d", zoneRow, i)).InBounds(msg) {
-					if i == cursor {
-						// Click on already-selected row: drilldown/enter.
-						if m.mode == modeNormal {
-							if err := m.handleNormalEnter(); err != nil {
-								m.setStatusError(err.Error())
-							}
-							if m.mode == modeForm {
-								return m, m.formInitCmd()
-							}
+					now := time.Now()
+					isDouble := m.lastRowClick.row == i &&
+						!m.lastRowClick.at.IsZero() &&
+						now.Sub(m.lastRowClick.at) <= doubleClickThreshold
+					if isDouble && m.mode == modeNormal {
+						m.lastRowClick = rowClickState{}
+						if err := m.handleNormalEnter(); err != nil {
+							m.setStatusError(err.Error())
 						}
 					} else {
 						tab.Table.SetCursor(i)
+						m.selectClickedColumn(tab, msg)
+						m.lastRowClick = rowClickState{at: now, row: i}
 					}
 					return m, nil
 				}
@@ -208,14 +220,20 @@ func (m *Model) handleHintClick(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
 
 // handleOverlayClick handles clicks within an active overlay.
 func (m *Model) handleOverlayClick(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
-	// Dashboard row clicks.
+	// Dashboard row clicks: single click selects, double-click jumps.
 	if m.dashboardVisible() {
 		for i := range m.dash.nav {
 			if m.zones.Get(fmt.Sprintf("%s%d", zoneDashRow, i)).InBounds(msg) {
-				if i == m.dash.cursor {
+				now := time.Now()
+				isDouble := m.lastDashClick.row == i &&
+					!m.lastDashClick.at.IsZero() &&
+					now.Sub(m.lastDashClick.at) <= doubleClickThreshold
+				if isDouble {
+					m.lastDashClick = rowClickState{}
 					m.dashJump()
 				} else {
 					m.dash.cursor = i
+					m.lastDashClick = rowClickState{at: now, row: i}
 				}
 				return m, nil
 			}
@@ -224,6 +242,29 @@ func (m *Model) handleOverlayClick(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
+// selectClickedColumn updates the tab's column cursor to match the column
+// zone the click's X coordinate falls within. Column header zones (col-N)
+// share the same X ranges as body cells, so we reuse them.
+func (m *Model) selectClickedColumn(tab *Tab, msg tea.MouseMsg) {
+	vSpecs, _, _, _, _ := visibleProjection(tab)
+	width := m.effectiveWidth()
+	normalSep := m.styles.TableSeparator().Render(" │ ")
+	vp := computeTableViewport(tab, width, normalSep, m.cur.Symbol())
+	for i := range vSpecs {
+		z := m.zones.Get(fmt.Sprintf("%s%d", zoneCol, i))
+		if z == nil || z.IsZero() {
+			continue
+		}
+		if msg.X >= z.StartX && msg.X <= z.EndX {
+			if i < len(vp.VisToFull) {
+				tab.ColCursor = vp.VisToFull[i]
+				m.updateTabViewport(tab)
+			}
+			return
+		}
+	}
+}
+
 // handleScroll scrolls the active surface by delta lines.
 func (m *Model) handleScroll(delta int) (tea.Model, tea.Cmd) {
 	// Overlay scroll.

internal/app/mouse_test.go

@@ -4,7 +4,9 @@
 package app
 
 import (
+	"fmt"
 	"testing"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 	zone "github.com/lrstanley/bubblezone"
@@ -33,6 +35,27 @@ func requireZone(t *testing.T, m *Model, id string) *zone.ZoneInfo {
 	return z
 }
 
+// drilldownColX returns the X coordinate of the drilldown column's header
+// zone. This is needed because row clicks also select the column, so tests
+// that expect drilldown must click at the drilldown column's X position.
+func drilldownColX(t *testing.T, m *Model, tab *Tab) int {
+	t.Helper()
+	m.View()
+	width := m.effectiveWidth()
+	normalSep := m.styles.TableSeparator().Render(" \u2502 ")
+	vp := computeTableViewport(tab, width, normalSep, m.cur.Symbol())
+	for vi, fi := range vp.VisToFull {
+		if fi < len(tab.Specs) && tab.Specs[fi].Kind == cellDrilldown {
+			z := m.zones.Get(fmt.Sprintf("%s%d", zoneCol, vi))
+			if z != nil && !z.IsZero() {
+				return z.StartX
+			}
+		}
+	}
+	t.Skip("drilldown column zone not rendered")
+	return 0
+}
+
 // TestTabClickSwitchesTab verifies that clicking on a tab changes the
 // active tab, simulating a real user left-click on tab zone markers.
 func TestTabClickSwitchesTab(t *testing.T) {
@@ -79,6 +102,31 @@ func TestRowClickMovesCursor(t *testing.T) {
 	assert.Equal(t, 1, tab.Table.Cursor(), "clicking row-1 should move cursor to row 1")
 }
 
+// TestRowClickSelectsColumn verifies that clicking on a cell within a row
+// also moves the column cursor to the clicked column.
+func TestRowClickSelectsColumn(t *testing.T) {
+	t.Parallel()
+	m := newTestModelWithDemoData(t, 42)
+
+	tab := m.effectiveTab()
+	require.NotNil(t, tab)
+	require.Greater(t, len(tab.CellRows), 1, "need at least 2 rows")
+	require.Greater(t, len(tab.Specs), 1, "need at least 2 columns")
+
+	tab.Table.SetCursor(0)
+	tab.ColCursor = 0
+
+	// Get the second column header zone for its X range.
+	colZone := requireZone(t, m, "col-1")
+	// Get a row zone for its Y range.
+	rowZone := requireZone(t, m, "row-1")
+
+	// Click at the X of column 1, Y of row 1.
+	sendClick(m, colZone.StartX, rowZone.StartY)
+	assert.Equal(t, 1, tab.Table.Cursor(), "clicking should move row cursor to row 1")
+	assert.NotEqual(t, 0, tab.ColCursor, "clicking in column 1 area should move column cursor")
+}
+
 // TestScrollWheelMovesCursor verifies that scroll wheel events move the
 // table cursor like j/k.
 func TestScrollWheelMovesCursor(t *testing.T) {
@@ -232,9 +280,9 @@ func TestMouseNoOpOnRelease(t *testing.T) {
 	assert.Equal(t, before, m.active, "mouse release should not change state")
 }
 
-// TestSelectedRowClickDrillsDown verifies that clicking an already-selected
-// row triggers drilldown (same as pressing enter).
-func TestSelectedRowClickDrillsDown(t *testing.T) {
+// TestDoubleClickRowDrillsDown verifies that double-clicking a row triggers
+// drilldown (same as pressing enter).
+func TestDoubleClickRowDrillsDown(t *testing.T) {
 	t.Parallel()
 	m := newTestModelWithDemoData(t, 42)
 
@@ -255,10 +303,115 @@ func TestSelectedRowClickDrillsDown(t *testing.T) {
 	}
 
 	tab.Table.SetCursor(0)
+	colX := drilldownColX(t, m, tab)
 	z := requireZone(t, m, "row-0")
 
-	sendClick(m, z.StartX, z.StartY)
-	assert.True(t, m.inDetail(), "clicking selected row should trigger drilldown")
+	// First click selects (already selected, but records the click).
+	sendClick(m, colX, z.StartY)
+	assert.False(t, m.inDetail(), "single click should not trigger drilldown")
+
+	// Second click within threshold triggers drilldown.
+	z = requireZone(t, m, "row-0")
+	sendClick(m, colX, z.StartY)
+	assert.True(t, m.inDetail(), "double-click should trigger drilldown")
+}
+
+// TestSingleClickOnSelectedRowDoesNotDrill verifies that a single click on
+// an already-selected row does not trigger drilldown.
+func TestSingleClickOnSelectedRowDoesNotDrill(t *testing.T) {
+	t.Parallel()
+	m := newTestModelWithDemoData(t, 42)
+
+	tab := m.effectiveTab()
+	require.NotNil(t, tab)
+	require.NotEmpty(t, tab.CellRows)
+
+	hasDrilldown := false
+	for i, spec := range tab.Specs {
+		if spec.Kind == cellDrilldown {
+			tab.ColCursor = i
+			hasDrilldown = true
+			break
+		}
+	}
+	if !hasDrilldown {
+		t.Skip("no drilldown column available")
+	}
+
+	tab.Table.SetCursor(0)
+	colX := drilldownColX(t, m, tab)
+	z := requireZone(t, m, "row-0")
+
+	sendClick(m, colX, z.StartY)
+	assert.False(t, m.inDetail(), "single click on selected row should not drill down")
+}
+
+// TestDoubleClickExpiredDoesNotDrill verifies that two clicks with too much
+// time between them do not trigger drilldown.
+func TestDoubleClickExpiredDoesNotDrill(t *testing.T) {
+	t.Parallel()
+	m := newTestModelWithDemoData(t, 42)
+
+	tab := m.effectiveTab()
+	require.NotNil(t, tab)
+	require.NotEmpty(t, tab.CellRows)
+
+	hasDrilldown := false
+	for i, spec := range tab.Specs {
+		if spec.Kind == cellDrilldown {
+			tab.ColCursor = i
+			hasDrilldown = true
+			break
+		}
+	}
+	if !hasDrilldown {
+		t.Skip("no drilldown column available")
+	}
+
+	tab.Table.SetCursor(0)
+	colX := drilldownColX(t, m, tab)
+	z := requireZone(t, m, "row-0")
+
+	sendClick(m, colX, z.StartY)
+	// Simulate an expired click by backdating the recorded time.
+	m.lastRowClick.at = m.lastRowClick.at.Add(-time.Second)
+
+	z = requireZone(t, m, "row-0")
+	sendClick(m, colX, z.StartY)
+	assert.False(t, m.inDetail(), "expired double-click should not trigger drilldown")
+}
+
+// TestDoubleClickDifferentRowDoesNotDrill verifies that clicking two
+// different rows in quick succession does not trigger drilldown.
+func TestDoubleClickDifferentRowDoesNotDrill(t *testing.T) {
+	t.Parallel()
+	m := newTestModelWithDemoData(t, 42)
+
+	tab := m.effectiveTab()
+	require.NotNil(t, tab)
+	require.Greater(t, len(tab.CellRows), 1, "need at least 2 rows")
+
+	hasDrilldown := false
+	for i, spec := range tab.Specs {
+		if spec.Kind == cellDrilldown {
+			tab.ColCursor = i
+			hasDrilldown = true
+			break
+		}
+	}
+	if !hasDrilldown {
+		t.Skip("no drilldown column available")
+	}
+
+	tab.Table.SetCursor(0)
+	colX := drilldownColX(t, m, tab)
+	z0 := requireZone(t, m, "row-0")
+	sendClick(m, colX, z0.StartY)
+
+	z1 := requireZone(t, m, "row-1")
+	sendClick(m, colX, z1.StartY)
+	assert.False(t, m.inDetail(), "clicking different rows should not trigger drilldown")
+	assert.Equal(t, 1, tab.Table.Cursor(), "second click should select row 1")
 }
 
 // TestDashboardScrollWheel verifies that scroll wheel events in the
@@ -281,6 +434,76 @@ func TestDashboardScrollWheel(t *testing.T) {
 	assert.Equal(t, 0, m.dash.cursor, "scroll up in dashboard should move cursor back")
 }
 
+// TestDashboardRowClickSelects verifies that a single click on a dashboard
+// row selects it without jumping.
+func TestDashboardRowClickSelects(t *testing.T) {
+	t.Parallel()
+	m := newTestModelWithDemoData(t, 42)
+
+	sendKey(m, "D")
+	if !m.dashboardVisible() {
+		t.Skip("dashboard has no data to display")
+	}
+	require.Greater(t, len(m.dash.nav), 1, "need multiple dashboard nav items")
+
+	m.dash.cursor = 0
+	// Render once to populate all zones including overlay.
+	m.View()
+	oz := m.zones.Get(zoneOverlay)
+	if oz == nil || oz.IsZero() {
+		t.Skip("overlay zone not rendered")
+	}
+	z := requireZone(t, m, "dash-1")
+
+	sendClick(m, z.StartX, z.StartY)
+	assert.True(t, m.dashboardVisible(), "single click should not close dashboard")
+	assert.Equal(t, 1, m.dash.cursor, "single click should move dashboard cursor")
+}
+
+// TestDashboardDoubleClickJumps verifies that double-clicking a dashboard
+// row jumps to the item (closes the dashboard and switches tabs).
+func TestDashboardDoubleClickJumps(t *testing.T) {
+	t.Parallel()
+	m := newTestModelWithDemoData(t, 42)
+
+	sendKey(m, "D")
+	if !m.dashboardVisible() {
+		t.Skip("dashboard has no data to display")
+	}
+	require.Greater(t, len(m.dash.nav), 1, "need multiple dashboard nav items")
+
+	// Find a jumpable (non-header, non-info-only) row.
+	jumpIdx := -1
+	for i, nav := range m.dash.nav {
+		if !nav.IsHeader && !nav.InfoOnly {
+			jumpIdx = i
+			break
+		}
+	}
+	if jumpIdx < 0 {
+		t.Skip("no jumpable dashboard row")
+	}
+
+	m.dash.cursor = 0
+	// Render once to populate all zones including overlay.
+	m.View()
+	oz := m.zones.Get(zoneOverlay)
+	if oz == nil || oz.IsZero() {
+		t.Skip("overlay zone not rendered")
+	}
+	z := requireZone(t, m, fmt.Sprintf("dash-%d", jumpIdx))
+
+	// First click selects.
+	sendClick(m, z.StartX, z.StartY)
+	require.True(t, m.dashboardVisible(), "single click should keep dashboard open")
+	require.Equal(t, jumpIdx, m.dash.cursor)
+
+	// Second click within threshold jumps.
+	z = requireZone(t, m, fmt.Sprintf("dash-%d", jumpIdx))
+	sendClick(m, z.StartX, z.StartY)
+	assert.False(t, m.dashboardVisible(), "double-click should close dashboard and jump")
+}
+
 // TestDashboardDismissOnOutsideClick verifies that clicking outside the
 // dashboard overlay dismisses it.
 func TestDashboardDismissOnOutsideClick(t *testing.T) {