feat: added UploadBlob method to ATProtoService for uploading binary data

* added PublicationListAdapter for managing publications with leaflet metadata

cmd/publication_commands.go

···
 	root.AddCommand(pullCmd)
 
 	listCmd := &cobra.Command{
-		Use:     "list [--published|--draft|--all]",
+		Use:     "list [--published|--draft|--all] [--interactive]",
 		Short:   "List notes synced with leaflet",
 		Aliases: []string{"ls"},
 		Long: `Display notes that have been pulled from or pushed to leaflet.
···
 - Content identifier (cid) for change tracking
 
 Use filters to show specific subsets:
-  --published  Show only published documents
-  --draft      Show only drafts
-  --all        Show all leaflet documents (default)`,
+  --published    Show only published documents
+  --draft        Show only drafts
+  --all          Show all leaflet documents (default)
+  --interactive  Open interactive TUI browser with search and preview`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			published, _ := cmd.Flags().GetBool("published")
 			draft, _ := cmd.Flags().GetBool("draft")
 			all, _ := cmd.Flags().GetBool("all")
+			interactive, _ := cmd.Flags().GetBool("interactive")
 
 			filter := "all"
 			if published {
···
 			}
 
 			defer c.handler.Close()
+
+			if interactive {
+				return c.handler.Browse(cmd.Context(), filter)
+			}
+
 			return c.handler.List(cmd.Context(), filter)
 		},
 	}
 	listCmd.Flags().Bool("published", false, "Show only published documents")
 	listCmd.Flags().Bool("draft", false, "Show only drafts")
 	listCmd.Flags().Bool("all", false, "Show all leaflet documents")
+	listCmd.Flags().BoolP("interactive", "i", false, "Open interactive TUI browser")
 	root.AddCommand(listCmd)
 
 	statusCmd := &cobra.Command{
···
 	patchCmd.Flags().Bool("preview", false, "Show what would be updated without actually patching")
 	patchCmd.Flags().Bool("validate", false, "Validate markdown conversion without patching")
 	root.AddCommand(patchCmd)
+
+	pushCmd := &cobra.Command{
+		Use:   "push [note-ids...]",
+		Short: "Create or update multiple documents on leaflet",
+		Long: `Batch publish or update multiple local notes to leaflet.pub.
+
+For each note:
+- If the note has never been published, creates a new document (like post)
+- If the note has been published before, updates the existing document (like patch)
+
+This is useful for bulk operations and continuous publishing workflows.
+
+Examples:
+  noteleaf pub push 1 2 3              # Publish/update notes 1, 2, and 3
+  noteleaf pub push 42 99 --draft      # Create/update as drafts`,
+		Args: cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			noteIDs := make([]int64, len(args))
+			for i, arg := range args {
+				id, err := parseNoteID(arg)
+				if err != nil {
+					return err
+				}
+				noteIDs[i] = id
+			}
+
+			isDraft, _ := cmd.Flags().GetBool("draft")
+
+			defer c.handler.Close()
+			return c.handler.Push(cmd.Context(), noteIDs, isDraft)
+		},
+	}
+	pushCmd.Flags().Bool("draft", false, "Create/update as drafts instead of publishing")
+	root.AddCommand(pushCmd)
 
 	return root
 }

cmd/publication_commands_test.go

