feat(wip): pull & list document commands

cmd/main.go

···
 	root.SetHelpCommand(&cobra.Command{Hidden: true})
 	cobra.EnableCommandSorting = false
 
-	root.AddGroup(&cobra.Group{ID: "core", Title: "Core Commands:"})
-	root.AddGroup(&cobra.Group{ID: "management", Title: "Management Commands:"})
+	root.AddGroup(&cobra.Group{ID: "core", Title: "Core:"})
+	root.AddGroup(&cobra.Group{ID: "management", Title: "Manage:"})
 	return root
 }
 
···
 	root := rootCmd()
 
 	coreGroups := []CommandGroup{
-		NewTaskCommand(taskHandler), NewNoteCommand(noteHandler), NewArticleCommand(articleHandler),
+		NewTaskCommand(taskHandler),
+		NewNoteCommand(noteHandler),
 		NewPublicationCommand(publicationHandler),
+		NewArticleCommand(articleHandler),
 	}
 
 	for _, group := range coreGroups {

cmd/task_commands.go

···
 time tracking. Tasks can be filtered by status, priority, project, or context.`,
 	}
 
+	root.AddGroup(
+		&cobra.Group{ID: "task-ops", Title: "Basic Operations"},
+		&cobra.Group{ID: "task-meta", Title: "Metadata"},
+		&cobra.Group{ID: "task-tracking", Title: "Tracking"},
+	)
+
 	for _, init := range []func(*handlers.TaskHandler) *cobra.Command{
-		addTaskCmd, listTaskCmd, viewTaskCmd, updateTaskCmd, editTaskCmd,
-		deleteTaskCmd, taskProjectsCmd, taskTagsCmd, taskContextsCmd,
-		taskCompleteCmd, taskStartCmd, taskStopCmd, timesheetViewCmd,
-		taskRecurCmd, taskDependCmd,
+		addTaskCmd, listTaskCmd, viewTaskCmd, updateTaskCmd, editTaskCmd, deleteTaskCmd,
 	} {
 		cmd := init(c.handler)
+		cmd.GroupID = "task-ops"
+		root.AddCommand(cmd)
+	}
+
+	for _, init := range []func(*handlers.TaskHandler) *cobra.Command{
+		taskProjectsCmd, taskTagsCmd, taskContextsCmd,
+	} {
+		cmd := init(c.handler)
+		cmd.GroupID = "task-meta"
+		root.AddCommand(cmd)
+	}
+
+	for _, init := range []func(*handlers.TaskHandler) *cobra.Command{
+		timesheetViewCmd, taskStartCmd, taskStopCmd, taskCompleteCmd, taskRecurCmd, taskDependCmd,
+	} {
+		cmd := init(c.handler)
+		cmd.GroupID = "task-tracking"
 		root.AddCommand(cmd)
 	}
 
···
 Examples:
   noteleaf todo add "Write documentation" --priority high --project docs
   noteleaf todo add "Weekly review" --recur "FREQ=WEEKLY" --due 2024-01-15`,
-		Args:    cobra.MinimumNArgs(1),
+		Args: cobra.MinimumNArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			description := strings.Join(args, " ")
 			priority, _ := c.Flags().GetString("priority")
···
 Shows all task attributes including description, status, priority, project,
 context, tags, due date, creation time, and modification history. Use --json
 for machine-readable output or --no-metadata to show only the description.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			format, _ := cmd.Flags().GetString("format")
 			jsonOutput, _ := cmd.Flags().GetBool("json")
···
 Examples:
   noteleaf todo update 123 --priority urgent --due tomorrow
   noteleaf todo update 456 --add-tag urgent --project website`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			taskID := args[0]
 			description, _ := cmd.Flags().GetString("description")
···
 
 Records the start time for a work session. Only one task can be actively
 tracked at a time. Use --note to add a description of what you're working on.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			taskID := args[0]
 			description, _ := c.Flags().GetString("note")
···
 
 Records the end time and calculates duration for the current work session.
 Duration is added to the task's total time tracked.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			taskID := args[0]
 			defer h.Close()
···
 
 Provides a user-friendly interface with status picker and priority toggle.
 Easier than using multiple command-line flags for complex updates.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			taskID := args[0]
 			defer h.Close()
···
 
 This operation cannot be undone. Consider updating the task status to
 'deleted' instead if you want to preserve the record for historical purposes.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
 			return h.Delete(c.Context(), args)
···
 
 Sets the task status to 'completed' and records the completion time. For
 recurring tasks, generates the next instance based on the recurrence rule.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
 			return h.Done(c.Context(), args)
···
 Examples:
   noteleaf todo recur set 123 --rule "FREQ=DAILY"
   noteleaf todo recur set 456 --rule "FREQ=WEEKLY;BYDAY=MO" --until 2024-12-31`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			rule, _ := c.Flags().GetString("rule")
 			until, _ := c.Flags().GetString("until")
···
 
 Converts a recurring task to a one-time task. Existing future instances are not
 affected.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
 			return h.ClearRecur(c.Context(), args[0])
···
 
 Shows the RRULE pattern, next occurrence date, and recurrence end date if
 configured.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
 			return h.ShowRecur(c.Context(), args[0])
···
 
 The first task cannot be started until the second task is completed. Use task
 UUIDs to specify dependencies.`,
-		Args:  cobra.ExactArgs(2),
+		Args: cobra.ExactArgs(2),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
 			return h.AddDep(c.Context(), args[0], args[1])

internal/handlers/publication.go

···
-// TODO: Implement document processing
-// For each document:
-//  1. Check if note with this leaflet_rkey exists
-//  2. If exists: Update note content, title, metadata
-//  3. If new: Create new note with leaflet metadata
-//  4. Convert document blocks to markdown
-//  5. Save to database
-//
-// TODO: Implement list functionality
-//  1. Query notes where leaflet_rkey IS NOT NULL
-//  2. Apply filter (published vs draft) - "all", "published", "draft", or empty (default: all)
-//  3. Use prior art from package ui and other handlers to render
+// Package handlers provides command handlers for leaflet publication operations.
 //
-// TODO: Implmenent pull command
+// Pull command:
 //  1. Authenticates with AT Protocol
 //  2. Fetches all pub.leaflet.document records
 //  3. Creates new notes for documents not seen before
 //  4. Updates existing notes (matched by leaflet_rkey)
 //  5. Shows summary of pulled documents
+//
+// List command:
+//  1. Query notes where leaflet_rkey IS NOT NULL
+//  2. Apply filter (published vs draft) - "all", "published", "draft", or empty (default: all)
+//  3. Static output (TUI viewing marked as TODO)
+//
+// TODO: Add TUI viewing for document details
 package handlers
 
 import (
···
 	"fmt"
 	"time"
 
+	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/public"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
 	"github.com/stormlightlabs/noteleaf/internal/services"
 	"github.com/stormlightlabs/noteleaf/internal/store"
+	"github.com/stormlightlabs/noteleaf/internal/ui"
 )
 
 // PublicationHandler handles leaflet publication commands
···
 		return fmt.Errorf("password is required")
 	}
 
-	fmt.Printf("Authenticating as %s...\n", handle)
+	ui.Infoln("Authenticating as %s...", handle)
 
 	if err := h.atproto.Authenticate(ctx, handle, password); err != nil {
 		return fmt.Errorf("authentication failed: %w", err)
···
 		return fmt.Errorf("authentication successful but failed to save credentials: %w", err)
 	}
 
-	fmt.Println("✓ Authentication successful!")
-	fmt.Println("✓ Credentials saved")
+	ui.Successln("Authentication successful!")
+	ui.Successln("Credentials saved")
 	return nil
+}
+
+// documentToMarkdown converts a leaflet Document to markdown content
+func documentToMarkdown(doc services.DocumentWithMeta) (string, error) {
+	converter := public.NewMarkdownConverter()
+	var allBlocks []public.BlockWrap
+
+	for _, page := range doc.Document.Pages {
+		allBlocks = append(allBlocks, page.Blocks...)
+	}
+
+	content, err := converter.FromLeaflet(allBlocks)
+	if err != nil {
+		return "", fmt.Errorf("failed to convert document to markdown: %w", err)
+	}
+
+	return content, nil
 }
 
 // Pull fetches all documents from leaflet and creates/updates local notes
 func (h *PublicationHandler) Pull(ctx context.Context) error {
-	fmt.Println("TODO: Implement document conversion and note creation")
+	if !h.atproto.IsAuthenticated() {
+		return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first")
+	}
+
+	ui.Infoln("Fetching documents from leaflet...")
+
+	docs, err := h.atproto.PullDocuments(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to fetch documents: %w", err)
+	}
+
+	if len(docs) == 0 {
+		ui.Infoln("No documents found in leaflet.")
+		return nil
+	}
+
+	ui.Infoln("Found %d document(s). Syncing...\n", len(docs))
+
+	var created, updated int
+
+	for _, doc := range docs {
+		existing, err := h.repos.Notes.GetByLeafletRKey(ctx, doc.Meta.RKey)
+		if err == nil && existing != nil {
+			content, err := documentToMarkdown(doc)
+			if err != nil {
+				ui.Warningln("⚠ Skipping document %s: %v", doc.Document.Title, err)
+				continue
+			}
+
+			existing.Title = doc.Document.Title
+			existing.Content = content
+			existing.LeafletCID = &doc.Meta.CID
+			existing.IsDraft = doc.Meta.IsDraft
+
+			if doc.Document.PublishedAt != "" {
+				publishedAt, err := time.Parse(time.RFC3339, doc.Document.PublishedAt)
+				if err == nil {
+					existing.PublishedAt = &publishedAt
+				}
+			}
+
+			if err := h.repos.Notes.Update(ctx, existing); err != nil {
+				ui.Warningln("⚠ Failed to update note for document %s: %v", doc.Document.Title, err)
+				continue
+			}
+
+			updated++
+			ui.Infoln("  Updated: %s", doc.Document.Title)
+		} else {
+			content, err := documentToMarkdown(doc)
+			if err != nil {
+				ui.Warningln("⚠ Skipping document %s: %v", doc.Document.Title, err)
+				continue
+			}
+
+			note := &models.Note{
+				Title:       doc.Document.Title,
+				Content:     content,
+				LeafletRKey: &doc.Meta.RKey,
+				LeafletCID:  &doc.Meta.CID,
+				IsDraft:     doc.Meta.IsDraft,
+			}
+
+			if doc.Document.PublishedAt != "" {
+				publishedAt, err := time.Parse(time.RFC3339, doc.Document.PublishedAt)
+				if err == nil {
+					note.PublishedAt = &publishedAt
+				}
+			}
+
+			_, err = h.repos.Notes.Create(ctx, note)
+			if err != nil {
+				ui.Warningln("⚠ Failed to create note for document %s: %v", doc.Document.Title, err)
+				continue
+			}
+
+			created++
+			ui.Infoln("  Created: %s", doc.Document.Title)
+		}
+	}
+
+	ui.Successln("Sync complete: %d created, %d updated", created, updated)
 	return nil
 }
 
+// printPublication prints a single publication note in static format
+func printPublication(note *models.Note) {
+	status := "published"
+	if note.IsDraft {
+		status = "draft"
+	}
+
+	ui.Infoln("[%d] %s (%s)", note.ID, note.Title, status)
+
+	if note.LeafletRKey != nil {
+		ui.Infoln("    rkey: %s", *note.LeafletRKey)
+	}
+
+	if note.PublishedAt != nil {
+		ui.Infoln("    published: %s", note.PublishedAt.Format("2006-01-02 15:04:05"))
+	}
+
+	ui.Infoln("    modified: %s", note.Modified.Format("2006-01-02 15:04:05"))
+	ui.Newline()
+}
+
 // List displays notes with leaflet publication metadata, showing all notes that have been pulled from or pushed to leaflet
 func (h *PublicationHandler) List(ctx context.Context, filter string) error {
-	fmt.Println("TODO: Implement leaflet document listing")
+	if filter == "" {
+		filter = "all"
+	}
+
+	var notes []*models.Note
+	var err error
+
+	switch filter {
+	case "all":
+		notes, err = h.repos.Notes.GetLeafletNotes(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch leaflet notes: %w", err)
+		}
+	case "published":
+		notes, err = h.repos.Notes.ListPublished(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch published notes: %w", err)
+		}
+	case "draft":
+		notes, err = h.repos.Notes.ListDrafts(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to fetch draft notes: %w", err)
+		}
+	default:
+		return fmt.Errorf("invalid filter: %s (must be 'all', 'published', or 'draft')", filter)
+	}
+
+	if len(notes) == 0 {
+		ui.Infoln("No %s documents found.", filter)
+		return nil
+	}
+
+	ui.Infoln("Found %d %s document(s):", len(notes), filter)
+	ui.Newline()
+
+	for _, note := range notes {
+		printPublication(note)
+	}
+
 	return nil
 }
 

internal/handlers/tasks.go

···
+// TODO: add context field to table in [TaskHandler.listTasksInteractive]
 package handlers
 
 import (
···
 	return nil
 }
 
-// TODO: include context field
 func (h *TaskHandler) listTasksInteractive(ctx context.Context, showAll bool, status, priority, project, _ string) error {
 	taskTable := ui.NewTaskListFromTable(h.repos.Tasks, os.Stdout, os.Stdin, false, showAll, status, priority, project)
 	return taskTable.Browse(ctx)

internal/ui/task_list_adapter.go

···
+// TODO: Use glamour to render the markdown produced by [formatTaskForView]
+// TODO: remove the ID from the table
 package ui
 
 import (