feat: add read command for articles with glamour based markdown rendering

cmd/commands.go

···
 	}
 	root.AddCommand(viewCmd)
 
+	readCmd := &cobra.Command{
+		Use:   "read <id>",
+		Short: "Read article content with formatted markdown",
+		Long: `Read the full markdown content of an article with beautiful formatting.
+
+This displays the complete article content using syntax highlighting and proper formatting.`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if articleID, err := parseID("article", args); err != nil {
+				return err
+			} else {
+				defer c.handler.Close()
+				return c.handler.Read(cmd.Context(), articleID)
+			}
+		},
+	}
+	root.AddCommand(readCmd)
+
 	removeCmd := &cobra.Command{
 		Use:     "remove <id>",
 		Short:   "Remove article and associated files",

cmd/commands_test.go

···
 			}
 		})
 
+		t.Run("read command with non-existent article ID", func(t *testing.T) {
+			cmd := NewArticleCommand(handler).Create()
+			cmd.SetArgs([]string{"read", "999"})
+			err := cmd.Execute()
+			if err == nil {
+				t.Error("expected article read command to fail with non-existent ID")
+			}
+		})
+
+		t.Run("read command with non-numeric ID", func(t *testing.T) {
+			cmd := NewArticleCommand(handler).Create()
+			cmd.SetArgs([]string{"read", "invalid"})
+			err := cmd.Execute()
+			if err == nil {
+				t.Error("expected article read command to fail with non-numeric ID")
+			}
+		})
+
 		t.Run("remove command with non-existent article ID", func(t *testing.T) {
 			cmd := NewArticleCommand(handler).Create()
 			cmd.SetArgs([]string{"remove", "999"})

docs/testing.md

···
 # Testing Documentation
 
-This document outlines the testing patterns and practices used in the noteleaf application.
+This document outlines the testing patterns and practices used in the `noteleaf` application.
 
-## Testing Principles
+## Overview
 
-The codebase follows Go's standard testing practices without external libraries. Tests use only the standard library `testing` package and avoid mock frameworks or assertion libraries. This keeps dependencies minimal and tests readable using standard Go patterns.
+The codebase follows Go's standard testing practices without external libraries. Tests use only the standard library package and avoid mock frameworks or assertion libraries. This is to keep dependencies minimal and tests readable using standard Go patterns.
 
-## Test File Organization
+### Organization
 
-Test files follow the standard Go convention of `*_test.go` naming. Each package contains its own test files alongside the source code. Test files are organized by functionality and mirror the structure of the source code they test.
+Each package contains its own test files alongside the source code. Test files are organized by functionality and mirror the structure of the source code they test.
 
-## Testing Patterns
+## Patterns
 
 ### Handler Creation Pattern
 
···
 
 Tests use `t.Fatal` for setup errors that prevent test execution and `t.Error` for test assertion failures. Fatal errors stop test execution while errors allow tests to continue checking other conditions.
 
+### Context Cancellation Testing Pattern
+
+Error case testing frequently uses context cancellation to simulate database and network failures. The pattern creates a context, immediately cancels it, then calls the function under test to verify error handling. This provides a reliable way to test error paths without requiring complex mock setups or external failure injection.
+
 ### Command Structure Testing
 
 Command group tests verify cobra command structure including use strings, aliases, short descriptions, and subcommand presence. Tests check that commands are properly configured without executing their logic.
···
 
 Tests verify interface compliance using compile-time checks with blank identifier assignments. This ensures structs implement expected interfaces without runtime overhead.
 
-```go
-var _ CommandGroup = NewTaskCommands(handler)
-```
-
 ## Test Organization Patterns
 
-### Single Root Test Pattern
+### Single Root Test
 
-The preferred test organization pattern uses a single root test function with nested subtests using `t.Run`. This provides clear hierarchical organization and allows running specific test sections while maintaining shared setup and context.
+The preferred test organization pattern uses a single root test function with nested subtests using `t.Run`. This provides clear hierarchical organization and allows running specific test sections while maintaining shared setup and context. This pattern offers several advantages: clear test hierarchy with logical grouping, ability to run specific test sections, consistent test structure across the codebase, and shared setup that can be inherited by subtests.
 
-```go
-func TestCommandGroup(t *testing.T) {
-    t.Run("Interface Implementations", func(t *testing.T) {
-        // Test interface compliance
-    })
+### Integration vs Unit Testing
 
-    t.Run("Create", func(t *testing.T) {
-        t.Run("TaskCommand", func(t *testing.T) {
-            // Test task command creation
-        })
-        t.Run("MovieCommand", func(t *testing.T) {
-            // Test movie command creation
-        })
-    })
-}
-```
+The codebase emphasizes integration testing over heavy mocking by using real handlers and services to verify actual behavior rather than mocked interactions. The goal is to catch integration issues while maintaining test reliability.
 
-This pattern offers several advantages: clear test hierarchy with logical grouping, ability to run specific test sections with `go test -run TestCommandGroup/Create/TaskCommand`, consistent test structure across the codebase, and shared setup that can be inherited by subtests.
+### Static Output
 
-### Integration vs Unit Testing
+UI components support static output modes for testing. Tests capture output using bytes.Buffer and verify content using string contains checks rather than exact string matching for better test maintainability.
 
-The codebase emphasizes integration testing over heavy mocking. Tests use real handlers and services to verify actual behavior rather than mocked interactions. This approach catches integration issues while maintaining test reliability.
-
-### Static Output Testing
+### Standard Output Redirection
 
-UI components support static output modes for testing. Tests capture output using bytes.Buffer and verify content using string contains checks rather than exact string matching for better test maintainability.
+For testing functions that write to stdout, tests use a pipe redirection pattern with goroutines to capture output. The pattern saves the original stdout, redirects to a pipe, captures output in a separate goroutine, and restores stdout after the test. This ensures clean output capture without interfering with the testing framework.
 
-## Test Utilities
+## Utilities
 
-### Helper Functions
+### Helpers
 
 Test files include helper functions for creating test data and finding elements in collections. These utilities reduce code duplication and improve test readability.
 
-### Mock Data Creation
+### Mock Data
 
-Tests create realistic mock data using factory functions that return properly initialized structs with sensible defaults. This approach provides consistent test data across different test cases.
+Tests create realistic mock data using factory functions (powered by faker) that return properly initialized structs with sensible defaults.
 
 ## Testing CLI Commands
 
···
 
 The single root test pattern allows for efficient resource management where setup costs can be amortized across multiple related test cases.
 
-## Best Practices Summary
+## Errors
+
+Error coverage follows a systematic approach to identify and test failure scenarios:
 
-Use factory functions for test handler creation with proper cleanup patterns. Organize tests using single root test functions with nested subtests for clear hierarchy. Manage resources with cleanup functions returned by factory methods. Prefer integration testing over mocking for real-world behavior validation. Verify interface compliance at compile time within dedicated subtests. Focus command tests on structure verification rather than execution testing. Leverage the single root test pattern for logical grouping and selective test execution. Use realistic test data with factory functions for consistent test scenarios.
+1. **Context Cancellation** - Primary method for testing database and network timeout scenarios
+2. **Invalid Input** - Malformed data, empty inputs, boundary conditions
+3. **Resource Exhaustion** - Database connection failures, memory limits
+4. **Constraint Violations** - Duplicate keys, foreign key failures
+5. **State Validation** - Testing functions with invalid system states

internal/handlers/articles.go

···
 	return nil
 }
 
+// Read displays an article's content with formatted markdown rendering
+func (h *ArticleHandler) Read(ctx context.Context, id int64) error {
+	article, err := h.repos.Articles.Get(ctx, id)
+	if err != nil {
+		return fmt.Errorf("failed to get article: %w", err)
+	}
+
+	if _, err := os.Stat(article.MarkdownPath); os.IsNotExist(err) {
+		return fmt.Errorf("markdown file not found: %s", article.MarkdownPath)
+	}
+
+	content, err := os.ReadFile(article.MarkdownPath)
+	if err != nil {
+		return fmt.Errorf("failed to read markdown file: %w", err)
+	}
+
+	if rendered, err := renderMarkdown(string(content)); err != nil {
+		return err
+	} else {
+		fmt.Print(rendered)
+		return nil
+	}
+
+}
+
 // TODO: Try to get from config first (could be added later)
 // For now, use default ~/Documents/Leaf/
 func (h *ArticleHandler) getStorageDirectory() (string, error) {

internal/handlers/articles_test.go

···
 		})
 	})
 