···
 			expectedSubcommands := []string{
 				"auth [handle]",
 				"pull",
-				"list [--published|--draft|--all]",
+				"list [--published|--draft|--all] [--interactive]",
 				"status",
 				"post [note-id]",
 				"patch [note-id]",
+				"push [note-ids...]",
 			}
 
 			for _, expected := range expectedSubcommands {

internal/docs/ROADMAP.md

···
 
 ### Configuration & Data
 
-- [ ] Implement **config management** (flagged TODO in code).
+- [ ] Implement **config management**
 - [ ] Define config file format (TOML, YAML, JSON).
 - [ ] Set default config/data paths:
     - Linux: `~/.config/noteleaf`, `~/.local/share/noteleaf`

internal/handlers/articles.go

···
-// TODO: more article sanitizing
 package handlers
 
 import (

internal/handlers/publication.go

···
 // Package handlers provides command handlers for leaflet publication operations.
-//
-// TODO: Post (create 1)
-// TODO: Patch (update 1)
-// TODO: Push
-//   - Builds on Post & Patch (create or update - more than 1)
-//
-// TODO: Add TUI viewing for document details
-//   - interactive list, read Markdown with glamour
-//
-// TODO: Add TUI for confirming post
-//   - proofread post with glamour
-//
-// TODO: Repost - "Reblog" - post to BlueSky
 package handlers
 
 import (
 	"context"
 	"fmt"
+	"path/filepath"
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
···
 		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
 	}
 
-	// TODO: Implement image handling for markdown conversion
-	// 1. Extract note's directory from filepath/database
-	// 2. Create LocalImageResolver with BlobUploader that calls h.atproto.UploadBlob()
-	// 3. Use converter.WithImageResolver(resolver, noteDir) before ToLeaflet()
-	// This will upload images to AT Protocol and get real CIDs/dimensions
 	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, isDraft, false)
 	if err != nil {
 		return err
···
 		return fmt.Errorf("failed to get note: %w", err)
 	}
 
-	// TODO: Implement image handling for markdown conversion (same as Post method)
-	// 1. Extract note's directory from filepath/database
-	// 2. Create LocalImageResolver with BlobUploader that calls h.atproto.UploadBlob()
-	// 3. Use converter.WithImageResolver(resolver, noteDir) before ToLeaflet()
-	// This will upload images to AT Protocol and get real CIDs/dimensions
 	note, doc, err := h.prepareDocumentForPublish(ctx, noteID, tempNote.IsDraft, true)
 	if err != nil {
 		return err
 	}
 
-	// Update note.PublishedAt if we set a new timestamp
 	if !note.IsDraft && note.PublishedAt == nil && doc.PublishedAt != "" {
 		publishedAt, err := time.Parse(time.RFC3339, doc.PublishedAt)
 		if err == nil {
···
 	return nil
 }
 
+// Push creates or updates multiple documents on leaflet from local notes
+func (h *PublicationHandler) Push(ctx context.Context, noteIDs []int64, isDraft bool) error {
+	if !h.atproto.IsAuthenticated() {
+		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
+	}
+
+	if len(noteIDs) == 0 {
+		return fmt.Errorf("no note IDs provided")
+	}
+
+	ui.Infoln("Processing %d note(s)...\n", len(noteIDs))
+
+	var created, updated, failed int
+	var errors []string
+
+	for _, noteID := range noteIDs {
+		note, err := h.repos.Notes.Get(ctx, noteID)
+		if err != nil {
+			ui.Warningln("  [%d] Failed to get note: %v", noteID, err)
+			errors = append(errors, fmt.Sprintf("note %d: %v", noteID, err))
+			failed++
+			continue
+		}
+
+		if note.HasLeafletAssociation() {
+			err = h.Patch(ctx, noteID)
+			if err != nil {
+				ui.Warningln("  [%d] Failed to update '%s': %v", noteID, note.Title, err)
+				errors = append(errors, fmt.Sprintf("note %d (%s): %v", noteID, note.Title, err))
+				failed++
+			} else {
+				updated++
+			}
+		} else {
+			err = h.Post(ctx, noteID, isDraft)
+			if err != nil {
+				ui.Warningln("  [%d] Failed to create '%s': %v", noteID, note.Title, err)
+				errors = append(errors, fmt.Sprintf("note %d (%s): %v", noteID, note.Title, err))
+				failed++
+			} else {
+				created++
+			}
+		}
+	}
+
+	ui.Newline()
+	ui.Successln("Push complete: %d created, %d updated, %d failed", created, updated, failed)
+
+	if len(errors) > 0 {
+		return fmt.Errorf("push completed with %d error(s)", failed)
+	}
+
+	return nil
+}
+
+// Browse opens an interactive TUI for browsing publications
+func (h *PublicationHandler) Browse(ctx context.Context, filter string) error {
+	if filter == "" {
+		filter = "all"
+	}
+
+	opts := ui.DataListOptions{
+		Title: "Publications - " + filter,
+	}
+
+	list := ui.NewPublicationDataList(h.repos.Notes, opts, filter)
+	return list.Browse(ctx)
+}
+
 // prepareDocumentForPublish prepares a note for publication by converting to Leaflet format
 func (h *PublicationHandler) prepareDocumentForPublish(ctx context.Context, noteID int64, isDraft bool, forPatch bool) (*models.Note, *public.Document, error) {
 	note, err := h.repos.Notes.Get(ctx, noteID)
···
 	}
 
 	converter := public.NewMarkdownConverter()
+
+	noteDir := extractNoteDirectory(note)
+	if noteDir != "" {
+		imageResolver := &public.LocalImageResolver{
+			BlobUploader: func(data []byte, mimeType string) (public.Blob, error) {
+				return h.atproto.UploadBlob(ctx, data, mimeType)
+			},
+		}
+		converter = converter.WithImageResolver(imageResolver, noteDir)
+	}
+
 	blocks, err := converter.ToLeaflet(note.Content)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to convert markdown to leaflet format: %w", err)
···
 		return "Authenticated (session details unavailable)"
 	}
 	return "Not authenticated"
+}
+
+// extractNoteDirectory extracts the directory path from a note's FilePath
+func extractNoteDirectory(note *models.Note) string {
+	if note.FilePath == "" {
+		return ""
+	}
+
+	return filepath.Dir(note.FilePath)
 }
 
 // sessionFromConfig converts config AT Protocol fields to a Session

internal/handlers/publication_test.go

···
 			}
 		})
 	})
