refactor: project & tag adapters

internal/handlers/tasks.go

···
 }
 
 func (h *TaskHandler) listProjectsInteractive(ctx context.Context) error {
-	projectList := ui.NewProjectList(h.repos.Tasks, ui.ProjectListOptions{})
-	return projectList.Browse(ctx)
+	projectTable := ui.NewProjectListFromTable(h.repos.Tasks, nil, nil, false)
+	return projectTable.Browse(ctx)
 }
 
 // ListTags lists all tags with their task counts
···
 }
 
 func (h *TaskHandler) listTagsInteractive(ctx context.Context) error {
-	tagList := ui.NewTagList(h.repos.Tasks, ui.TagListOptions{})
-	return tagList.Browse(ctx)
+	tagTable := ui.NewTagListFromTable(h.repos.Tasks, nil, nil, false)
+	return tagTable.Browse(ctx)
 }
 
 func (h *TaskHandler) printTask(task *models.Task) {
···
 	}
 }
 
-// formatDuration formats a duration in a human-readable format
 func formatDuration(d time.Duration) string {
 	if d < time.Minute {
 		return fmt.Sprintf("%.0fs", d.Seconds())

internal/ui/data_list.go

···
 	listViewMsg   string
 	listErrorMsg  error
 	listCountMsg  int
-	searchModeMsg bool
 )
 
 type dataListModel struct {
···
 	help        help.Model
 	showingHelp bool
 	totalCount  int
-	currentPage int
 	listOpts    ListOptions
 }
 

internal/ui/data_list_test.go

···
 )
 
 type MockListItem struct {
-	id          int64
 	title       string
 	description string
 	filterValue string
-	created     time.Time
-	modified    time.Time
 }
 
 func (m MockListItem) GetID() int64 {
-	return m.id
+	return 1 // Mock ID
 }
 
 func (m MockListItem) SetID(id int64) {
-	m.id = id
+	// Mock - no-op
 }
 
 func (m MockListItem) GetTableName() string {
···
 }
 
 func (m MockListItem) GetCreatedAt() time.Time {
-	return m.created
+	return time.Time{} // Mock - zero time
 }
 
 func (m MockListItem) SetCreatedAt(t time.Time) {
-	m.created = t
+	// Mock - no-op
 }
 
 func (m MockListItem) GetUpdatedAt() time.Time {
-	return m.modified
+	return time.Time{} // Mock - zero time
 }
 
 func (m MockListItem) SetUpdatedAt(t time.Time) {
-	m.modified = t
+	// Mock - no-op
 }
 
 func (m MockListItem) GetTitle() string {
···
 }
 
 func NewMockItem(id int64, title, description, filterValue string) MockListItem {
-	now := time.Now()
 	return MockListItem{
-		id:          id,
 		title:       title,
 		description: description,
 		filterValue: filterValue,
-		created:     now,
-		modified:    now,
 	}
 }
 

internal/ui/data_table.go

···
 	help        help.Model
 	showingHelp bool
 	totalCount  int
-	currentPage int
 	dataOpts    DataOptions
 }
 

internal/ui/data_table_test.go

···
 )
 
 type MockDataRecord struct {
-	id       int64
-	fields   map[string]any
-	created  time.Time
-	modified time.Time
+	fields map[string]any
 }
 
 func (m MockDataRecord) GetID() int64 {
-	return m.id
+	return 1 // Mock ID
 }
 
 func (m MockDataRecord) SetID(id int64) {
-	m.id = id
+	// Mock - no-op
 }
 
 func (m MockDataRecord) GetTableName() string {
···
 }
 
 func (m MockDataRecord) GetCreatedAt() time.Time {
-	return m.created
+	return time.Time{} // Mock - zero time
 }
 
 func (m MockDataRecord) SetCreatedAt(t time.Time) {
-	m.created = t
+	// Mock - no-op
 }
 
 func (m MockDataRecord) GetUpdatedAt() time.Time {
-	return m.modified
+	return time.Time{} // Mock - zero time
 }
 
 func (m MockDataRecord) SetUpdatedAt(t time.Time) {
-	m.modified = t
+	// Mock - no-op
 }
 
 func (m MockDataRecord) GetField(name string) any {
···
 }
 
 func NewMockRecord(id int64, fields map[string]any) MockDataRecord {
-	now := time.Now()
 	return MockDataRecord{
-		id:       id,
-		fields:   fields,
-		created:  now,
-		modified: now,
+		fields: fields,
 	}
 }
 
···
 	records    []DataRecord
 	loadError  error
 	countError error