+	t.Run("Read", func(t *testing.T) {
+		t.Run("read renders article successfully", func(t *testing.T) {
+			helper := NewArticleTestHelper(t)
+			ctx := context.Background()
+			id := helper.CreateTestArticle(t, "https://example.com/read", "Read Test Article", "Test Author", "2024-01-01")
+			err := helper.Read(ctx, id)
+			Expect.AssertNoError(t, err, "Read should succeed with valid article ID")
+		})
+
+		t.Run("handles non-existent article", func(t *testing.T) {
+			helper := NewArticleTestHelper(t)
+			ctx := context.Background()
+			err := helper.Read(ctx, 99999)
+			Expect.AssertError(t, err, "failed to get article", "Read should fail with non-existent article ID")
+		})
+
+		t.Run("handles missing markdown file", func(t *testing.T) {
+			helper := NewArticleTestHelper(t)
+			ctx := context.Background()
+
+			article := &models.Article{
+				URL:          "https://example.com/missing-md",
+				Title:        "Missing Markdown Article",
+				Author:       "Test Author",
+				Date:         "2024-01-01",
+				MarkdownPath: "/non/existent/path.md",
+				HTMLPath:     "/some/existent/path.html",
+				Created:      time.Now(),
+				Modified:     time.Now(),
+			}
+
+			id, err := helper.repos.Articles.Create(ctx, article)
+			if err != nil {
+				t.Fatalf("Failed to create article with missing markdown file: %v", err)
+			}
+
+			err = helper.Read(ctx, id)
+			Expect.AssertError(t, err, "markdown file not found", "Read should fail when markdown file is missing")
+		})
+
+		t.Run("handles database error", func(t *testing.T) {
+			helper := NewArticleTestHelper(t)
+			ctx := context.Background()
+			helper.db.Exec("DROP TABLE articles")
+			err := helper.Read(ctx, 1)
+			Expect.AssertError(t, err, "failed to get article", "Read should fail when database is corrupted")
+		})
+	})
+
 	t.Run("Remove", func(t *testing.T) {
 		t.Run("removes article successfully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			ctx := context.Background()
-
 			id := helper.CreateTestArticle(t, "https://example.com/remove", "Remove Test", "Author", "2024-01-01")
-
 			Expect.AssertArticleExists(t, helper, id)
 
 			err := helper.Remove(ctx, id)
 			Expect.AssertNoError(t, err, "Remove should succeed")
-
 			Expect.AssertArticleNotExists(t, helper, id)
 		})
 
 		t.Run("handles non-existent article", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			ctx := context.Background()
-
 			err := helper.Remove(ctx, 99999)
 			Expect.AssertError(t, err, "failed to get article", "Remove should fail with non-existent article ID")
 		})