+
+	t.Run("Push", func(t *testing.T) {
+		t.Run("returns error when not authenticated", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			err := handler.Push(ctx, []int64{1, 2, 3}, false)
+			if err == nil {
+				t.Error("Expected error when not authenticated")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Errorf("Expected 'not authenticated' error, got '%v'", err)
+			}
+		})
+
+		t.Run("returns error when no note IDs provided", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err := handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.Push(ctx, []int64{}, false)
+			if err == nil {
+				t.Error("Expected error when no note IDs provided")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "no note IDs provided") {
+				t.Errorf("Expected 'no note IDs provided' error, got '%v'", err)
+			}
+		})
+
+		t.Run("handles note not found error", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err := handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.Push(ctx, []int64{999}, false)
+			if err == nil {
+				t.Error("Expected error when note not found")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "error(s)") {
+				t.Errorf("Expected error about failures, got '%v'", err)
+			}
+		})
+
+		t.Run("attempts to create notes without leaflet association", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note1 := &models.Note{
+				Title:   "New Note 1",
+				Content: "# Content 1",
+			}
+			note2 := &models.Note{
+				Title:   "New Note 2",
+				Content: "# Content 2",
+			}
+
+			id1, err := handler.repos.Notes.Create(ctx, note1)
+			suite.AssertNoError(err, "create note 1")
+
+			id2, err := handler.repos.Notes.Create(ctx, note2)
+			suite.AssertNoError(err, "create note 2")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.Push(ctx, []int64{id1, id2}, false)
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Logf("Got error during push (expected for external service call): %v", err)
+			}
+		})
+
+		t.Run("attempts to update notes with leaflet association", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			rkey1 := "rkey1"
+			cid1 := "cid1"
+			publishedAt1 := time.Now().Add(-24 * time.Hour)
+			note1 := &models.Note{
+				Title:       "Published Note 1",
+				Content:     "# Content 1",
+				LeafletRKey: &rkey1,
+				LeafletCID:  &cid1,
+				PublishedAt: &publishedAt1,
+				IsDraft:     false,
+			}
+
+			rkey2 := "rkey2"
+			cid2 := "cid2"
+			note2 := &models.Note{
+				Title:       "Draft Note 2",
+				Content:     "# Content 2",
+				LeafletRKey: &rkey2,
+				LeafletCID:  &cid2,
+				IsDraft:     true,
+			}
+
+			id1, err := handler.repos.Notes.Create(ctx, note1)
+			suite.AssertNoError(err, "create note 1")
+
+			id2, err := handler.repos.Notes.Create(ctx, note2)
+			suite.AssertNoError(err, "create note 2")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.Push(ctx, []int64{id1, id2}, false)
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Logf("Got error during push (expected for external service call): %v", err)
+			}
+		})
+
+		t.Run("handles mixed create and update operations", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			newNote := &models.Note{
+				Title:   "New Note",
+				Content: "# New content",
+			}
+
+			rkey := "existing_rkey"
+			cid := "existing_cid"
+			publishedAt := time.Now().Add(-24 * time.Hour)
+			existingNote := &models.Note{
+				Title:       "Existing Note",
+				Content:     "# Updated content",
+				LeafletRKey: &rkey,
+				LeafletCID:  &cid,
+				PublishedAt: &publishedAt,
+				IsDraft:     false,
+			}
+
+			newID, err := handler.repos.Notes.Create(ctx, newNote)
+			suite.AssertNoError(err, "create new note")
+
+			existingID, err := handler.repos.Notes.Create(ctx, existingNote)
+			suite.AssertNoError(err, "create existing note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.Push(ctx, []int64{newID, existingID}, false)
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Logf("Got error during push (expected for external service call): %v", err)
+			}
+		})
+
+		t.Run("continues processing after individual failures", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note1 := &models.Note{
+				Title:   "Valid Note",
+				Content: "# Content",
+			}
+
+			id1, err := handler.repos.Notes.Create(ctx, note1)
+			suite.AssertNoError(err, "create valid note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			invalidID := int64(999)
+			err = handler.Push(ctx, []int64{id1, invalidID}, false)
+
+			if err == nil {
+				t.Error("Expected error due to invalid note ID")
+			}
+
+			if err != nil && !strings.Contains(err.Error(), "error(s)") {
+				t.Errorf("Expected error message about failures, got '%v'", err)
+			}
+		})
+
+		t.Run("respects draft flag for new notes", func(t *testing.T) {
+			suite := NewHandlerTestSuite(t)
+			defer suite.Cleanup()
+
+			handler := CreateHandler(t, NewPublicationHandler)
+			ctx := context.Background()
+
+			note := &models.Note{
+				Title:   "Draft Note",
+				Content: "# Draft content",
+			}
+
+			id, err := handler.repos.Notes.Create(ctx, note)
+			suite.AssertNoError(err, "create note")
+
+			session := &services.Session{
+				DID:           "did:plc:test123",
+				Handle:        "test.bsky.social",
+				AccessJWT:     "access_token",
+				RefreshJWT:    "refresh_token",
+				PDSURL:        "https://bsky.social",
+				ExpiresAt:     time.Now().Add(2 * time.Hour),
+				Authenticated: true,
+			}
+
+			err = handler.atproto.RestoreSession(session)
+			if err != nil {
+				t.Fatalf("Failed to restore session: %v", err)
+			}
+
+			err = handler.Push(ctx, []int64{id}, true)
+
+			if err != nil && !strings.Contains(err.Error(), "not authenticated") {
+				t.Logf("Got error during push (expected for external service call): %v", err)
+			}
+		})
+	})
 }

internal/public/convert.go

···
 
 // LocalImageResolver resolves local file paths to image metadata
 type LocalImageResolver struct {
-	// BlobUploader is called to upload image bytes and get a blob reference
-	// If nil, creates a placeholder blob with a hash-based CID
-	//
-	// TODO: CLI commands that publish documents must provide this function to upload
-	// images to AT Protocol blob storage via com.atproto.repo.uploadBlob
+	// Called to upload image bytes and get a blob reference
 	BlobUploader func(data []byte, mimeType string) (Blob, error)
 }
 

internal/services/atproto.go

···
 //   - Pull: Fetch pub.leaflet.document records from AT Protocol repository
 //   - Post: Create new pub.leaflet.document records in AT Protocol repository
 //   - Push: Update existing pub.leaflet.document records in AT Protocol repository
-//
-// Publishing Workflow (TODO):
-//  1. Post - Create new document:
-//     - Convert note to pub.leaflet.document format
-//     - Upload any embedded images as blobs
-//     - Create record with com.atproto.repo.createRecord
-//     - Store returned rkey and cid in note metadata
-//  2. Push - Update existing document:
-//     - Check if note has leaflet_rkey (indicates previously published)
-//     - Convert updated note to pub.leaflet.document format
-//     - Upload any new images as blobs
-//     - Update record with com.atproto.repo.putRecord
-//     - Update stored cid in note metadata
-//  3. Delete - Remove published document:
-//     - Use com.atproto.repo.deleteRecord with stored rkey
-//     - Clear leaflet metadata from note
-//
-// Blob Upload (TODO):
-//  1. Use com.atproto.repo.uploadBlob for images
-//  2. Returns blob reference with CID
-//  3. Include blob ref in ImageBlock structures
-//
-// Draft vs Published (TODO):
-//  1. Draft documents stored in collection: pub.leaflet.document.draft
-//  2. Published documents in: pub.leaflet.document
-//  3. Moving from draft to published requires:
-//     - Delete from draft collection
-//     - Create in published collection
-//     - Update note metadata with new rkey
+//   - Delete: Remove pub.leaflet.document records from AT Protocol repository
 package services
 
 import (
···
 	}
 
 	return nil
+}
+
+// UploadBlob uploads binary data as a blob to AT Protocol
+func (s *ATProtoService) UploadBlob(ctx context.Context, data []byte, mimeType string) (public.Blob, error) {
+	if !s.IsAuthenticated() {
+		return public.Blob{}, fmt.Errorf("not authenticated")
+	}
+
+	if len(data) == 0 {
+		return public.Blob{}, fmt.Errorf("data cannot be empty")
+	}
+
+	if mimeType == "" {
+		return public.Blob{}, fmt.Errorf("mimeType is required")
+	}
+
+	output, err := atproto.RepoUploadBlob(ctx, s.client, bytes.NewReader(data))
+	if err != nil {
+		return public.Blob{}, fmt.Errorf("failed to upload blob: %w", err)
+	}
+
+	blob := public.Blob{
+		Type:     public.TypeBlob,
+		Ref:      public.CID{Link: output.Blob.Ref.String()},
+		MimeType: output.Blob.MimeType,
+		Size:     int(output.Blob.Size),
+	}
+
+	return blob, nil
 }
 
 // Close cleans up resources