-	loadDelay  bool
 }
 
 func (m *MockDataSource) Load(ctx context.Context, opts DataOptions) ([]DataRecord, error) {

internal/ui/project_list.go

···
-package ui
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/charmbracelet/bubbles/help"
-	"github.com/charmbracelet/bubbles/key"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/stormlightlabs/noteleaf/internal/repo"
-)
-
-// Project list key bindings
-type projectKeyMap struct {
-	Up      key.Binding
-	Down    key.Binding
-	Enter   key.Binding
-	Refresh key.Binding
-	Quit    key.Binding
-	Back    key.Binding
-	Help    key.Binding
-	Numbers []key.Binding
-}
-
-func (k projectKeyMap) ShortHelp() []key.Binding {
-	return []key.Binding{k.Up, k.Down, k.Enter, k.Help, k.Quit}
-}
-
-func (k projectKeyMap) FullHelp() [][]key.Binding {
-	return [][]key.Binding{
-		{k.Up, k.Down, k.Enter, k.Refresh},
-		{k.Help, k.Quit, k.Back},
-	}
-}
-
-var projectKeys = projectKeyMap{
-	Up:      key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
-	Down:    key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
-	Enter:   key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select project")),
-	Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
-	Quit:    key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
-	Back:    key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
-	Help:    key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
-	Numbers: []key.Binding{
-		key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to project 1")),
-		key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to project 2")),
-		key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to project 3")),
-		key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to project 4")),
-		key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to project 5")),
-		key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to project 6")),
-		key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to project 7")),
-		key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to project 8")),
-		key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to project 9")),
-	},
-}
-
-// ProjectRepository interface for dependency injection in tests
-type ProjectRepository interface {
-	GetProjects(ctx context.Context) ([]repo.ProjectSummary, error)
-}
-
-// ProjectListOptions configures the project list UI behavior
-type ProjectListOptions struct {
-	// Output destination (stdout for interactive, buffer for testing)
-	Output io.Writer
-	// Input source (stdin for interactive, strings reader for testing)
-	Input io.Reader
-	// Enable static mode (no interactive components)
-	Static bool
-}
-
-// ProjectList handles project browsing UI
-type ProjectList struct {
-	repo ProjectRepository
-	opts ProjectListOptions
-}
-
-// NewProjectList creates a new project list UI component
-func NewProjectList(repo ProjectRepository, opts ProjectListOptions) *ProjectList {
-	if opts.Output == nil {
-		opts.Output = os.Stdout
-	}
-	if opts.Input == nil {
-		opts.Input = os.Stdin
-	}
-	return &ProjectList{repo: repo, opts: opts}
-}
-
-type (
-	projectsLoadedMsg []repo.ProjectSummary
-	errorProjectMsg   error
-	projectListModel  struct {
-		projects    []repo.ProjectSummary
-		selected    int
-		err         error
-		repo        ProjectRepository
-		opts        ProjectListOptions
-		keys        projectKeyMap
-		help        help.Model
-		showingHelp bool
-	}
-)
-
-func (m projectListModel) Init() tea.Cmd {
-	return m.loadProjects()
-}
-
-func (m projectListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		if m.showingHelp {
-			switch {
-			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
-				m.showingHelp = false
-				return m, nil
-			}
-			return m, nil
-		}
-
-		switch {
-		case key.Matches(msg, m.keys.Quit):
-			return m, tea.Quit
-		case key.Matches(msg, m.keys.Up):
-			if m.selected > 0 {
-				m.selected--
-			}
-		case key.Matches(msg, m.keys.Down):
-			if m.selected < len(m.projects)-1 {
-				m.selected++
-			}
-		case key.Matches(msg, m.keys.Enter):
-			if len(m.projects) > 0 && m.selected < len(m.projects) {
-				// TODO: navigate to tasks for that project
-				return m, tea.Quit
-			}
-		case key.Matches(msg, m.keys.Refresh):
-			return m, m.loadProjects()
-		case key.Matches(msg, m.keys.Help):
-			m.showingHelp = true
-			return m, nil
-		default:
-			for i, numKey := range m.keys.Numbers {
-				if key.Matches(msg, numKey) && i < len(m.projects) {
-					m.selected = i
-					break
-				}
-			}
-		}
-	case projectsLoadedMsg:
-		m.projects = []repo.ProjectSummary(msg)
-		if m.selected >= len(m.projects) && len(m.projects) > 0 {
-			m.selected = len(m.projects) - 1
-		}
-	case errorProjectMsg:
-		m.err = error(msg)
-	}
-	return m, nil
-}
-
-func (m projectListModel) View() string {
-	var s strings.Builder
-
-	style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
-
-	if m.showingHelp {
-		return m.help.View(m.keys)
-	}
-
-	s.WriteString(TitleColorStyle.Render("Projects"))
-	s.WriteString("\n\n")
-
-	if m.err != nil {
-		s.WriteString(fmt.Sprintf("Error: %s", m.err))
-		return s.String()
-	}
-
-	if len(m.projects) == 0 {
-		s.WriteString("No projects found")
-		s.WriteString("\n\n")
-		s.WriteString(style.Render("Press r to refresh, q to quit"))
-		return s.String()
-	}
-
-	headerLine := fmt.Sprintf("   %-30s %-15s", "Project Name", "Task Count")
-	s.WriteString(HeaderColorStyle.Render(headerLine))
-	s.WriteString("\n")
-	s.WriteString(HeaderColorStyle.Render(strings.Repeat("─", 50)))
-	s.WriteString("\n")
-
-	for i, project := range m.projects {
-		prefix := "   "
-		if i == m.selected {
-			prefix = " > "
-		}
-
-		projectName := project.Name
-		if len(projectName) > 28 {
-			projectName = projectName[:25] + "..."
-		}
-
-		taskCountStr := fmt.Sprintf("%d task%s", project.TaskCount, pluralizeCount(project.TaskCount))
-
-		line := fmt.Sprintf("%s%-30s %-15s", prefix, projectName, taskCountStr)
-
-		if i == m.selected {
-			s.WriteString(SelectedColorStyle.Render(line))
-		} else {
-			s.WriteString(style.Render(line))
-		}
-
-		s.WriteString("\n")
-	}
-
-	s.WriteString("\n")
-	s.WriteString(m.help.View(m.keys))
-
-	return s.String()
-}
-
-func (m projectListModel) loadProjects() tea.Cmd {
-	return func() tea.Msg {
-		projects, err := m.repo.GetProjects(context.Background())
-		if err != nil {
-			return errorProjectMsg(err)
-		}
-
-		return projectsLoadedMsg(projects)
-	}
-}
-
-// Browse opens an interactive TUI for navigating projects
-func (pl *ProjectList) Browse(ctx context.Context) error {
-	if pl.opts.Static {
-		return pl.staticList(ctx)
-	}
-
-	model := projectListModel{
-		repo: pl.repo,
-		opts: pl.opts,
-		keys: projectKeys,
-		help: help.New(),
-	}
-
-	program := tea.NewProgram(model, tea.WithInput(pl.opts.Input), tea.WithOutput(pl.opts.Output))
-
-	_, err := program.Run()
-	return err
-}
-
-func (pl *ProjectList) staticList(ctx context.Context) error {
-	projects, err := pl.repo.GetProjects(ctx)
-	if err != nil {
-		fmt.Fprintf(pl.opts.Output, "Error: %s\n", err)
-		return err
-	}
-
-	fmt.Fprintf(pl.opts.Output, "Projects\n\n")
-
-	if len(projects) == 0 {
-		fmt.Fprintf(pl.opts.Output, "No projects found\n")
-		return nil
-	}
-
-	fmt.Fprintf(pl.opts.Output, "%-30s %-15s\n", "Project Name", "Task Count")
-	fmt.Fprintf(pl.opts.Output, "%s\n", strings.Repeat("─", 50))
-
-	for _, project := range projects {
-		projectName := project.Name
-		if len(projectName) > 28 {
-			projectName = projectName[:25] + "..."
-		}
-
-		taskCountStr := fmt.Sprintf("%d task%s", project.TaskCount, pluralizeCount(project.TaskCount))
-
-		fmt.Fprintf(pl.opts.Output, "%-30s %-15s\n", projectName, taskCountStr)
-	}
-
-	return nil
-}
-
-func pluralizeCount(count int) string {
-	if count == 1 {
-		return ""
-	}
-	return "s"
-}