···
 		t.Run("handles database error", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			ctx := context.Background()
-
 			id := helper.CreateTestArticle(t, "https://example.com/db-error", "DB Error Test", "Author", "2024-01-01")
 
 			helper.db.Exec("DROP TABLE articles")
···
 	t.Run("Help", func(t *testing.T) {
 		t.Run("shows supported domains", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
-
 			err := helper.Help()
 			Expect.AssertNoError(t, err, "Help should succeed")
 		})
···
 	t.Run("Close", func(t *testing.T) {
 		t.Run("closes successfully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
-
 			err := helper.Close()
 			Expect.AssertNoError(t, err, "Close should succeed")
 		})
···
 		t.Run("handles nil database gracefully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			helper.db = nil
-
 			err := helper.Close()
 			Expect.AssertNoError(t, err, "Close should succeed with nil database")
 		})
···
 	t.Run("getStorageDirectory", func(t *testing.T) {
 		t.Run("returns storage directory successfully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
-
 			dir, err := helper.getStorageDirectory()
 			Expect.AssertNoError(t, err, "getStorageDirectory should succeed")
 

internal/handlers/books_test.go

···
 				t.Errorf("Close failed: %v", err)
 			}
 		})
+
+		t.Run("handles service close gracefully", func(t *testing.T) {
+			_, cleanup := setupBookTest(t)
+			defer cleanup()
+
+			handler, err := NewBookHandler()
+			if err != nil {
+				t.Fatalf("NewBookHandler failed: %v", err)
+			}
+
+			if err = handler.Close(); err != nil {
+				t.Errorf("Close should succeed: %v", err)
+			}
+		})
 	})
 
 	t.Run("Print", func(t *testing.T) {

internal/handlers/notes.go

···
 	"path/filepath"
 	"strings"
 
-	"github.com/charmbracelet/glamour"
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
 	"github.com/stormlightlabs/noteleaf/internal/store"
···
 	return ""
 }
 
-func defaultOpenInEditor(editor, filePath string) error {
-	cmd := exec.Command(editor, filePath)
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
-}
-
 func (h *NoteHandler) openInEditor(editor, filePath string) error {
 	if h.openInEditorFunc != nil {
 		return h.openInEditorFunc(editor, filePath)
 	}
-	return defaultOpenInEditor(editor, filePath)
+	return openInDefaultEditor(editor, filePath)
 }
 
 func (h *NoteHandler) parseNoteContent(content string) (title, noteContent string, tags []string) {
···
 	return title, noteContent, tags
 }
 
-func (h *NoteHandler) formatNoteForEdit(note *models.Note) string {
-	var content strings.Builder
-
-	if !strings.Contains(note.Content, "# "+note.Title) {
-		content.WriteString("# " + note.Title + "\n\n")
-	}
-
-	content.WriteString(note.Content)
-
-	if len(note.Tags) > 0 {
-		if !strings.HasSuffix(note.Content, "\n") {
-			content.WriteString("\n")
-		}
-		content.WriteString("\n<!-- Tags: " + strings.Join(note.Tags, ", ") + " -->\n")
-	}
-
-	return content.String()
-}
-
 // View displays a note with formatted markdown content
 func (h *NoteHandler) View(ctx context.Context, id int64) error {
 	note, err := h.repos.Notes.Get(ctx, id)
···
 		return fmt.Errorf("failed to get note: %w", err)
 	}
 
-	renderer, err := glamour.NewTermRenderer(
-		glamour.WithAutoStyle(),
-		glamour.WithWordWrap(80),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to create markdown renderer: %w", err)
-	}
-
 	content := h.formatNoteForView(note)
-	rendered, err := renderer.Render(content)
-	if err != nil {
-		return fmt.Errorf("failed to render markdown: %w", err)
+	if rendered, err := renderMarkdown(content); err != nil {
+		return err
+	} else {
+		fmt.Print(rendered)
+		return nil
 	}
-
-	fmt.Print(rendered)
-	return nil
 }
 
 // List opens either an interactive TUI browser for navigating and viewing notes or a static list
···
 
 	return content.String()
 }