internal/ui/note_list_adapter.go

···
 }
 
 func (n *NoteRecord) GetDescription() string {
-	// Create a short description from tags and modification time
 	var parts []string
 
 	if len(n.Tags) > 0 {
···
 		repoOpts.Archived = &archived
 	}
 
-	// Apply search filter if provided
 	if opts.Search != "" {
-		repoOpts.Content = opts.Search // Search in content
+		repoOpts.Content = opts.Search
 	}
 
 	if opts.Limit > 0 {
···
 }
 
 func (n *NoteDataSource) Count(ctx context.Context, opts ListOptions) (int, error) {
-	// For simplicity, load all and count (could be optimized with a separate Count method)
 	items, err := n.Load(ctx, opts)
 	if err != nil {
 		return 0, err
···
 }
 
 func (n *NoteDataSource) Search(ctx context.Context, query string, opts ListOptions) ([]ListItem, error) {
-	// Set search in options and use regular Load
 	opts.Search = query
 	return n.Load(ctx, opts)
 }
···
 		opts.Title = "Notes"
 	}
 
-	// Enable search functionality for notes
 	opts.ShowSearch = true
 	opts.Searchable = true
 
-	// Set up view handler for markdown rendering
 	if opts.ViewHandler == nil {
 		opts.ViewHandler = func(item ListItem) string {
 			if noteRecord, ok := item.(*NoteRecord); ok {
···
 		}
 	}
 
-	// Render markdown
 	renderer, err := glamour.NewTermRenderer(
 		glamour.WithAutoStyle(),
 		glamour.WithWordWrap(80),
 	)
 	if err != nil {
-		return content.String() // Return unrendered if glamour fails
+		return content.String()
 	}
 
 	rendered, err := renderer.Render(content.String())
 	if err != nil {
-		return content.String() // Return unrendered if rendering fails
+		return content.String()
 	}
 
 	return rendered

internal/ui/note_list_adapter_test.go

···
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 type mockNoteRepository struct {
···
 			}
 		}
 
-		// Filter by content search
 		if options.Content != "" && !strings.Contains(note.Content, options.Content) {
 			continue
 		}
···
 	return filtered, nil
 }
 