internal/ui/project_list_adapter.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// ProjectRepository interface for dependency injection in tests
+type ProjectRepository interface {
+	GetProjects(ctx context.Context) ([]repo.ProjectSummary, error)
+}
+
+
+func pluralizeCount(count int) string {
+	if count == 1 {
+		return ""
+	}
+	return "s"
+}
+
+// ProjectSummaryRecord adapts repo.ProjectSummary to work with DataTable
+type ProjectSummaryRecord struct {
+	summary repo.ProjectSummary
+}
+
+func (p *ProjectSummaryRecord) GetField(name string) any {
+	switch name {
+	case "name":
+		return p.summary.Name
+	case "task_count":
+		return p.summary.TaskCount
+	default:
+		return ""
+	}
+}
+
+func (p *ProjectSummaryRecord) GetTableName() string {
+	return "projects"
+}
+
+// Use task count as pseudo-ID since projects don't have IDs
+func (p *ProjectSummaryRecord) GetID() int64             { return int64(p.summary.TaskCount) }
+func (p *ProjectSummaryRecord) SetID(id int64)           {}
+func (p *ProjectSummaryRecord) GetCreatedAt() time.Time  { return time.Time{} }
+func (p *ProjectSummaryRecord) SetCreatedAt(t time.Time) {}
+func (p *ProjectSummaryRecord) GetUpdatedAt() time.Time  { return time.Time{} }
+func (p *ProjectSummaryRecord) SetUpdatedAt(t time.Time) {}
+
+// ProjectDataSource adapts ProjectRepository to work with DataTable
+type ProjectDataSource struct {
+	repo ProjectRepository
+}
+
+func (p *ProjectDataSource) Load(ctx context.Context, opts DataOptions) ([]DataRecord, error) {
+	projects, err := p.repo.GetProjects(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	records := make([]DataRecord, len(projects))
+	for i, project := range projects {
+		records[i] = &ProjectSummaryRecord{summary: project}
+	}
+
+	return records, nil
+}
+
+func (p *ProjectDataSource) Count(ctx context.Context, opts DataOptions) (int, error) {
+	projects, err := p.repo.GetProjects(ctx)
+	if err != nil {
+		return 0, err
+	}
+	return len(projects), nil
+}
+
+// NewProjectDataTable creates a new DataTable for browsing projects
+func NewProjectDataTable(repo ProjectRepository, opts DataTableOptions) *DataTable {
+	if opts.Title == "" {
+		opts.Title = "Projects"
+	}
+
+	if len(opts.Fields) == 0 {
+		opts.Fields = []Field{
+			{
+				Name:  "name",
+				Title: "Project Name",
+				Width: 30,
+			},
+			{
+				Name:  "task_count",
+				Title: "Task Count",
+				Width: 15,
+				Formatter: func(value any) string {
+					if count, ok := value.(int); ok {
+						return fmt.Sprintf("%d task%s", count, pluralizeCount(count))
+					}
+					return fmt.Sprintf("%v", value)
+				},
+			},
+		}
+	}
+
+	source := &ProjectDataSource{repo: repo}
+	return NewDataTable(source, opts)
+}
+
+// NewProjectListFromTable creates a ProjectList-compatible interface using DataTable
+func NewProjectListFromTable(repo ProjectRepository, output io.Writer, input io.Reader, static bool) *DataTable {
+	opts := DataTableOptions{
+		Output: output,
+		Input:  input,
+		Static: static,
+		Title:  "Projects",
+	}
+	return NewProjectDataTable(repo, opts)
+}

internal/ui/project_list_adapter_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// mockProjectRepository implements ProjectRepository for testing
+type mockProjectRepository struct {
+	projects []repo.ProjectSummary
+	err      error
+}
+
+func (m *mockProjectRepository) GetProjects(ctx context.Context) ([]repo.ProjectSummary, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.projects, nil
+}
+
+func TestProjectAdapter(t *testing.T) {
+	t.Run("ProjectSummaryRecord", func(t *testing.T) {
+		summary := repo.ProjectSummary{
+			Name:      "Test Project",
+			TaskCount: 5,
+		}
+		record := &ProjectSummaryRecord{summary: summary}
+
+		t.Run("GetField", func(t *testing.T) {
+			tests := []struct {
+				field    string
+				expected any
+				name     string
+			}{
+				{"name", "Test Project", "should return project name"},
+				{"task_count", 5, "should return task count"},
+				{"unknown", "", "should return empty string for unknown field"},
+			}
+
+			for _, tt := range tests {
+				t.Run(tt.name, func(t *testing.T) {
+					result := record.GetField(tt.field)
+					if result != tt.expected {
+						t.Errorf("GetField(%q) = %v, want %v", tt.field, result, tt.expected)
+					}
+				})
+			}
+		})
+
+		t.Run("ModelInterface", func(t *testing.T) {
+			if record.GetID() != 5 {
+				t.Errorf("GetID() = %d, want 5", record.GetID())
+			}
+
+			if record.GetTableName() != "projects" {
+				t.Errorf("GetTableName() = %q, want 'projects'", record.GetTableName())
+			}
+
+			if !record.GetCreatedAt().IsZero() {
+				t.Error("GetCreatedAt() should return zero time")
+			}
+
+			if !record.GetUpdatedAt().IsZero() {
+				t.Error("GetUpdatedAt() should return zero time")
+			}
+		})
+	})
+
+	t.Run("ProjectDataSource", func(t *testing.T) {
+		t.Run("Load", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "Project 1", TaskCount: 5},
+				{Name: "Project 2", TaskCount: 3},
+			}
+			repo := &mockProjectRepository{projects: projects}
+			source := &ProjectDataSource{repo: repo}
+
+			records, err := source.Load(context.Background(), DataOptions{})
+			if err != nil {
+				t.Fatalf("Load() failed: %v", err)
+			}
+
+			if len(records) != 2 {
+				t.Errorf("Load() returned %d records, want 2", len(records))
+			}
+
+			if records[0].GetField("name") != "Project 1" {
+				t.Errorf("First record name = %v, want 'Project 1'", records[0].GetField("name"))
+			}
+
+			if records[0].GetField("task_count") != 5 {
+				t.Errorf("First record task_count = %v, want 5", records[0].GetField("task_count"))
+			}
+		})
+
+		t.Run("Load_Error", func(t *testing.T) {
+			testErr := fmt.Errorf("test error")
+			repo := &mockProjectRepository{err: testErr}
+			source := &ProjectDataSource{repo: repo}
+
+			_, err := source.Load(context.Background(), DataOptions{})
+			if err != testErr {
+				t.Errorf("Load() error = %v, want %v", err, testErr)
+			}
+		})
+
+		t.Run("Count", func(t *testing.T) {
+			projects := []repo.ProjectSummary{
+				{Name: "Project 1", TaskCount: 5},
+				{Name: "Project 2", TaskCount: 3},
+				{Name: "Project 3", TaskCount: 1},
+			}
+			repo := &mockProjectRepository{projects: projects}
+			source := &ProjectDataSource{repo: repo}
+
+			count, err := source.Count(context.Background(), DataOptions{})
+			if err != nil {
+				t.Fatalf("Count() failed: %v", err)
+			}
+
+			if count != 3 {
+				t.Errorf("Count() = %d, want 3", count)
+			}
+		})
+
+		t.Run("Count_Error", func(t *testing.T) {
+			testErr := fmt.Errorf("test error")
+			repo := &mockProjectRepository{err: testErr}
+			source := &ProjectDataSource{repo: repo}
+
+			_, err := source.Count(context.Background(), DataOptions{})
+			if err != testErr {
+				t.Errorf("Count() error = %v, want %v", err, testErr)
+			}
+		})
+	})
+
+	t.Run("NewProjectDataTable", func(t *testing.T) {
+		repo := &mockProjectRepository{
+			projects: []repo.ProjectSummary{
+				{Name: "Test Project", TaskCount: 2},
+			},
+		}
+
+		opts := DataTableOptions{
+			Output: &bytes.Buffer{},
+			Input:  strings.NewReader("q\n"),
+			Static: true,
+		}
+
+		table := NewProjectDataTable(repo, opts)
+		if table == nil {
+			t.Fatal("NewProjectDataTable() returned nil")
+		}
+
+		emptyOpts := DataTableOptions{
+			Output: &bytes.Buffer{},
+			Input:  strings.NewReader("q\n"),
+			Static: true,
+		}
+
+		table2 := NewProjectDataTable(repo, emptyOpts)
+		if table2 == nil {
+			t.Fatal("NewProjectDataTable() with empty opts returned nil")
+		}
+
+		err := table.Browse(context.Background())
+		if err != nil {
+			t.Errorf("Browse() failed: %v", err)
+		}
+	})
+
+	t.Run("NewProjectListFromTable", func(t *testing.T) {
+		repo := &mockProjectRepository{
+			projects: []repo.ProjectSummary{
+				{Name: "Test Project", TaskCount: 1},
+			},
+		}
+
+		output := &bytes.Buffer{}
+		input := strings.NewReader("q\n")
+
+		table := NewProjectListFromTable(repo, output, input, true)
+		if table == nil {
+			t.Fatal("NewProjectListFromTable() returned nil")
+		}
+
+		err := table.Browse(context.Background())
+		if err != nil {
+			t.Errorf("Browse() failed: %v", err)
+		}
+
+		outputStr := output.String()
+		if !strings.Contains(outputStr, "Projects") {
+			t.Error("Output should contain 'Projects' title")
+		}
+		if !strings.Contains(outputStr, "Test Project") {
+			t.Error("Output should contain project name")
+		}
+		if !strings.Contains(outputStr, "1 task") {
+			t.Error("Output should contain formatted task count")
+		}
+	})
+}

internal/ui/project_list_test.go

···
-package ui
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/stormlightlabs/noteleaf/internal/repo"
-)
-
-// Mock project repository for testing
-type mockProjectRepository struct {
-	projects []repo.ProjectSummary
-	err      error
-}
-
-func (m *mockProjectRepository) GetProjects(ctx context.Context) ([]repo.ProjectSummary, error) {
-	if m.err != nil {
-		return nil, m.err
-	}
-	return m.projects, nil
-}
-
-func TestProjectList(t *testing.T) {
-	t.Run("NewProjectList", func(t *testing.T) {
-		t.Run("creates project list successfully", func(t *testing.T) {
-			mockRepo := &mockProjectRepository{}
-			opts := ProjectListOptions{}
-
-			projectList := NewProjectList(mockRepo, opts)
-
-			if projectList == nil {
-				t.Fatal("ProjectList should not be nil")
-			}
-			if projectList.repo != mockRepo {
-				t.Error("ProjectList repo should be set correctly")
-			}
-		})
-
-		t.Run("sets default options", func(t *testing.T) {
-			mockRepo := &mockProjectRepository{}
-			opts := ProjectListOptions{}
-
-			projectList := NewProjectList(mockRepo, opts)
-
-			if projectList.opts.Output == nil {
-				t.Error("Default output should be set")
-			}
-			if projectList.opts.Input == nil {
-				t.Error("Default input should be set")
-			}
-		})
-
-		t.Run("preserves custom options", func(t *testing.T) {
-			mockRepo := &mockProjectRepository{}
-			output := &bytes.Buffer{}
-			input := strings.NewReader("")
-			opts := ProjectListOptions{
-				Output: output,
-				Input:  input,
-				Static: true,
-			}
-
-			projectList := NewProjectList(mockRepo, opts)
-
-			if projectList.opts.Output != output {
-				t.Error("Custom output should be preserved")
-			}
-			if projectList.opts.Input != input {
-				t.Error("Custom input should be preserved")
-			}
-			if !projectList.opts.Static {
-				t.Error("Static option should be preserved")
-			}
-		})
-	})
-
-	t.Run("StaticList", func(t *testing.T) {
-		t.Run("displays projects correctly", func(t *testing.T) {
-			projects := []repo.ProjectSummary{
-				{Name: "web-app", TaskCount: 5},
-				{Name: "mobile-app", TaskCount: 3},
-				{Name: "documentation", TaskCount: 1},
-			}
-			mockRepo := &mockProjectRepository{projects: projects}
-			output := &bytes.Buffer{}
-			opts := ProjectListOptions{Output: output, Static: true}
-
-			projectList := NewProjectList(mockRepo, opts)
-			err := projectList.Browse(context.Background())
-
-			if err != nil {
-				t.Errorf("Browse should not return error: %v", err)
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "Projects") {
-				t.Error("Output should contain title")
-			}
-			if !strings.Contains(result, "web-app") {
-				t.Error("Output should contain web-app project")
-			}
-			if !strings.Contains(result, "mobile-app") {
-				t.Error("Output should contain mobile-app project")
-			}
-			if !strings.Contains(result, "5 tasks") {
-				t.Error("Output should show correct task count for web-app")
-			}
-			if !strings.Contains(result, "1 task") {
-				t.Error("Output should show singular task for documentation")
-			}
-		})
-
-		t.Run("handles empty project list", func(t *testing.T) {
-			mockRepo := &mockProjectRepository{projects: []repo.ProjectSummary{}}
-			output := &bytes.Buffer{}
-			opts := ProjectListOptions{Output: output, Static: true}
-
-			projectList := NewProjectList(mockRepo, opts)
-			err := projectList.Browse(context.Background())
-
-			if err != nil {
-				t.Errorf("Browse should not return error: %v", err)
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "No projects found") {
-				t.Error("Output should indicate no projects found")
-			}
-		})
-
-		t.Run("handles repository errors", func(t *testing.T) {
-			mockRepo := &mockProjectRepository{err: fmt.Errorf("database error")}
-			output := &bytes.Buffer{}
-			opts := ProjectListOptions{Output: output, Static: true}
-
-			projectList := NewProjectList(mockRepo, opts)
-			err := projectList.Browse(context.Background())
-
-			if err == nil {
-				t.Error("Browse should return error when repository fails")
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "Error:") {
-				t.Error("Output should contain error message")
-			}
-		})
-
-		t.Run("truncates long project names", func(t *testing.T) {
-			projects := []repo.ProjectSummary{
-				{Name: "this-is-a-very-long-project-name-that-should-be-truncated", TaskCount: 2},
-			}
-			mockRepo := &mockProjectRepository{projects: projects}
-			output := &bytes.Buffer{}
-			opts := ProjectListOptions{Output: output, Static: true}
-
-			projectList := NewProjectList(mockRepo, opts)
-			err := projectList.Browse(context.Background())
-
-			if err != nil {
-				t.Errorf("Browse should not return error: %v", err)
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "...") {
-				t.Error("Output should truncate long project names")
-			}
-		})
-	})
-
-	t.Run("ProjectListModel", func(t *testing.T) {
-		t.Run("initializes correctly", func(t *testing.T) {
-			model := projectListModel{
-				selected:    0,
-				showingHelp: false,
-			}
-
-			if model.selected != 0 {
-				t.Error("Initial selection should be 0")
-			}
-			if model.showingHelp {
-				t.Error("Should not be showing help initially")
-			}
-		})
-
-		t.Run("handles key navigation", func(t *testing.T) {
-			projects := []repo.ProjectSummary{
-				{Name: "project1", TaskCount: 1},
-				{Name: "project2", TaskCount: 2},
-				{Name: "project3", TaskCount: 3},
-			}
-
-			model := projectListModel{
-				projects: projects,
-				selected: 1,
-				keys:     projectKeys,
-			}
-
-			// Test down key
-			downMsg := tea.KeyMsg{Type: tea.KeyDown}
-			updatedModel, _ := model.Update(downMsg)
-			if updatedModel.(projectListModel).selected != 2 {
-				t.Error("Down key should move selection down")
-			}
-
-			// Test up key
-			upMsg := tea.KeyMsg{Type: tea.KeyUp}
-			updatedModel, _ = updatedModel.Update(upMsg)
-			if updatedModel.(projectListModel).selected != 1 {
-				t.Error("Up key should move selection up")
-			}
-
-			// Test boundary conditions
-			model.selected = 0
-			updatedModel, _ = model.Update(upMsg)
-			if updatedModel.(projectListModel).selected != 0 {
-				t.Error("Up key should not move selection below 0")
-			}
-
-			model.selected = len(projects) - 1
-			updatedModel, _ = model.Update(downMsg)
-			if updatedModel.(projectListModel).selected != len(projects)-1 {
-				t.Error("Down key should not move selection beyond list length")
-			}
-		})
-
-		t.Run("handles number key selection", func(t *testing.T) {
-			projects := []repo.ProjectSummary{
-				{Name: "project1", TaskCount: 1},
-				{Name: "project2", TaskCount: 2},
-				{Name: "project3", TaskCount: 3},
-			}
-
-			model := projectListModel{
-				projects: projects,
-				selected: 0,
-				keys:     projectKeys,
-			}
-
-			// Test number key 3 (index 2)
-			keyMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'3'}}
-			updatedModel, _ := model.Update(keyMsg)
-			if updatedModel.(projectListModel).selected != 2 {
-				t.Error("Number key 3 should select index 2")
-			}
-		})
-
-		t.Run("handles help toggle", func(t *testing.T) {
-			model := projectListModel{
-				keys: projectKeys,
-			}
-
-			// Toggle help on
-			helpMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'?'}}
-			updatedModel, _ := model.Update(helpMsg)
-			if !updatedModel.(projectListModel).showingHelp {
-				t.Error("Help key should show help")
-			}
-
-			// Toggle help off
-			updatedModel, _ = updatedModel.Update(helpMsg)
-			if updatedModel.(projectListModel).showingHelp {
-				t.Error("Help key should hide help when already showing")
-			}
-		})
-
-		t.Run("handles projects loaded message", func(t *testing.T) {
-			projects := []repo.ProjectSummary{
-				{Name: "new-project", TaskCount: 5},
-			}
-
-			model := projectListModel{
-				selected: 5, // Invalid selection
-			}
-
-			msg := projectsLoadedMsg(projects)
-			updatedModel, _ := model.Update(msg)
-			resultModel := updatedModel.(projectListModel)
-
-			if len(resultModel.projects) != 1 {
-				t.Error("Projects should be loaded correctly")
-			}
-			if resultModel.selected != 0 {
-				t.Error("Selection should be reset to valid range")
-			}
-		})
-
-		t.Run("handles error message", func(t *testing.T) {
-			model := projectListModel{}
-
-			errorMsg := errorProjectMsg(fmt.Errorf("test error"))
-			updatedModel, _ := model.Update(errorMsg)
-			resultModel := updatedModel.(projectListModel)
-
-			if resultModel.err == nil {
-				t.Error("Error should be set")
-			}
-			if resultModel.err.Error() != "test error" {
-				t.Errorf("Expected 'test error', got '%s'", resultModel.err.Error())
-			}
-		})
-
-		t.Run("view renders correctly", func(t *testing.T) {
-			projects := []repo.ProjectSummary{
-				{Name: "web-app", TaskCount: 5},
-				{Name: "mobile-app", TaskCount: 1},
-			}
-
-			model := projectListModel{
-				projects: projects,
-				selected: 0,
-				keys:     projectKeys,
-			}
-
-			view := model.View()
-			if !strings.Contains(view, "Projects") {
-				t.Error("View should contain title")
-			}
-			if !strings.Contains(view, "web-app") {
-				t.Error("View should contain project names")
-			}
-			if !strings.Contains(view, "5 tasks") {
-				t.Error("View should show task counts")
-			}
-			if !strings.Contains(view, "1 task") {
-				t.Error("View should show singular task count")
-			}
-		})
-
-		t.Run("view handles empty state", func(t *testing.T) {
-			model := projectListModel{
-				projects: []repo.ProjectSummary{},
-			}
-
-			view := model.View()
-			if !strings.Contains(view, "No projects found") {
-				t.Error("View should show empty state message")
-			}
-		})
-
-		t.Run("view handles error state", func(t *testing.T) {
-			model := projectListModel{
-				err: fmt.Errorf("test error"),
-			}
-
-			view := model.View()
-			if !strings.Contains(view, "Error:") {
-				t.Error("View should show error message")
-			}
-		})
-	})
-
-	t.Run("PluralizeCount", func(t *testing.T) {
-		t.Run("returns empty string for singular", func(t *testing.T) {
-			result := pluralizeCount(1)
-			if result != "" {
-				t.Errorf("Expected empty string for 1, got '%s'", result)
-			}
-		})
-
-		t.Run("returns 's' for plural", func(t *testing.T) {
-			testCases := []int{0, 2, 10, 100}
-			for _, count := range testCases {
-				result := pluralizeCount(count)
-				if result != "s" {
-					t.Errorf("Expected 's' for %d, got '%s'", count, result)
-				}
-			}
-		})
-	})
-}

internal/ui/tag_list.go

···
-package ui
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"github.com/charmbracelet/bubbles/help"
-	"github.com/charmbracelet/bubbles/key"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/stormlightlabs/noteleaf/internal/repo"
-)
-
-// Tag list key bindings
-type tagKeyMap struct {
-	Up      key.Binding
-	Down    key.Binding
-	Enter   key.Binding
-	Refresh key.Binding
-	Quit    key.Binding
-	Back    key.Binding
-	Help    key.Binding
-	Numbers []key.Binding
-}
-
-func (k tagKeyMap) ShortHelp() []key.Binding {
-	return []key.Binding{k.Up, k.Down, k.Enter, k.Help, k.Quit}
-}
-
-func (k tagKeyMap) FullHelp() [][]key.Binding {
-	return [][]key.Binding{
-		{k.Up, k.Down, k.Enter, k.Refresh},
-		{k.Help, k.Quit, k.Back},
-	}
-}
-
-var tagKeys = tagKeyMap{
-	Up:      key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "move up")),
-	Down:    key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "move down")),
-	Enter:   key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "select tag")),
-	Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
-	Quit:    key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
-	Back:    key.NewBinding(key.WithKeys("esc", "backspace"), key.WithHelp("esc", "back")),
-	Help:    key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
-	Numbers: []key.Binding{
-		key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "jump to tag 1")),
-		key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "jump to tag 2")),
-		key.NewBinding(key.WithKeys("3"), key.WithHelp("3", "jump to tag 3")),
-		key.NewBinding(key.WithKeys("4"), key.WithHelp("4", "jump to tag 4")),
-		key.NewBinding(key.WithKeys("5"), key.WithHelp("5", "jump to tag 5")),
-		key.NewBinding(key.WithKeys("6"), key.WithHelp("6", "jump to tag 6")),
-		key.NewBinding(key.WithKeys("7"), key.WithHelp("7", "jump to tag 7")),
-		key.NewBinding(key.WithKeys("8"), key.WithHelp("8", "jump to tag 8")),
-		key.NewBinding(key.WithKeys("9"), key.WithHelp("9", "jump to tag 9")),
-	},
-}
-
-type (
-	// TagRepository interface for dependency injection in tests
-	TagRepository interface {
-		GetTags(ctx context.Context) ([]repo.TagSummary, error)
-	}
-
-	// TagListOptions configures the tag list UI behavior
-	TagListOptions struct {
-		// Output destination (stdout for interactive, buffer for testing)
-		Output io.Writer
-		// Input source (stdin for interactive, strings reader for testing)
-		Input io.Reader
-		// Enable static mode (no interactive components)
-		Static bool
-	}
-
-	// TagList handles tag browsing UI
-	TagList struct {
-		repo TagRepository
-		opts TagListOptions
-	}
-)
-
-// NewTagList creates a new tag list UI component
-func NewTagList(repo TagRepository, opts TagListOptions) *TagList {
-	if opts.Output == nil {
-		opts.Output = os.Stdout
-	}
-	if opts.Input == nil {
-		opts.Input = os.Stdin
-	}
-	return &TagList{repo: repo, opts: opts}
-}
-
-type (
-	tagsLoadedMsg []repo.TagSummary
-	errorTagMsg   error
-	tagListModel  struct {
-		tags        []repo.TagSummary
-		selected    int
-		err         error
-		repo        TagRepository
-		opts        TagListOptions
-		keys        tagKeyMap
-		help        help.Model
-		showingHelp bool
-	}
-)
-
-func (m tagListModel) Init() tea.Cmd {
-	return m.loadTags()
-}
-
-func (m tagListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		if m.showingHelp {
-			switch {
-			case key.Matches(msg, m.keys.Back) || key.Matches(msg, m.keys.Quit) || key.Matches(msg, m.keys.Help):
-				m.showingHelp = false
-				return m, nil
-			}
-			return m, nil
-		}
-
-		switch {
-		case key.Matches(msg, m.keys.Quit):
-			return m, tea.Quit
-		case key.Matches(msg, m.keys.Up):
-			if m.selected > 0 {
-				m.selected--
-			}
-		case key.Matches(msg, m.keys.Down):
-			if m.selected < len(m.tags)-1 {
-				m.selected++
-			}
-		case key.Matches(msg, m.keys.Enter):
-			if len(m.tags) > 0 && m.selected < len(m.tags) {
-				// For now, just show the selected tag name
-				// In a real implementation, this might navigate to tasks with that tag
-				return m, tea.Quit
-			}
-		case key.Matches(msg, m.keys.Refresh):
-			return m, m.loadTags()
-		case key.Matches(msg, m.keys.Help):
-			m.showingHelp = true
-			return m, nil
-		default:
-			// Handle number keys for quick selection
-			for i, numKey := range m.keys.Numbers {
-				if key.Matches(msg, numKey) && i < len(m.tags) {
-					m.selected = i
-					break
-				}
-			}
-		}
-	case tagsLoadedMsg:
-		m.tags = []repo.TagSummary(msg)
-		if m.selected >= len(m.tags) && len(m.tags) > 0 {
-			m.selected = len(m.tags) - 1
-		}
-	case errorTagMsg:
-		m.err = error(msg)
-	}
-	return m, nil
-}
-
-func (m tagListModel) View() string {
-	var s strings.Builder
-
-	style := lipgloss.NewStyle().Foreground(lipgloss.Color(Squid.Hex()))
-
-	if m.showingHelp {
-		return m.help.View(m.keys)
-	}
-
-	s.WriteString(TitleColorStyle.Render("Tags"))
-	s.WriteString("\n\n")
-
-	if m.err != nil {
-		s.WriteString(fmt.Sprintf("Error: %s", m.err))
-		return s.String()
-	}
-
-	if len(m.tags) == 0 {
-		s.WriteString("No tags found")
-		s.WriteString("\n\n")
-		s.WriteString(style.Render("Press r to refresh, q to quit"))
-		return s.String()
-	}
-
-	headerLine := fmt.Sprintf("   %-25s %-15s", "Tag Name", "Task Count")
-	s.WriteString(HeaderColorStyle.Render(headerLine))
-	s.WriteString("\n")
-	s.WriteString(HeaderColorStyle.Render(strings.Repeat("─", 45)))
-	s.WriteString("\n")
-
-	for i, tag := range m.tags {
-		prefix := "   "
-		if i == m.selected {
-			prefix = " > "
-		}
-
-		tagName := tag.Name
-		if len(tagName) > 23 {
-			tagName = tagName[:20] + "..."
-		}
-
-		taskCountStr := fmt.Sprintf("%d task%s", tag.TaskCount, pluralizeCount(tag.TaskCount))
-
-		line := fmt.Sprintf("%s%-25s %-15s", prefix, tagName, taskCountStr)
-
-		if i == m.selected {
-			s.WriteString(SelectedColorStyle.Render(line))
-		} else {
-			s.WriteString(style.Render(line))
-		}
-
-		s.WriteString("\n")
-	}
-
-	s.WriteString("\n")
-	s.WriteString(m.help.View(m.keys))
-
-	return s.String()
-}
-
-func (m tagListModel) loadTags() tea.Cmd {
-	return func() tea.Msg {
-		tags, err := m.repo.GetTags(context.Background())
-		if err != nil {
-			return errorTagMsg(err)
-		}
-
-		return tagsLoadedMsg(tags)
-	}
-}
-
-// Browse opens an interactive TUI for navigating tags
-func (tl *TagList) Browse(ctx context.Context) error {
-	if tl.opts.Static {
-		return tl.staticList(ctx)
-	}
-
-	model := tagListModel{
-		repo: tl.repo,
-		opts: tl.opts,
-		keys: tagKeys,
-		help: help.New(),
-	}
-
-	program := tea.NewProgram(model, tea.WithInput(tl.opts.Input), tea.WithOutput(tl.opts.Output))
-
-	_, err := program.Run()
-	return err
-}
-
-func (tl *TagList) staticList(ctx context.Context) error {
-	tags, err := tl.repo.GetTags(ctx)
-	if err != nil {
-		fmt.Fprintf(tl.opts.Output, "Error: %s\n", err)
-		return err
-	}
-
-	fmt.Fprintf(tl.opts.Output, "Tags\n\n")
-
-	if len(tags) == 0 {
-		fmt.Fprintf(tl.opts.Output, "No tags found\n")
-		return nil
-	}
-
-	fmt.Fprintf(tl.opts.Output, "%-25s %-15s\n", "Tag Name", "Task Count")
-	fmt.Fprintf(tl.opts.Output, "%s\n", strings.Repeat("─", 45))
-
-	for _, tag := range tags {
-		tagName := tag.Name
-		if len(tagName) > 23 {
-			tagName = tagName[:20] + "..."
-		}
-
-		taskCountStr := fmt.Sprintf("%d task%s", tag.TaskCount, pluralizeCount(tag.TaskCount))
-
-		fmt.Fprintf(tl.opts.Output, "%-25s %-15s\n", tagName, taskCountStr)
-	}
-
-	return nil
-}

internal/ui/tag_list_adapter.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// TagRepository interface for dependency injection in tests
+type TagRepository interface {
+	GetTags(ctx context.Context) ([]repo.TagSummary, error)
+}
+
+
+// TagSummaryRecord adapts repo.TagSummary to work with DataTable
+type TagSummaryRecord struct {
+	summary repo.TagSummary
+}
+
+func (t *TagSummaryRecord) GetField(name string) any {
+	switch name {
+	case "name":
+		return t.summary.Name
+	case "task_count":
+		return t.summary.TaskCount
+	default:
+		return ""
+	}
+}
+
+func (t *TagSummaryRecord) GetTableName() string {
+	return "tags"
+}
+
+// Use task count as pseudo-ID since tags don't have IDs
+func (t *TagSummaryRecord) GetID() int64                { return int64(t.summary.TaskCount) }
+func (t *TagSummaryRecord) SetID(id int64)              {}
+func (t *TagSummaryRecord) GetCreatedAt() time.Time     { return time.Time{} }
+func (t *TagSummaryRecord) SetCreatedAt(time time.Time) {}
+func (t *TagSummaryRecord) GetUpdatedAt() time.Time     { return time.Time{} }
+func (t *TagSummaryRecord) SetUpdatedAt(time time.Time) {}
+
+// TagDataSource adapts TagRepository to work with DataTable
+type TagDataSource struct {
+	repo TagRepository
+}
+
+func (t *TagDataSource) Load(ctx context.Context, opts DataOptions) ([]DataRecord, error) {
+	tags, err := t.repo.GetTags(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	records := make([]DataRecord, len(tags))
+	for i, tag := range tags {
+		records[i] = &TagSummaryRecord{summary: tag}
+	}
+
+	return records, nil
+}
+
+func (t *TagDataSource) Count(ctx context.Context, opts DataOptions) (int, error) {
+	tags, err := t.repo.GetTags(ctx)
+	if err != nil {
+		return 0, err
+	}
+	return len(tags), nil
+}
+
+// NewTagDataTable creates a new DataTable for browsing tags
+func NewTagDataTable(repo TagRepository, opts DataTableOptions) *DataTable {
+	if opts.Title == "" {
+		opts.Title = "Tags"
+	}
+
+	if len(opts.Fields) == 0 {
+		opts.Fields = []Field{
+			{
+				Name:  "name",
+				Title: "Tag Name",
+				Width: 25,
+			},
+			{
+				Name:  "task_count",
+				Title: "Task Count",
+				Width: 15,
+				Formatter: func(value any) string {
+					if count, ok := value.(int); ok {
+						return fmt.Sprintf("%d task%s", count, pluralizeCount(count))
+					}
+					return fmt.Sprintf("%v", value)
+				},
+			},
+		}
+	}
+
+	source := &TagDataSource{repo: repo}
+	return NewDataTable(source, opts)
+}
+
+// NewTagListFromTable creates a TagList-compatible interface using DataTable
+func NewTagListFromTable(repo TagRepository, output io.Writer, input io.Reader, static bool) *DataTable {
+	opts := DataTableOptions{
+		Output: output,
+		Input:  input,
+		Static: static,
+		Title:  "Tags",
+	}
+	return NewTagDataTable(repo, opts)
+}

internal/ui/tag_list_adapter_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+// mockTagRepository implements TagRepository for testing
+type mockTagRepository struct {
+	tags []repo.TagSummary
+	err  error
+}
+
+func (m *mockTagRepository) GetTags(ctx context.Context) ([]repo.TagSummary, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.tags, nil
+}
+
+func TestTagAdapter(t *testing.T) {
+	t.Run("TagSummaryRecord", func(t *testing.T) {
+		summary := repo.TagSummary{
+			Name:      "work",
+			TaskCount: 8,
+		}
+		record := &TagSummaryRecord{summary: summary}
+
+		t.Run("GetField", func(t *testing.T) {
+			tests := []struct {
+				field    string
+				expected any
+				name     string
+			}{
+				{"name", "work", "should return tag name"},
+				{"task_count", 8, "should return task count"},
+				{"unknown", "", "should return empty string for unknown field"},
+			}
+
+			for _, tt := range tests {
+				t.Run(tt.name, func(t *testing.T) {
+					result := record.GetField(tt.field)
+					if result != tt.expected {
+						t.Errorf("GetField(%q) = %v, want %v", tt.field, result, tt.expected)
+					}
+				})
+			}
+		})
+
+		t.Run("ModelInterface", func(t *testing.T) {
+			if record.GetID() != 8 {
+				t.Errorf("GetID() = %d, want 8", record.GetID())
+			}
+
+			if record.GetTableName() != "tags" {
+				t.Errorf("GetTableName() = %q, want 'tags'", record.GetTableName())
+			}
+
+			if !record.GetCreatedAt().IsZero() {
+				t.Error("GetCreatedAt() should return zero time")
+			}
+
+			if !record.GetUpdatedAt().IsZero() {
+				t.Error("GetUpdatedAt() should return zero time")
+			}
+		})
+	})
+
+	t.Run("TagDataSource", func(t *testing.T) {
+		t.Run("Load", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "work", TaskCount: 5},
+				{Name: "personal", TaskCount: 3},
+			}
+			repo := &mockTagRepository{tags: tags}
+			source := &TagDataSource{repo: repo}
+
+			records, err := source.Load(context.Background(), DataOptions{})
+			if err != nil {
+				t.Fatalf("Load() failed: %v", err)
+			}
+
+			if len(records) != 2 {
+				t.Errorf("Load() returned %d records, want 2", len(records))
+			}
+
+			if records[0].GetField("name") != "work" {
+				t.Errorf("First record name = %v, want 'work'", records[0].GetField("name"))
+			}
+
+			if records[0].GetField("task_count") != 5 {
+				t.Errorf("First record task_count = %v, want 5", records[0].GetField("task_count"))
+			}
+		})
+
+		t.Run("Load_Error", func(t *testing.T) {
+			testErr := fmt.Errorf("test error")
+			repo := &mockTagRepository{err: testErr}
+			source := &TagDataSource{repo: repo}
+
+			_, err := source.Load(context.Background(), DataOptions{})
+			if err != testErr {
+				t.Errorf("Load() error = %v, want %v", err, testErr)
+			}
+		})
+
+		t.Run("Count", func(t *testing.T) {
+			tags := []repo.TagSummary{
+				{Name: "work", TaskCount: 5},
+				{Name: "personal", TaskCount: 3},
+				{Name: "urgent", TaskCount: 1},
+			}
+			repo := &mockTagRepository{tags: tags}
+			source := &TagDataSource{repo: repo}
+
+			count, err := source.Count(context.Background(), DataOptions{})
+			if err != nil {
+				t.Fatalf("Count() failed: %v", err)
+			}
+
+			if count != 3 {
+				t.Errorf("Count() = %d, want 3", count)
+			}
+		})
+
+		t.Run("Count_Error", func(t *testing.T) {
+			testErr := fmt.Errorf("test error")
+			repo := &mockTagRepository{err: testErr}
+			source := &TagDataSource{repo: repo}
+
+			_, err := source.Count(context.Background(), DataOptions{})
+			if err != testErr {
+				t.Errorf("Count() error = %v, want %v", err, testErr)
+			}
+		})
+	})
+
+	t.Run("NewTagDataTable", func(t *testing.T) {
+		repo := &mockTagRepository{
+			tags: []repo.TagSummary{
+				{Name: "work", TaskCount: 4},
+			},
+		}
+
+		opts := DataTableOptions{
+			Output: &bytes.Buffer{},
+			Input:  strings.NewReader("q\n"),
+			Static: true,
+		}
+
+		table := NewTagDataTable(repo, opts)
+		if table == nil {
+			t.Fatal("NewTagDataTable() returned nil")
+		}
+
+		err := table.Browse(context.Background())
+		if err != nil {
+			t.Errorf("Browse() failed: %v", err)
+		}
+	})
+
+	t.Run("NewTagListFromTable", func(t *testing.T) {
+		repo := &mockTagRepository{
+			tags: []repo.TagSummary{
+				{Name: "urgent", TaskCount: 1},
+			},
+		}
+
+		output := &bytes.Buffer{}
+		input := strings.NewReader("q\n")
+
+		table := NewTagListFromTable(repo, output, input, true)
+		if table == nil {
+			t.Fatal("NewTagListFromTable() returned nil")
+		}
+
+		err := table.Browse(context.Background())
+		if err != nil {
+			t.Errorf("Browse() failed: %v", err)
+		}
+
+		outputStr := output.String()
+		if !strings.Contains(outputStr, "Tags") {
+			t.Error("Output should contain 'Tags' title")
+		}
+		if !strings.Contains(outputStr, "urgent") {
+			t.Error("Output should contain tag name")
+		}
+		if !strings.Contains(outputStr, "1 task") {
+			t.Error("Output should contain formatted task count")
+		}
+	})
+}

internal/ui/tag_list_test.go

···
-package ui
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/stormlightlabs/noteleaf/internal/repo"
-)
-
-// Mock tag repository for testing
-type mockTagRepository struct {
-	tags []repo.TagSummary
-	err  error
-}
-
-func (m *mockTagRepository) GetTags(ctx context.Context) ([]repo.TagSummary, error) {
-	if m.err != nil {
-		return nil, m.err
-	}
-	return m.tags, nil
-}
-
-func TestTagList(t *testing.T) {
-	t.Run("NewTagList", func(t *testing.T) {
-		t.Run("creates tag list successfully", func(t *testing.T) {
-			mockRepo := &mockTagRepository{}
-			opts := TagListOptions{}
-
-			tagList := NewTagList(mockRepo, opts)
-
-			if tagList == nil {
-				t.Fatal("TagList should not be nil")
-			}
-			if tagList.repo != mockRepo {
-				t.Error("TagList repo should be set correctly")
-			}
-		})
-
-		t.Run("sets default options", func(t *testing.T) {
-			mockRepo := &mockTagRepository{}
-			opts := TagListOptions{}
-
-			tagList := NewTagList(mockRepo, opts)
-
-			if tagList.opts.Output == nil {
-				t.Error("Default output should be set")
-			}
-			if tagList.opts.Input == nil {
-				t.Error("Default input should be set")
-			}
-		})
-
-		t.Run("preserves custom options", func(t *testing.T) {
-			mockRepo := &mockTagRepository{}
-			output := &bytes.Buffer{}
-			input := strings.NewReader("")
-			opts := TagListOptions{
-				Output: output,
-				Input:  input,
-				Static: true,
-			}
-
-			tagList := NewTagList(mockRepo, opts)
-
-			if tagList.opts.Output != output {
-				t.Error("Custom output should be preserved")
-			}
-			if tagList.opts.Input != input {
-				t.Error("Custom input should be preserved")
-			}
-			if !tagList.opts.Static {
-				t.Error("Static option should be preserved")
-			}
-		})
-	})
-
-	t.Run("StaticList", func(t *testing.T) {
-		t.Run("displays tags correctly", func(t *testing.T) {
-			tags := []repo.TagSummary{
-				{Name: "frontend", TaskCount: 5},
-				{Name: "backend", TaskCount: 3},
-				{Name: "urgent", TaskCount: 1},
-			}
-			mockRepo := &mockTagRepository{tags: tags}
-			output := &bytes.Buffer{}
-			opts := TagListOptions{Output: output, Static: true}
-
-			tagList := NewTagList(mockRepo, opts)
-			err := tagList.Browse(context.Background())
-
-			if err != nil {
-				t.Errorf("Browse should not return error: %v", err)
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "Tags") {
-				t.Error("Output should contain title")
-			}
-			if !strings.Contains(result, "frontend") {
-				t.Error("Output should contain frontend tag")
-			}
-			if !strings.Contains(result, "backend") {
-				t.Error("Output should contain backend tag")
-			}
-			if !strings.Contains(result, "5 tasks") {
-				t.Error("Output should show correct task count for frontend")
-			}
-			if !strings.Contains(result, "1 task") {
-				t.Error("Output should show singular task for urgent")
-			}
-		})
-
-		t.Run("handles empty tag list", func(t *testing.T) {
-			mockRepo := &mockTagRepository{tags: []repo.TagSummary{}}
-			output := &bytes.Buffer{}
-			opts := TagListOptions{Output: output, Static: true}
-
-			tagList := NewTagList(mockRepo, opts)
-			err := tagList.Browse(context.Background())
-
-			if err != nil {
-				t.Errorf("Browse should not return error: %v", err)
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "No tags found") {
-				t.Error("Output should indicate no tags found")
-			}
-		})
-
-		t.Run("handles repository errors", func(t *testing.T) {
-			mockRepo := &mockTagRepository{err: fmt.Errorf("database error")}
-			output := &bytes.Buffer{}
-			opts := TagListOptions{Output: output, Static: true}
-
-			tagList := NewTagList(mockRepo, opts)
-			err := tagList.Browse(context.Background())
-
-			if err == nil {
-				t.Error("Browse should return error when repository fails")
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "Error:") {
-				t.Error("Output should contain error message")
-			}
-		})
-
-		t.Run("truncates long tag names", func(t *testing.T) {
-			tags := []repo.TagSummary{
-				{Name: "this-is-a-very-long-tag-name-that-should-be-truncated", TaskCount: 2},
-			}
-			mockRepo := &mockTagRepository{tags: tags}
-			output := &bytes.Buffer{}
-			opts := TagListOptions{Output: output, Static: true}
-
-			tagList := NewTagList(mockRepo, opts)
-			err := tagList.Browse(context.Background())
-
-			if err != nil {
-				t.Errorf("Browse should not return error: %v", err)
-			}
-
-			result := output.String()
-			if !strings.Contains(result, "...") {
-				t.Error("Output should truncate long tag names")
-			}
-		})
-	})
-
-	t.Run("TagListModel", func(t *testing.T) {
-		t.Run("initializes correctly", func(t *testing.T) {
-			model := tagListModel{
-				selected:    0,
-				showingHelp: false,
-			}
-
-			if model.selected != 0 {
-				t.Error("Initial selection should be 0")
-			}
-			if model.showingHelp {
-				t.Error("Should not be showing help initially")
-			}
-		})
-
-		t.Run("handles key navigation", func(t *testing.T) {
-			tags := []repo.TagSummary{
-				{Name: "tag1", TaskCount: 1},
-				{Name: "tag2", TaskCount: 2},
-				{Name: "tag3", TaskCount: 3},
-			}
-
-			model := tagListModel{
-				tags:     tags,
-				selected: 1,
-				keys:     tagKeys,
-			}
-
-			// Test down key
-			downMsg := tea.KeyMsg{Type: tea.KeyDown}
-			updatedModel, _ := model.Update(downMsg)
-			if updatedModel.(tagListModel).selected != 2 {
-				t.Error("Down key should move selection down")
-			}
-
-			// Test up key
-			upMsg := tea.KeyMsg{Type: tea.KeyUp}
-			updatedModel, _ = updatedModel.Update(upMsg)
-			if updatedModel.(tagListModel).selected != 1 {
-				t.Error("Up key should move selection up")
-			}
-
-			// Test boundary conditions
-			model.selected = 0
-			updatedModel, _ = model.Update(upMsg)
-			if updatedModel.(tagListModel).selected != 0 {
-				t.Error("Up key should not move selection below 0")
-			}
-
-			model.selected = len(tags) - 1
-			updatedModel, _ = model.Update(downMsg)
-			if updatedModel.(tagListModel).selected != len(tags)-1 {
-				t.Error("Down key should not move selection beyond list length")
-			}
-		})
-
-		t.Run("handles number key selection", func(t *testing.T) {
-			tags := []repo.TagSummary{
-				{Name: "tag1", TaskCount: 1},
-				{Name: "tag2", TaskCount: 2},
-				{Name: "tag3", TaskCount: 3},
-			}
-
-			model := tagListModel{
-				tags:     tags,
-				selected: 0,
-				keys:     tagKeys,
-			}
-
-			// Test number key 3 (index 2)
-			keyMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'3'}}
-			updatedModel, _ := model.Update(keyMsg)
-			if updatedModel.(tagListModel).selected != 2 {
-				t.Error("Number key 3 should select index 2")
-			}
-		})
-
-		t.Run("handles help toggle", func(t *testing.T) {
-			model := tagListModel{
-				keys: tagKeys,
-			}
-
-			helpMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'?'}}
-			updatedModel, _ := model.Update(helpMsg)
-			if !updatedModel.(tagListModel).showingHelp {
-				t.Error("Help key should show help")
-			}
-
-			updatedModel, _ = updatedModel.Update(helpMsg)
-			if updatedModel.(tagListModel).showingHelp {
-				t.Error("Help key should hide help when already showing")
-			}
-		})
-
-		t.Run("handles tags loaded message", func(t *testing.T) {
-			tags := []repo.TagSummary{
-				{Name: "new-tag", TaskCount: 5},
-			}
-
-			model := tagListModel{
-				selected: 5, // Invalid selection
-			}
-
-			msg := tagsLoadedMsg(tags)
-			updatedModel, _ := model.Update(msg)
-			resultModel := updatedModel.(tagListModel)
-
-			if len(resultModel.tags) != 1 {
-				t.Error("Tags should be loaded correctly")
-			}
-			if resultModel.selected != 0 {
-				t.Error("Selection should be reset to valid range")
-			}
-		})
-
-		t.Run("handles error message", func(t *testing.T) {
-			model := tagListModel{}
-
-			errorMsg := errorTagMsg(fmt.Errorf("test error"))
-			updatedModel, _ := model.Update(errorMsg)
-			resultModel := updatedModel.(tagListModel)
-
-			if resultModel.err == nil {
-				t.Error("Error should be set")
-			}
-			if resultModel.err.Error() != "test error" {
-				t.Errorf("Expected 'test error', got '%s'", resultModel.err.Error())
-			}
-		})
-
-		t.Run("view renders correctly", func(t *testing.T) {
-			tags := []repo.TagSummary{
-				{Name: "frontend", TaskCount: 5},
-				{Name: "urgent", TaskCount: 1},
-			}
-
-			model := tagListModel{
-				tags:     tags,
-				selected: 0,
-				keys:     tagKeys,
-			}
-
-			view := model.View()
-			if !strings.Contains(view, "Tags") {
-				t.Error("View should contain title")
-			}
-			if !strings.Contains(view, "frontend") {
-				t.Error("View should contain tag names")
-			}
-			if !strings.Contains(view, "5 tasks") {
-				t.Error("View should show task counts")
-			}
-			if !strings.Contains(view, "1 task") {
-				t.Error("View should show singular task count")
-			}
-		})
-
-		t.Run("view handles empty state", func(t *testing.T) {
-			model := tagListModel{
-				tags: []repo.TagSummary{},
-			}
-
-			view := model.View()
-			if !strings.Contains(view, "No tags found") {
-				t.Error("View should show empty state message")
-			}
-		})
-
-		t.Run("view handles error state", func(t *testing.T) {
-			model := tagListModel{
-				err: fmt.Errorf("test error"),
-			}
-
-			view := model.View()
-			if !strings.Contains(view, "Error:") {
-				t.Error("View should show error message")
-			}
-		})
-	})
-}