+
+func (h *NoteHandler) formatNoteForEdit(note *models.Note) string {
+	var content strings.Builder
+
+	if !strings.Contains(note.Content, "# "+note.Title) {
+		content.WriteString("# " + note.Title + "\n\n")
+	}
+
+	content.WriteString(note.Content)
+
+	if len(note.Tags) > 0 {
+		if !strings.HasSuffix(note.Content, "\n") {
+			content.WriteString("\n")
+		}
+		content.WriteString("\n<!-- Tags: " + strings.Join(note.Tags, ", ") + " -->\n")
+	}
+
+	return content.String()
+}
+
+func openInDefaultEditor(editor, filePath string) error {
+	cmd := exec.Command(editor, filePath)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}

internal/handlers/notes_test.go

···
 	"runtime"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/store"
···
 	})
 
 	t.Run("Close", func(t *testing.T) {
-		testHandler, err := NewNoteHandler()
-		if err != nil {
-			t.Fatalf("Failed to create test handler: %v", err)
-		}
+		t.Run("closes handler resources successfully", func(t *testing.T) {
+			testHandler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("Failed to create test handler: %v", err)
+			}
+
+			if err = testHandler.Close(); err != nil {
+				t.Errorf("Close should succeed: %v", err)
+			}
+		})
+
+		t.Run("handles nil database", func(t *testing.T) {
+			testHandler, err := NewNoteHandler()
+			if err != nil {
+				t.Fatalf("Failed to create test handler: %v", err)
+			}
+			testHandler.db = nil
 
-		err = testHandler.Close()
-		if err != nil {
-			t.Errorf("Close should succeed: %v", err)
-		}
+			if err = testHandler.Close(); err != nil {
+				t.Errorf("Close should succeed with nil database: %v", err)
+			}
+		})
 	})
 
 	t.Run("Helper Methods", func(t *testing.T) {
···
 
 			err := handler.createInteractive(ctx)
 			Expect.AssertError(t, err, "failed to read edited content", "createInteractive should fail when temp file is deleted")
+		})
+	})
+
+	t.Run("CreateWithOptions", func(t *testing.T) {
+		ctx := context.Background()
+
+		t.Run("creates note successfully without editor prompt", func(t *testing.T) {
+			handler := NewHandlerTestHelper(t)
+			err := handler.CreateWithOptions(ctx, "Test Note", "Test content", "", false, false)
+			Expect.AssertNoError(t, err, "CreateWithOptions should succeed")
+		})
+
+		t.Run("creates note successfully with editor prompt disabled", func(t *testing.T) {
+			handler := NewHandlerTestHelper(t)
+			err := handler.CreateWithOptions(ctx, "Another Test Note", "More content", "", false, false)
+			Expect.AssertNoError(t, err, "CreateWithOptions should succeed")
+		})
+
+		t.Run("handles database error during creation", func(t *testing.T) {
+			handler := NewHandlerTestHelper(t)
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			err := handler.CreateWithOptions(cancelCtx, "Test Note", "Test content", "", false, false)
+			Expect.AssertError(t, err, "failed to create note", "CreateWithOptions should fail with cancelled context")
+		})
+
+		t.Run("creates note with empty content", func(t *testing.T) {
+			handler := NewHandlerTestHelper(t)
+			err := handler.CreateWithOptions(ctx, "Empty Content Note", "", "", false, false)
+			Expect.AssertNoError(t, err, "CreateWithOptions should succeed with empty content")
+		})
+
+		t.Run("creates note with empty title", func(t *testing.T) {
+			handler := NewHandlerTestHelper(t)
+			err := handler.CreateWithOptions(ctx, "", "Content without title", "", false, false)
+			Expect.AssertNoError(t, err, "CreateWithOptions should succeed with empty title")
+		})
+
+		t.Run("handles editor prompt with no editor available", func(t *testing.T) {
+			handler := NewHandlerTestHelper(t)
+			envHelper := NewEnvironmentTestHelper()
+			defer envHelper.RestoreEnv()
+
+			envHelper.UnsetEnv("EDITOR")
+			envHelper.SetEnv("PATH", "")
+
+			err := handler.CreateWithOptions(ctx, "Test Note", "Test content", "", false, true)
+			Expect.AssertNoError(t, err, "CreateWithOptions should succeed even when no editor is available")
+		})
+	})
+
+	t.Run("formatNoteForView", func(t *testing.T) {
+		t.Run("formats note with title and content", func(t *testing.T) {
+			note := &models.Note{
+				Title:    "Test Note",
+				Content:  "This is test content",
+				Tags:     []string{},
+				Created:  time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+				Modified: time.Date(2023, 1, 2, 11, 0, 0, 0, time.UTC),
+			}
+
+			result := handler.formatNoteForView(note)
+
+			if !strings.Contains(result, "# Test Note") {
+				t.Error("Formatted note should contain title")
+			}
+			if !strings.Contains(result, "This is test content") {
+				t.Error("Formatted note should contain content")
+			}
+			if !strings.Contains(result, "**Created:**") {
+				t.Error("Formatted note should contain created timestamp")
+			}
+			if !strings.Contains(result, "**Modified:**") {
+				t.Error("Formatted note should contain modified timestamp")
+			}
+		})
+
+		t.Run("formats note with tags", func(t *testing.T) {
+			note := &models.Note{
+				Title:    "Tagged Note",
+				Content:  "Content with tags",
+				Tags:     []string{"work", "important", "personal"},
+				Created:  time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+				Modified: time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+			}
+
+			result := handler.formatNoteForView(note)
+
+			if !strings.Contains(result, "**Tags:**") {
+				t.Error("Formatted note should contain tags section")
+			}
+			if !strings.Contains(result, "`work`") {
+				t.Error("Formatted note should contain work tag")
+			}
+			if !strings.Contains(result, "`important`") {
+				t.Error("Formatted note should contain important tag")
+			}
+			if !strings.Contains(result, "`personal`") {
+				t.Error("Formatted note should contain personal tag")
+			}
+		})
+
+		t.Run("formats note with no tags", func(t *testing.T) {
+			note := &models.Note{
+				Title:    "Untagged Note",
+				Content:  "Content without tags",
+				Tags:     []string{},
+				Created:  time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+				Modified: time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+			}
+
+			result := handler.formatNoteForView(note)
+
+			if strings.Contains(result, "**Tags:**") {
+				t.Error("Formatted note should not contain tags section when no tags exist")
+			}
+		})
+
+		t.Run("handles content with existing title", func(t *testing.T) {
+			note := &models.Note{
+				Title:    "Note Title",
+				Content:  "# Duplicate Title\nContent after title",
+				Tags:     []string{},
+				Created:  time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+				Modified: time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+			}
+
+			result := handler.formatNoteForView(note)
+
+			if !strings.Contains(result, "Content after title") {
+				t.Error("Formatted note should contain content after duplicate title removal")
+			}
+			contentLines := strings.Split(result, "\n")
+			duplicateTitleCount := 0
+			for _, line := range contentLines {
+				if strings.Contains(line, "# Duplicate Title") {
+					duplicateTitleCount++
+				}
+			}
+			if duplicateTitleCount > 0 {
+				t.Error("Formatted note should not contain duplicate title from content")
+			}
+		})
+
+		t.Run("handles empty content", func(t *testing.T) {
+			note := &models.Note{
+				Title:    "Empty Content Note",
+				Content:  "",
+				Tags:     []string{},
+				Created:  time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+				Modified: time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+			}
+
+			result := handler.formatNoteForView(note)
+
+			if !strings.Contains(result, "# Empty Content Note") {
+				t.Error("Formatted note should contain title even with empty content")
+			}
+			if !strings.Contains(result, "---") {
+				t.Error("Formatted note should contain separator")
+			}
+		})
+
+		t.Run("handles content with only title line", func(t *testing.T) {
+			note := &models.Note{
+				Title:    "Single Line",
+				Content:  "# Single Line",
+				Tags:     []string{},
+				Created:  time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+				Modified: time.Date(2023, 1, 1, 10, 0, 0, 0, time.UTC),
+			}
+
+			result := handler.formatNoteForView(note)
+
+			if !strings.Contains(result, "# Single Line") {
+				t.Error("Formatted note should contain title")
+			}
 		})
 	})
 }

internal/handlers/shared.go

···
+package handlers
+
+import (
+	"fmt"
+
+	"github.com/charmbracelet/glamour"
+)
+
+func renderMarkdown(content string) (string, error) {
+	renderer, err := glamour.NewTermRenderer(glamour.WithAutoStyle(), glamour.WithWordWrap(80))
+	if err != nil {
+		return "", fmt.Errorf("failed to create markdown renderer: %w", err)
+	}
+
+	rendered, err := renderer.Render(content)
+	if err != nil {
+		return "", fmt.Errorf("failed to render markdown: %w", err)
+	}
+
+	return rendered, nil
+}

internal/handlers/shared_test.go

···
+package handlers
+
+import (
+	"strings"
+	"testing"
+)
+
+type renderMarkdownTC struct {
+	name     string
+	content  string
+	err      bool
+	contains []string
+}
+
+func TestRenderMarkdown(t *testing.T) {
+	tt := []renderMarkdownTC{
+		{name: "simple text", content: "Hello, world!", err: false, contains: []string{"Hello, world!"}},
+		{name: "markdown heading", content: "# Main Title", err: false, contains: []string{"Main Title"}},
+		{name: "markdown with emphasis", content: "This is **bold** and *italic* text", err: false, contains: []string{"bold", "italic"}},
+		{name: "markdown list", content: "- Item 1\n- Item 2\n- Item 3", err: false, contains: []string{"Item 1", "Item 2", "Item 3"}},
+		{name: "code block", content: "```go\nfunc main() {\n    fmt.Println(\"Hello\")\n}\n```", err: false, contains: []string{"main", "fmt.Println"}},
+		{name: "empty string", content: "", err: false, contains: []string{}},
+		{name: "only whitespace", content: "   \n\t  \n   ", err: false, contains: []string{}},
+		{name: "mixed content", content: "# Title\n\nSome **bold** text and a [link](https://example.com)\n\n- List item", err: false,
+			contains: []string{"Title", "bold", "example.com", "List item"}}}
+
+	for _, tt := range tt {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := renderMarkdown(tt.content)
+			if tt.err && err == nil {
+				t.Fatalf("expected error, got nil")
+			}
+
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			for _, want := range tt.contains {
+				if strings.Contains(result, want) {
+					continue
+				}
+				t.Fatalf("result should contain %q, got:\n%s", want, result)
+			}
+		})
+	}
+
+	t.Run("WordWrap", func(t *testing.T) {
+		text := strings.Repeat("This is a very long line that should be wrapped at 80 characters. ", 5)
+		result, err := renderMarkdown(text)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+
+		lines := strings.Split(result, "\n")
+		for i, line := range lines {
+			cleaned := removeANSI(line)
+			if len(cleaned) > 85 {
+				t.Fatalf("Line at index %d is too long (%d chars): %q", i, len(cleaned), cleaned)
+			}
+		}
+	})
+}
+
+func removeANSI(s string) string {
+	result := ""
+	inEscapeCh := false
+	for i := 0; i < len(s); i++ {
+		if s[i] == '\x1b' && i+1 < len(s) && s[i+1] == '[' {
+			inEscapeCh = true
+			i++
+			continue
+		}
+		if inEscapeCh {
+			if (s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z') {
+				inEscapeCh = false
+			}
+			continue
+		}
+		result += string(s[i])
+	}
+	return result
+}

internal/handlers/tasks_test.go

···
 			})
 		})
 	})
+
+	t.Run("ListContexts", func(t *testing.T) {
+		_, cleanup := setupTaskTest(t)
+		defer cleanup()
+
+		ctx := context.Background()
+
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
+		tasks := []*models.Task{
+			{
+				UUID:        uuid.New().String(),
+				Description: "Task with context 1",
+				Status:      "pending",
+				Context:     "test-context",
+			},
+			{
+				UUID:        uuid.New().String(),
+				Description: "Task with context 2",
+				Status:      "pending",
+				Context:     "work-context",
+			},
+			{
+				UUID:        uuid.New().String(),
+				Description: "Task without context",
+				Status:      "pending",
+			},
+		}
+
+		for _, task := range tasks {
+			_, err := handler.repos.Tasks.Create(ctx, task)
+			if err != nil {
+				t.Fatalf("Failed to create task: %v", err)
+			}
+		}
+
+		t.Run("lists contexts in static mode", func(t *testing.T) {
+			err := handler.ListContexts(ctx, true)
+			if err != nil {
+				t.Errorf("ListContexts static mode failed: %v", err)
+			}
+		})
+
+		t.Run("lists contexts in interactive mode (falls back to static)", func(t *testing.T) {
+			err := handler.ListContexts(ctx, false)
+			if err != nil {
+				t.Errorf("ListContexts interactive mode failed: %v", err)
+			}
+		})
+
+		t.Run("lists contexts with todoTxt flag true", func(t *testing.T) {
+			err := handler.ListContexts(ctx, true, true)
+			if err != nil {
+				t.Errorf("ListContexts with todoTxt=true failed: %v", err)
+			}
+		})
+
+		t.Run("lists contexts with todoTxt flag false", func(t *testing.T) {
+			err := handler.ListContexts(ctx, true, false)
+			if err != nil {
+				t.Errorf("ListContexts with todoTxt=false failed: %v", err)
+			}
+		})
+
+		t.Run("handles database error in static mode", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			err := handler.ListContexts(cancelCtx, true)
+			if err == nil {
+				t.Error("Expected error with cancelled context in static mode")
+			}
+			if !strings.Contains(err.Error(), "failed to list tasks for contexts") {
+				t.Errorf("Expected specific error message, got: %v", err)
+			}
+		})
+
+		t.Run("handles database error in interactive mode", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			err := handler.ListContexts(cancelCtx, false)
+			if err == nil {
+				t.Error("Expected error with cancelled context in interactive mode")
+			}
+			if !strings.Contains(err.Error(), "failed to list tasks for contexts") {
+				t.Errorf("Expected specific error message, got: %v", err)
+			}
+		})
+
+		t.Run("returns no contexts when none exist", func(t *testing.T) {
+			_, cleanup_ := setupTaskTest(t)
+			defer cleanup_()
+
+			handler_, err := NewTaskHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
+			defer handler_.Close()
+
+			err = handler_.ListContexts(ctx, true)
+			if err != nil {
+				t.Errorf("ListContexts with no contexts failed: %v", err)
+			}
+		})
+	})
 }