+func (m *mockNoteRepository) ListPublished(ctx context.Context) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	var published []*models.Note
+	for _, note := range m.notes {
+		if note.LeafletRKey != nil && !note.IsDraft {
+			published = append(published, note)
+		}
+	}
+	return published, nil
+}
+
+func (m *mockNoteRepository) ListDrafts(ctx context.Context) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	var drafts []*models.Note
+	for _, note := range m.notes {
+		if note.LeafletRKey != nil && note.IsDraft {
+			drafts = append(drafts, note)
+		}
+	}
+	return drafts, nil
+}
+
+func (m *mockNoteRepository) GetLeafletNotes(ctx context.Context) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	var leafletNotes []*models.Note
+	for _, note := range m.notes {
+		if note.LeafletRKey != nil {
+			leafletNotes = append(leafletNotes, note)
+		}
+	}
+	return leafletNotes, nil
+}
+
 func TestNoteAdapter(t *testing.T) {
 	t.Run("NoteRecord", func(t *testing.T) {
 		note := &models.Note{
···
 			for _, tt := range tests {
 				t.Run(tt.name, func(t *testing.T) {
 					result := record.GetField(tt.field)
-					// For slices, do a deep comparison
 					if tags, ok := tt.expected.([]string); ok {
 						resultTags, ok := result.([]string)
 						if !ok || len(resultTags) != len(tags) {
···
 				t.Errorf("Load() returned %d items, want 3", len(items))
 			}
 
-			// Check first item
 			if items[0].GetTitle() != "Work Note" {
 				t.Errorf("First item title = %q, want 'Work Note'", items[0].GetTitle())
 			}
···
 		}
 
 		outputStr := output.String()
-		if !strings.Contains(outputStr, "Notes") {
-			t.Error("Output should contain 'Notes' title")
-		}
-		if !strings.Contains(outputStr, "Test Note") {
-			t.Error("Output should contain note title")
-		}
+		shared.AssertContains(t, outputStr, "Notes", "Output should contain 'Notes' title")
+		shared.AssertContains(t, outputStr, "Test Note", "Output should contain note title")
 	})
 
 	t.Run("Format Note for View", func(t *testing.T) {
···
 
 		result := formatNoteForView(note)
 
-		// Check that it contains expected elements
-		if !strings.Contains(result, "Test Note") {
-			t.Error("Formatted view should contain note title")
-		}
-		if !strings.Contains(result, "test") {
-			t.Error("Formatted view should contain tags")
-		}
-		if !strings.Contains(result, "2023-01-01") {
-			t.Error("Formatted view should contain created date")
-		}
-		if !strings.Contains(result, "2023-01-02") {
-			t.Error("Formatted view should contain modified date")
-		}
+		shared.AssertContains(t, result, "Test Note", "Formatted view should contain note title")
+		shared.AssertContains(t, result, "test", "Formatted view should contain tags")
+		shared.AssertContains(t, result, "2023-01-01", "Formatted view should contain created date")
+		shared.AssertContains(t, result, "2023-01-02", "Formatted view should contain modified date")
 	})
 }

internal/ui/publication_list_adapter.go

···
+package ui
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/charmbracelet/glamour"
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/utils"
+)
+
+// PublicationRecord adapts models.Note with leaflet metadata to work with DataList
+type PublicationRecord struct {
+	*models.Note
+}
+
+func (p *PublicationRecord) GetField(name string) any {
+	switch name {
+	case "id":
+		return p.ID
+	case "title":
+		return p.Title
+	case "status":
+		if p.IsDraft {
+			return "draft"
+		}
+		return "published"
+	case "published_at":
+		return p.PublishedAt
+	case "modified":
+		return p.Modified
+	case "leaflet_rkey":
+		return p.LeafletRKey
+	case "leaflet_cid":
+		return p.LeafletCID
+	default:
+		return ""
+	}
+}
+
+func (p *PublicationRecord) GetTitle() string {
+	status := "draft"
+	if !p.IsDraft {
+		status = "published"
+	}
+	return fmt.Sprintf("[%d] %s (%s)", p.ID, p.Title, status)
+}
+
+func (p *PublicationRecord) GetDescription() string {
+	var parts []string
+
+	if p.PublishedAt != nil {
+		parts = append(parts, "Published: "+p.PublishedAt.Format("2006-01-02 15:04"))
+	}
+
+	parts = append(parts, "Modified: "+p.Modified.Format("2006-01-02 15:04"))
+
+	if p.LeafletRKey != nil {
+		parts = append(parts, "rkey: "+*p.LeafletRKey)
+	}
+
+	return strings.Join(parts, " • ")
+}
+
+func (p *PublicationRecord) GetFilterValue() string {
+	searchable := []string{p.Title, p.Content}
+	if p.LeafletRKey != nil {
+		searchable = append(searchable, *p.LeafletRKey)
+	}
+	return strings.Join(searchable, " ")
+}
+
+// PublicationDataSource loads notes with leaflet metadata
+type PublicationDataSource struct {
+	repo   utils.TestNoteRepository
+	filter string // "all", "published", or "draft"
+}
+
+func (p *PublicationDataSource) Load(ctx context.Context, opts ListOptions) ([]ListItem, error) {
+	var notes []*models.Note
+	var err error
+
+	switch p.filter {
+	case "published":
+		notes, err = p.repo.ListPublished(ctx)
+	case "draft":
+		notes, err = p.repo.ListDrafts(ctx)
+	default:
+		notes, err = p.repo.GetLeafletNotes(ctx)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if opts.Search != "" {
+		var filtered []*models.Note
+		searchLower := strings.ToLower(opts.Search)
+		for _, note := range notes {
+			if strings.Contains(strings.ToLower(note.Title), searchLower) ||
+				strings.Contains(strings.ToLower(note.Content), searchLower) ||
+				(note.LeafletRKey != nil && strings.Contains(strings.ToLower(*note.LeafletRKey), searchLower)) {
+				filtered = append(filtered, note)
+			}
+		}
+		notes = filtered
+	}
+
+	if opts.Limit > 0 && opts.Limit < len(notes) {
+		notes = notes[:opts.Limit]
+	}
+
+	items := make([]ListItem, len(notes))
+	for i, note := range notes {
+		items[i] = &PublicationRecord{Note: note}
+	}
+
+	return items, nil
+}
+
+func (p *PublicationDataSource) Count(ctx context.Context, opts ListOptions) (int, error) {
+	items, err := p.Load(ctx, opts)
+	if err != nil {
+		return 0, err
+	}
+	return len(items), nil
+}
+
+func (p *PublicationDataSource) Search(ctx context.Context, query string, opts ListOptions) ([]ListItem, error) {
+	opts.Search = query
+	return p.Load(ctx, opts)
+}
+
+// NewPublicationDataList creates a new DataList for browsing published/draft documents
+func NewPublicationDataList(repo utils.TestNoteRepository, opts DataListOptions, filter string) *DataList {
+	if opts.Title == "" {
+		opts.Title = "Publications"
+	}
+
+	opts.ShowSearch = true
+	opts.Searchable = true
+
+	if opts.ViewHandler == nil {
+		opts.ViewHandler = func(item ListItem) string {
+			if pubRecord, ok := item.(*PublicationRecord); ok {
+				return formatPublicationForView(pubRecord.Note)
+			}
+			return "Unable to display publication"
+		}
+	}
+
+	source := &PublicationDataSource{
+		repo:   repo,
+		filter: filter,
+	}
+
+	return NewDataList(source, opts)
+}
+
+// NewPublicationListFromList creates a publication list using DataList
+func NewPublicationListFromList(repo utils.TestNoteRepository, output io.Writer, input io.Reader, static bool, filter string) *DataList {
+	opts := DataListOptions{
+		Output: output,
+		Input:  input,
+		Static: static,
+		Title:  "Publications",
+	}
+	return NewPublicationDataList(repo, opts, filter)
+}
+
+// formatPublicationForView formats a publication for display with glamour
+func formatPublicationForView(note *models.Note) string {
+	var content strings.Builder
+
+	content.WriteString("# " + note.Title + "\n\n")
+
+	status := "published"
+	if note.IsDraft {
+		status = "draft"
+	}
+	content.WriteString("**Status:** " + status + "\n")
+
+	if note.PublishedAt != nil {
+		content.WriteString("**Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n")
+	}
+
+	content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n")
+
+	if note.LeafletRKey != nil {
+		content.WriteString("**RKey:** `" + *note.LeafletRKey + "`\n")
+	}
+
+	if note.LeafletCID != nil {
+		content.WriteString("**CID:** `" + *note.LeafletCID + "`\n")
+	}
+
+	content.WriteString("\n---\n\n")
+
+	noteContent := strings.TrimSpace(note.Content)
+	if !strings.HasPrefix(noteContent, "# ") {
+		content.WriteString(noteContent)
+	} else {
+		lines := strings.Split(noteContent, "\n")
+		if len(lines) > 1 {
+			content.WriteString(strings.Join(lines[1:], "\n"))
+		}
+	}
+
+	renderer, err := glamour.NewTermRenderer(
+		glamour.WithAutoStyle(),
+		glamour.WithWordWrap(80),
+	)
+	if err != nil {
+		return content.String()
+	}
+
+	rendered, err := renderer.Render(content.String())
+	if err != nil {
+		return content.String()
+	}
+
+	return rendered
+}

internal/ui/publication_list_adapter_test.go

···
+package ui
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+)
+
+type mockPublicationRepository struct {
+	notes      []*models.Note
+	err        error
+	published  []*models.Note
+	drafts     []*models.Note
+	leafletAll []*models.Note
+}
+
+func (m *mockPublicationRepository) ListPublished(ctx context.Context) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	if m.published != nil {
+		return m.published, nil
+	}
+	var published []*models.Note
+	for _, note := range m.notes {
+		if !note.IsDraft {
+			published = append(published, note)
+		}
+	}
+	return published, nil
+}
+
+func (m *mockPublicationRepository) ListDrafts(ctx context.Context) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	if m.drafts != nil {
+		return m.drafts, nil
+	}
+	var drafts []*models.Note
+	for _, note := range m.notes {
+		if note.IsDraft {
+			drafts = append(drafts, note)
+		}
+	}
+	return drafts, nil
+}
+
+func (m *mockPublicationRepository) GetLeafletNotes(ctx context.Context) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	if m.leafletAll != nil {
+		return m.leafletAll, nil
+	}
+	return m.notes, nil
+}
+
+func (m *mockPublicationRepository) List(ctx context.Context, options repo.NoteListOptions) ([]*models.Note, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.notes, nil
+}
+
+func TestPublicationAdapter(t *testing.T) {
+	t.Run("PublicationRecord", func(t *testing.T) {
+		rkey := "test-rkey-123"
+		cid := "test-cid-456"
+		publishedAt := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+
+		note := &models.Note{
+			ID:          1,
+			Title:       "Test Publication",
+			Content:     "Publication content",
+			Tags:        []string{"article", "tech"},
+			IsDraft:     false,
+			PublishedAt: &publishedAt,
+			Modified:    time.Date(2024, 1, 16, 12, 0, 0, 0, time.UTC),
+			LeafletRKey: &rkey,
+			LeafletCID:  &cid,
+		}
+		record := &PublicationRecord{Note: note}
+
+		t.Run("GetField returns all publication fields", func(t *testing.T) {
+			tests := []struct {
+				field    string
+				expected any
+				name     string
+			}{
+				{"id", int64(1), "id field"},
+				{"title", "Test Publication", "title field"},
+				{"status", "published", "status for published note"},
+				{"published_at", &publishedAt, "published_at field"},
+				{"modified", note.Modified, "modified field"},
+				{"leaflet_rkey", &rkey, "leaflet_rkey field"},
+				{"leaflet_cid", &cid, "leaflet_cid field"},
+				{"unknown", "", "unknown field returns empty string"},
+			}
+
+			for _, tt := range tests {
+				t.Run(tt.name, func(t *testing.T) {
+					result := record.GetField(tt.field)
+					if fmt.Sprintf("%v", result) != fmt.Sprintf("%v", tt.expected) {
+						t.Errorf("GetField(%q) = %v, want %v", tt.field, result, tt.expected)
+					}
+				})
+			}
+		})
+
+		t.Run("GetField returns draft status", func(t *testing.T) {
+			draftNote := &models.Note{
+				ID:      2,
+				Title:   "Draft Note",
+				IsDraft: true,
+			}
+			draftRecord := &PublicationRecord{Note: draftNote}
+
+			status := draftRecord.GetField("status")
+			if status != "draft" {
+				t.Errorf("GetField(status) for draft = %v, want 'draft'", status)
+			}
+		})
+
+		t.Run("GetTitle formats with ID and status", func(t *testing.T) {
+			title := record.GetTitle()
+			if !strings.Contains(title, "[1]") {
+				t.Errorf("GetTitle() should contain ID [1], got: %s", title)
+			}
+			if !strings.Contains(title, "Test Publication") {
+				t.Errorf("GetTitle() should contain title, got: %s", title)
+			}
+			if !strings.Contains(title, "(published)") {
+				t.Errorf("GetTitle() should contain status (published), got: %s", title)
+			}
+		})
+
+		t.Run("GetTitle shows draft status", func(t *testing.T) {
+			draftNote := &models.Note{
+				ID:      3,
+				Title:   "Draft Article",
+				IsDraft: true,
+			}
+			draftRecord := &PublicationRecord{Note: draftNote}
+
+			title := draftRecord.GetTitle()
+			if !strings.Contains(title, "(draft)") {
+				t.Errorf("GetTitle() for draft should contain (draft), got: %s", title)
+			}
+		})
+
+		t.Run("GetDescription includes all metadata", func(t *testing.T) {
+			description := record.GetDescription()
+
+			if !strings.Contains(description, "Published: 2024-01-15 10:00") {
+				t.Errorf("GetDescription() should contain published date, got: %s", description)
+			}
+			if !strings.Contains(description, "Modified: 2024-01-16 12:00") {
+				t.Errorf("GetDescription() should contain modified date, got: %s", description)
+			}
+			if !strings.Contains(description, "rkey: test-rkey-123") {
+				t.Errorf("GetDescription() should contain rkey, got: %s", description)
+			}
+		})
+
+		t.Run("GetDescription handles missing fields", func(t *testing.T) {
+			minimalNote := &models.Note{
+				ID:       4,
+				Title:    "Minimal Note",
+				Modified: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC),
+			}
+			minimalRecord := &PublicationRecord{Note: minimalNote}
+
+			description := minimalRecord.GetDescription()
+
+			if strings.Contains(description, "Published:") {
+				t.Errorf("GetDescription() should not contain Published for unpublished note, got: %s", description)
+			}
+			if strings.Contains(description, "rkey:") {
+				t.Errorf("GetDescription() should not contain rkey when not set, got: %s", description)
+			}
+			if !strings.Contains(description, "Modified: 2024-01-01 00:00") {
+				t.Errorf("GetDescription() should always contain Modified, got: %s", description)
+			}
+		})
+
+		t.Run("GetFilterValue includes searchable text", func(t *testing.T) {
+			filterValue := record.GetFilterValue()
+
+			if !strings.Contains(filterValue, "Test Publication") {
+				t.Errorf("GetFilterValue() should contain title, got: %s", filterValue)
+			}
+			if !strings.Contains(filterValue, "Publication content") {
+				t.Errorf("GetFilterValue() should contain content, got: %s", filterValue)
+			}
+			if !strings.Contains(filterValue, "test-rkey-123") {
+				t.Errorf("GetFilterValue() should contain rkey, got: %s", filterValue)
+			}
+		})
+
+		t.Run("GetFilterValue handles missing rkey", func(t *testing.T) {
+			noteWithoutRKey := &models.Note{
+				ID:      5,
+				Title:   "No RKey Note",
+				Content: "Some content",
+			}
+			recordWithoutRKey := &PublicationRecord{Note: noteWithoutRKey}
+
+			filterValue := recordWithoutRKey.GetFilterValue()
+
+			if !strings.Contains(filterValue, "No RKey Note") {
+				t.Errorf("GetFilterValue() should contain title, got: %s", filterValue)
+			}
+			if !strings.Contains(filterValue, "Some content") {
+				t.Errorf("GetFilterValue() should contain content, got: %s", filterValue)
+			}
+		})
+	})
+
+	t.Run("PublicationDataSource", func(t *testing.T) {
+		rkey1 := "rkey-published"
+		rkey2 := "rkey-draft"
+		publishedAt := time.Date(2024, 1, 10, 0, 0, 0, 0, time.UTC)
+
+		notes := []*models.Note{
+			{
+				ID:          1,
+				Title:       "Published Article",
+				Content:     "Published content",
+				IsDraft:     false,
+				PublishedAt: &publishedAt,
+				LeafletRKey: &rkey1,
+				Modified:    time.Now(),
+			},
+			{
+				ID:          2,
+				Title:       "Draft Article",
+				Content:     "Draft content",
+				IsDraft:     true,
+				LeafletRKey: &rkey2,
+				Modified:    time.Now(),
+			},
+			{
+				ID:       3,
+				Title:    "Another Published",
+				Content:  "More published content",
+				IsDraft:  false,
+				Modified: time.Now(),
+			},
+		}
+
+		t.Run("Load with all filter", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			items, err := source.Load(context.Background(), ListOptions{})
+			if err != nil {
+				t.Fatalf("Load() failed: %v", err)
+			}
+
+			if len(items) != 3 {
+				t.Errorf("Load() with filter 'all' returned %d items, want 3", len(items))
+			}
+		})
+
+		t.Run("Load with published filter", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "published"}
+
+			items, err := source.Load(context.Background(), ListOptions{})
+			if err != nil {
+				t.Fatalf("Load() failed: %v", err)
+			}
+
+			if len(items) != 2 {
+				t.Errorf("Load() with filter 'published' returned %d items, want 2", len(items))
+			}
+
+			for _, item := range items {
+				pubRecord := item.(*PublicationRecord)
+				if pubRecord.IsDraft {
+					t.Error("Load() with 'published' filter should not return drafts")
+				}
+			}
+		})
+
+		t.Run("Load with draft filter", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "draft"}
+
+			items, err := source.Load(context.Background(), ListOptions{})
+			if err != nil {
+				t.Fatalf("Load() failed: %v", err)
+			}
+
+			if len(items) != 1 {
+				t.Errorf("Load() with filter 'draft' returned %d items, want 1", len(items))
+			}
+
+			pubRecord := items[0].(*PublicationRecord)
+			if !pubRecord.IsDraft {
+				t.Error("Load() with 'draft' filter should only return drafts")
+			}
+		})
+
+		t.Run("Load with search query", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			items, err := source.Load(context.Background(), ListOptions{Search: "Draft"})
+			if err != nil {
+				t.Fatalf("Load() with search failed: %v", err)
+			}
+
+			if len(items) != 1 {
+				t.Errorf("Load() with search 'Draft' returned %d items, want 1", len(items))
+			}
+
+			if items[0].GetTitle() != "[2] Draft Article (draft)" {
+				t.Errorf("Search result title = %q, want '[2] Draft Article (draft)'", items[0].GetTitle())
+			}
+		})
+
+		t.Run("Load with search in content", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			items, err := source.Load(context.Background(), ListOptions{Search: "Draft content"})
+			if err != nil {
+				t.Fatalf("Load() with content search failed: %v", err)
+			}
+
+			if len(items) != 1 {
+				t.Errorf("Load() searching content returned %d items, want 1", len(items))
+			}
+		})
+
+		t.Run("Load with search in rkey", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			items, err := source.Load(context.Background(), ListOptions{Search: "rkey-draft"})
+			if err != nil {
+				t.Fatalf("Load() with rkey search failed: %v", err)
+			}
+
+			if len(items) != 1 {
+				t.Errorf("Load() searching rkey returned %d items, want 1", len(items))
+			}
+
+			pubRecord := items[0].(*PublicationRecord)
+			if *pubRecord.LeafletRKey != "rkey-draft" {
+				t.Errorf("Found note with rkey %q, want 'rkey-draft'", *pubRecord.LeafletRKey)
+			}
+		})
+
+		t.Run("Load with limit", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			items, err := source.Load(context.Background(), ListOptions{Limit: 2})
+			if err != nil {
+				t.Fatalf("Load() with limit failed: %v", err)
+			}
+
+			if len(items) != 2 {
+				t.Errorf("Load() with limit 2 returned %d items, want 2", len(items))
+			}
+		})
+
+		t.Run("Load error handling", func(t *testing.T) {
+			testErr := fmt.Errorf("database error")
+			mockRepo := &mockPublicationRepository{err: testErr}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			_, err := source.Load(context.Background(), ListOptions{})
+			if err != testErr {
+				t.Errorf("Load() error = %v, want %v", err, testErr)
+			}
+		})
+
+		t.Run("Count", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			count, err := source.Count(context.Background(), ListOptions{})
+			if err != nil {
+				t.Fatalf("Count() failed: %v", err)
+			}
+
+			if count != 3 {
+				t.Errorf("Count() = %d, want 3", count)
+			}
+		})
+
+		t.Run("Count with filter", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "draft"}
+
+			count, err := source.Count(context.Background(), ListOptions{})
+			if err != nil {
+				t.Fatalf("Count() with filter failed: %v", err)
+			}
+
+			if count != 1 {
+				t.Errorf("Count() with draft filter = %d, want 1", count)
+			}
+		})
+
+		t.Run("Search", func(t *testing.T) {
+			mockRepo := &mockPublicationRepository{notes: notes}
+			source := &PublicationDataSource{repo: mockRepo, filter: "all"}
+
+			items, err := source.Search(context.Background(), "Published", ListOptions{})
+			if err != nil {
+				t.Fatalf("Search() failed: %v", err)
+			}
+
+			if len(items) != 2 {
+				t.Errorf("Search() for 'Published' returned %d items, want 2", len(items))
+			}
+		})
+	})
+
+	t.Run("NewPublicationDataList", func(t *testing.T) {
+		notes := []*models.Note{
+			{
+				ID:       1,
+				Title:    "Test Publication",
+				Content:  "Test content",
+				IsDraft:  false,
+				Modified: time.Now(),
+			},
+		}
+
+		mockRepo := &mockPublicationRepository{notes: notes}
+
+		opts := DataListOptions{
+			Output: &bytes.Buffer{},
+			Input:  strings.NewReader("q\n"),
+			Static: true,
+		}
+
+		list := NewPublicationDataList(mockRepo, opts, "all")
+		if list == nil {
+			t.Fatal("NewPublicationDataList() returned nil")
+		}
+
+		err := list.Browse(context.Background())
+		if err != nil {
+			t.Errorf("Browse() failed: %v", err)
+		}
+	})
+
+	t.Run("NewPublicationListFromList", func(t *testing.T) {
+		notes := []*models.Note{
+			{
+				ID:       1,
+				Title:    "Test Publication",
+				Content:  "Test content",
+				IsDraft:  false,
+				Modified: time.Now(),
+			},
+		}
+
+		mockRepo := &mockPublicationRepository{notes: notes}
+
+		output := &bytes.Buffer{}
+		input := strings.NewReader("q\n")
+
+		list := NewPublicationListFromList(mockRepo, output, input, true, "all")
+		if list == nil {
+			t.Fatal("NewPublicationListFromList() returned nil")
+		}
+
+		err := list.Browse(context.Background())
+		if err != nil {
+			t.Errorf("Browse() failed: %v", err)
+		}
+
+		outputStr := output.String()
+		if !strings.Contains(outputStr, "Publications") {
+			t.Error("Output should contain 'Publications' title")
+		}
+		if !strings.Contains(outputStr, "Test Publication") {
+			t.Error("Output should contain publication title")
+		}
+	})
+
+	t.Run("formatPublicationForView", func(t *testing.T) {
+		t.Run("formats published note with all metadata", func(t *testing.T) {
+			rkey := "test-rkey"
+			cid := "test-cid"
+			publishedAt := time.Date(2024, 1, 15, 10, 0, 0, 0, time.UTC)
+
+			note := &models.Note{
+				ID:          1,
+				Title:       "Test Article",
+				Content:     "# Test Article\n\nThis is the article content.",
+				IsDraft:     false,
+				PublishedAt: &publishedAt,
+				Modified:    time.Date(2024, 1, 16, 12, 0, 0, 0, time.UTC),
+				LeafletRKey: &rkey,
+				LeafletCID:  &cid,
+			}
+
+			result := formatPublicationForView(note)
+
+			if !strings.Contains(result, "Test Article") {
+				t.Errorf("Formatted view should contain title\nGot: %s", result)
+			}
+			if !strings.Contains(result, "published") {
+				t.Errorf("Formatted view should contain status 'published'\nGot: %s", result)
+			}
+			if !strings.Contains(result, "2024-01-15") {
+				t.Errorf("Formatted view should contain published date\nGot: %s", result)
+			}
+			if !strings.Contains(result, "Modified") && !strings.Contains(result, "2024-01-16") {
+				t.Errorf("Formatted view should contain modified date\nGot: %s", result)
+			}
+			if !strings.Contains(result, "test-rkey") {
+				t.Error("Formatted view should contain rkey")
+			}
+			if !strings.Contains(result, "test-cid") {
+				t.Error("Formatted view should contain cid")
+			}
+		})
+
+		t.Run("formats draft note", func(t *testing.T) {
+			note := &models.Note{
+				ID:       2,
+				Title:    "Draft Article",
+				Content:  "Draft content here.",
+				IsDraft:  true,
+				Modified: time.Date(2024, 1, 20, 14, 0, 0, 0, time.UTC),
+			}
+
+			result := formatPublicationForView(note)
+
+			if !strings.Contains(result, "Draft Article") {
+				t.Error("Formatted view should contain title")
+			}
+			if !strings.Contains(result, "draft") {
+				t.Error("Formatted view should contain status 'draft'")
+			}
+			if strings.Contains(result, "Published:") {
+				t.Error("Formatted draft view should not contain published date")
+			}
+			if !strings.Contains(result, "2024-01-20 14:00") {
+				t.Error("Formatted view should contain modified date")
+			}
+		})
+
+		t.Run("handles content without title header", func(t *testing.T) {
+			note := &models.Note{
+				ID:       3,
+				Title:    "Plain Content",
+				Content:  "This content has no markdown header.",
+				IsDraft:  false,
+				Modified: time.Now(),
+			}
+
+			result := formatPublicationForView(note)
+
+			if !strings.Contains(result, "Plain Content") {
+				t.Error("Formatted view should contain title")
+			}
+			if !strings.Contains(result, "This content has no markdown header") {
+				t.Error("Formatted view should contain full content")
+			}
+		})
+
+		t.Run("strips duplicate title from content", func(t *testing.T) {
+			note := &models.Note{
+				ID:       4,
+				Title:    "Article Title",
+				Content:  "# Article Title\n\nContent after title.",
+				IsDraft:  false,
+				Modified: time.Now(),
+			}
+
+			result := formatPublicationForView(note)
+
+			titleCount := strings.Count(result, "Article Title")
+			if titleCount < 1 {
+				t.Error("Formatted view should contain title at least once")
+			}
+			if !strings.Contains(result, "Content after title") {
+				t.Error("Formatted view should contain content after title")
+			}
+		})
+	})
+}

internal/utils/utils.go

···
 		logger.SetLevel(log.InfoLevel)
 	}
 
-	// Set format
 	if format == "json" {
 		logger.SetFormatter(log.JSONFormatter)
 	} else {
···
 	List(ctx context.Context, options repo.BookListOptions) ([]*models.Book, error)
 }
 
-// TestNoteRepository interface for dependency injection in tests
+// TestNoteRepository interface for dependency injection in tests.
 type TestNoteRepository interface {
 	List(ctx context.Context, options repo.NoteListOptions) ([]*models.Note, error)
+	ListPublished(ctx context.Context) ([]*models.Note, error)
+	ListDrafts(ctx context.Context) ([]*models.Note, error)
+	GetLeafletNotes(ctx context.Context) ([]*models.Note, error)
 }

justfile

···
 
 # Run all tests
 test:
-    go test ./... -v
+    go test ./...
 
 # Run tests with coverage
 coverage: