refactor: use single task handler instance in task command

cmd/commands.go

···
+/*
+TODO: Implement movie addition
+TODO: Implement movie listing
+TODO: Implement movie watched status
+TODO: Implement movie removal
+TODO: Implement TV show addition
+TODO: Implement TV show listing
+TODO: Implement TV show watched status
+TODO: Implement TV show removal
+TODO: Implement config management
+*/
 package main
 
 import (
···
 		Short:   "task management",
 	}
 
-	root.AddCommand(&cobra.Command{
+	addCmd := &cobra.Command{
 		Use:     "add [description]",
 		Short:   "Add a new task",
 		Aliases: []string{"create", "new"},
 		Args:    cobra.MinimumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.CreateTask(cmd.Context(), args)
+			priority, _ := cmd.Flags().GetString("priority")
+			project, _ := cmd.Flags().GetString("project")
+			due, _ := cmd.Flags().GetString("due")
+			tags, _ := cmd.Flags().GetStringSlice("tags")
+
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.Create(cmd.Context(), args, priority, project, due, tags)
 		},
-	})
+	}
+	addCmd.Flags().StringP("priority", "p", "", "Set task priority")
+	addCmd.Flags().String("project", "", "Set task project")
+	addCmd.Flags().StringP("due", "d", "", "Set due date (YYYY-MM-DD)")
+	addCmd.Flags().StringSliceP("tags", "t", []string{}, "Add tags to task")
+	root.AddCommand(addCmd)
 
 	listCmd := &cobra.Command{
 		Use:     "list",
···
 			priority, _ := cmd.Flags().GetString("priority")
 			project, _ := cmd.Flags().GetString("project")
 
-			return handlers.ListTasks(cmd.Context(), static, showAll, status, priority, project)
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.List(cmd.Context(), static, showAll, status, priority, project)
 		},
 	}
 	listCmd.Flags().BoolP("interactive", "i", false, "Force interactive mode (default)")
···
 	listCmd.Flags().String("project", "", "Filter by project")
 	root.AddCommand(listCmd)
 
-	root.AddCommand(&cobra.Command{
+	viewCmd := &cobra.Command{
 		Use:   "view [task-id]",
 		Short: "View task by ID",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.ViewTask(cmd.Context(), args)
+			format, _ := cmd.Flags().GetString("format")
+			jsonOutput, _ := cmd.Flags().GetBool("json")
+			noMetadata, _ := cmd.Flags().GetBool("no-metadata")
+
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.View(cmd.Context(), args, format, jsonOutput, noMetadata)
 		},
-	})
+	}
+	viewCmd.Flags().String("format", "detailed", "Output format (detailed, brief)")
+	viewCmd.Flags().Bool("json", false, "Output as JSON")
+	viewCmd.Flags().Bool("no-metadata", false, "Hide creation/modification timestamps")
+	root.AddCommand(viewCmd)
 
 	root.AddCommand(&cobra.Command{
 		Use:   "update [task-id] [options...]",
 		Short: "Update task properties",
 		Args:  cobra.MinimumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.UpdateTask(cmd.Context(), args)
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.Update(cmd.Context(), args)
 		},
 	})
 
···
 		Short: "Delete a task",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.DeleteTask(cmd.Context(), args)
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.Delete(cmd.Context(), args)
 		},
 	})
 
···
 		Aliases: []string{"proj"},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			static, _ := cmd.Flags().GetBool("static")
-			return handlers.ListProjects(cmd.Context(), static)
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.ListProjects(cmd.Context(), static)
 		},
 	}
 	projectsCmd.Flags().Bool("static", false, "Use static text output instead of interactive")
···
 		Aliases: []string{"t"},
 		RunE: func(cmd *cobra.Command, args []string) error {
 			static, _ := cmd.Flags().GetBool("static")
-			return handlers.ListTags(cmd.Context(), static)
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.ListTags(cmd.Context(), static)
 		},
 	}
 	tagsCmd.Flags().Bool("static", false, "Use static text output instead of interactive")
···
 		Aliases: []string{"complete"},
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.DoneTask(cmd.Context(), args)
+			handler, err := handlers.NewTaskHandler()
+			if err != nil {
+				return err
+			}
+			defer handler.Close()
+			return handler.Done(cmd.Context(), args)
 		},
 	})
 
···
 		RunE: func(cmd *cobra.Command, args []string) error {
 			title := args[0]
 			fmt.Printf("Adding movie: %s\n", title)
-			// TODO: Implement movie addition
 			return nil
 		},
 	})
···
 		Short: "List movies in queue",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Println("Listing movies...")
-			// TODO: Implement movie listing
 			return nil
 		},
 	})
···
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Printf("Marking movie %s as watched\n", args[0])
-			// TODO: Implement movie watched status
 			return nil
 		},
 	})
···
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Printf("Removing movie %s from queue\n", args[0])
-			// TODO: Implement movie removal
 			return nil
 		},
 	})
···
 		RunE: func(cmd *cobra.Command, args []string) error {
 			title := args[0]
 			fmt.Printf("Adding TV show: %s\n", title)
-			// TODO: Implement TV show addition
 			return nil
 		},
 	})
···
 		Short: "List TV shows in queue",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Println("Listing TV shows...")
-			// TODO: Implement TV show listing
 			return nil
 		},
 	})
···
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Printf("Marking TV show %s as watched\n", args[0])
-			// TODO: Implement TV show watched status
 			return nil
 		},
 	})
···
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Printf("Removing TV show %s from queue\n", args[0])
-			// TODO: Implement TV show removal
 			return nil
 		},
 	})
···
 		RunE: func(cmd *cobra.Command, args []string) error {
 			key, value := args[0], args[1]
 			fmt.Printf("Setting config %s = %s\n", key, value)
-			// TODO: Implement config management
 			return nil
 		},
 	}

go.mod

···
 	github.com/yuin/goldmark v1.7.8 // indirect
 	github.com/yuin/goldmark-emoji v1.0.5 // indirect
 	golang.org/x/net v0.33.0 // indirect
-	golang.org/x/sync v0.13.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
 	golang.org/x/term v0.31.0 // indirect
 )
 
···
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.24.0
+	golang.org/x/text v0.28.0
 )

go.sum

···
 golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
 golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
-golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
 golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
 golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
-golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
-golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
 golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

internal/handlers/notes.go

···
 	return h.createFromArgs(ctx, title, content)
 }
 
-// Edit handles note editing by ID
-func (h *NoteHandler) Edit(ctx context.Context, noteID int64) error {
-	return h.editNote(ctx, noteID)
-}
-
-// View displays a note with formatted markdown content
-func (h *NoteHandler) View(ctx context.Context, noteID int64) error {
-	return h.viewNote(ctx, noteID)
-}
-
-// List opens either an interactive TUI browser for navigating and viewing notes or a static list
-func (h *NoteHandler) List(ctx context.Context, static, showArchived bool, tags []string) error {
-	return h.listNotes(ctx, showArchived, tags, static)
-}
-
-// Delete permanently removes a note and its metadata
-func (h *NoteHandler) Delete(ctx context.Context, noteID int64) error {
-	return h.deleteNote(ctx, noteID)
-}
-
 func (h *NoteHandler) createInteractive(ctx context.Context) error {
 	logger := utils.GetLogger()
 
···
 		var response string
 		fmt.Scanln(&response)
 		if strings.ToLower(response) == "y" || strings.ToLower(response) == "yes" {
-			return h.editNote(ctx, id)
+			return h.Edit(ctx, id)
 		}
 	}
 
 	return nil
 }
 
-func (h *NoteHandler) editNote(ctx context.Context, id int64) error {
+// Edit handles note editing by ID
+func (h *NoteHandler) Edit(ctx context.Context, id int64) error {
 	note, err := h.repos.Notes.Get(ctx, id)
 	if err != nil {
 		return fmt.Errorf("failed to get note: %w", err)
···
 	return content.String()
 }
 
-func (h *NoteHandler) viewNote(ctx context.Context, id int64) error {
+// 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)
 	if err != nil {
 		return fmt.Errorf("failed to get note: %w", err)
···
 	return nil
 }
 
-func (h *NoteHandler) formatNoteForView(note *models.Note) string {
-	var content strings.Builder
-
-	content.WriteString("# " + note.Title + "\n\n")
-
-	if len(note.Tags) > 0 {
-		content.WriteString("**Tags:** ")
-		for i, tag := range note.Tags {
-			if i > 0 {
-				content.WriteString(", ")
-			}
-			content.WriteString("`" + tag + "`")
-		}
-		content.WriteString("\n\n")
-	}
-
-	content.WriteString("**Created:** " + note.Created.Format("2006-01-02 15:04") + "\n")
-	content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n\n")
-	content.WriteString("---\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"))
-		}
-	}
-
-	return content.String()
-}
-
-func (h *NoteHandler) listNotes(ctx context.Context, showArchived bool, tags []string, static bool) error {
+// List opens either an interactive TUI browser for navigating and viewing notes or a static list
+func (h *NoteHandler) List(ctx context.Context, static, showArchived bool, tags []string) error {
 	opts := ui.NoteListOptions{
 		Output:       os.Stdout,
 		Input:        os.Stdin,
···
 	return noteList.Browse(ctx)
 }
 
-func (h *NoteHandler) deleteNote(ctx context.Context, id int64) error {
+// Delete permanently removes a note and its metadata
+func (h *NoteHandler) Delete(ctx context.Context, id int64) error {
 	note, err := h.repos.Notes.Get(ctx, id)
 	if err != nil {
 		return fmt.Errorf("failed to find note: %w", err)
···
 	}
 	return nil
 }
+
+func (h *NoteHandler) formatNoteForView(note *models.Note) string {
+	var content strings.Builder
+
+	content.WriteString("# " + note.Title + "\n\n")
+
+	if len(note.Tags) > 0 {
+		content.WriteString("**Tags:** ")
+		for i, tag := range note.Tags {
+			if i > 0 {
+				content.WriteString(", ")
+			}
+			content.WriteString("`" + tag + "`")
+		}
+		content.WriteString("\n\n")
+	}
+
+	content.WriteString("**Created:** " + note.Created.Format("2006-01-02 15:04") + "\n")
+	content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n\n")
+	content.WriteString("---\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"))
+		}
+	}
+
+	return content.String()
+}

internal/handlers/tasks.go

···
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"slices"
 	"strconv"
···
 	"github.com/stormlightlabs/noteleaf/internal/repo"
 	"github.com/stormlightlabs/noteleaf/internal/store"
 	"github.com/stormlightlabs/noteleaf/internal/ui"
+	"golang.org/x/text/feature/plural"
+	"golang.org/x/text/language"
 )
 
 // TaskHandler handles all task-related commands
···
 	return h.db.Close()
 }
 
-// CreateTask creates a new task
-func CreateTask(ctx context.Context, args []string) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
-	return handler.createTask(ctx, args)
-}
-
-func (h *TaskHandler) createTask(ctx context.Context, args []string) error {
-	if len(args) < 1 {
+// Create creates a new task
+func (h *TaskHandler) Create(ctx context.Context, desc []string, priority, project, due string, tags []string) error {
+	if len(desc) < 1 {
 		return fmt.Errorf("task description required")
 	}
 
-	description := strings.Join(args, " ")
+	description := strings.Join(desc, " ")
 
 	task := &models.Task{
 		UUID:        uuid.New().String(),
 		Description: description,
 		Status:      "pending",
+		Priority:    priority,
+		Project:     project,
+		Tags:        tags,
+	}
+
+	if due != "" {
+		if dueTime, err := time.Parse("2006-01-02", due); err == nil {
+			task.Due = &dueTime
+		} else {
+			return fmt.Errorf("invalid due date format, use YYYY-MM-DD: %w", err)
+		}
 	}
 
 	id, err := h.repos.Tasks.Create(ctx, task)
···
 	}
 
 	fmt.Printf("Task created (ID: %d, UUID: %s): %s\n", id, task.UUID, task.Description)
+
+	if priority != "" {
+		fmt.Printf("Priority: %s\n", priority)
+	}
+	if project != "" {
+		fmt.Printf("Project: %s\n", project)
+	}
+	if len(tags) > 0 {
+		fmt.Printf("Tags: %s\n", strings.Join(tags, ", "))
+	}
+	if task.Due != nil {
+		fmt.Printf("Due: %s\n", task.Due.Format("2006-01-02"))
+	}
+
 	return nil
 }
 
-// ListTasks lists all tasks with optional filtering
-func ListTasks(ctx context.Context, static, showAll bool, status, priority, project string) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
+// List lists all tasks with optional filtering
+func (h *TaskHandler) List(ctx context.Context, static, showAll bool, status, priority, project string) error {
 	if static {
-		return handler.listTasksStatic(ctx, showAll, status, priority, project)
+		return h.listTasksStatic(ctx, showAll, status, priority, project)
 	}
 
-	return handler.listTasksInteractive(ctx, showAll, status, priority, project)
+	return h.listTasksInteractive(ctx, showAll, status, priority, project)
 }
 
 func (h *TaskHandler) listTasksStatic(ctx context.Context, showAll bool, status, priority, project string) error {
···
 	return taskList.Browse(ctx)
 }
 
-// UpdateTask updates an existing task
-func UpdateTask(ctx context.Context, args []string) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
-	return handler.updateTask(ctx, args)
-}
-
-func (h *TaskHandler) updateTask(ctx context.Context, args []string) error {
+func (h *TaskHandler) Update(ctx context.Context, args []string) error {
 	if len(args) < 1 {
 		return fmt.Errorf("task ID required")
 	}
···
 	return nil
 }
 
-// DeleteTask deletes a task
-func DeleteTask(ctx context.Context, args []string) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
-	return handler.deleteTask(ctx, args)
-}
-
-func (h *TaskHandler) deleteTask(ctx context.Context, args []string) error {
+// Delete deletes a task
+func (h *TaskHandler) Delete(ctx context.Context, args []string) error {
 	if len(args) < 1 {
 		return fmt.Errorf("task ID required")
 	}
···
 	return nil
 }
 
-// ViewTask displays a single task
-func ViewTask(ctx context.Context, args []string) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
-	return handler.viewTask(ctx, args)
-}
-
-func (h *TaskHandler) viewTask(ctx context.Context, args []string) error {
+// View displays a single task
+func (h *TaskHandler) View(ctx context.Context, args []string, format string, jsonOutput, noMetadata bool) error {
 	if len(args) < 1 {
 		return fmt.Errorf("task ID required")
 	}
···
 		return fmt.Errorf("failed to find task: %w", err)
 	}
 
-	h.printTaskDetail(task)
-	return nil
-}
+	if jsonOutput {
+		return h.printTaskJSON(task)
+	}
 
-// DoneTask marks a task as completed
-func DoneTask(ctx context.Context, args []string) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
+	if format == "brief" {
+		h.printTask(task)
+	} else {
+		h.printTaskDetail(task, noMetadata)
 	}
-	defer handler.Close()
-
-	return handler.doneTask(ctx, args)
+	return nil
 }
 
-func (h *TaskHandler) doneTask(ctx context.Context, args []string) error {
+// Done marks a task as completed
+func (h *TaskHandler) Done(ctx context.Context, args []string) error {
 	if len(args) < 1 {
 		return fmt.Errorf("task ID required")
 	}
···
 }
 
 // ListProjects lists all projects with their task counts
-func ListProjects(ctx context.Context, static bool) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
+func (h *TaskHandler) ListProjects(ctx context.Context, static bool) error {
 	if static {
-		return handler.listProjectsStatic(ctx)
+		return h.listProjectsStatic(ctx)
 	}
 
-	return handler.listProjectsInteractive(ctx)
+	return h.listProjectsInteractive(ctx)
 }
 
 func (h *TaskHandler) listProjectsStatic(ctx context.Context) error {
···
 }
 
 // ListTags lists all tags with their task counts
-func ListTags(ctx context.Context, static bool) error {
-	handler, err := NewTaskHandler()
-	if err != nil {
-		return fmt.Errorf("failed to initialize task handler: %w", err)
-	}
-	defer handler.Close()
-
+func (h *TaskHandler) ListTags(ctx context.Context, static bool) error {
 	if static {
-		return handler.listTagsStatic(ctx)
+		return h.listTagsStatic(ctx)
 	}
 
-	return handler.listTagsInteractive(ctx)
+	return h.listTagsInteractive(ctx)
 }
 
 func (h *TaskHandler) listTagsStatic(ctx context.Context) error {
···
 	fmt.Println()
 }
 
-func (h *TaskHandler) printTaskDetail(task *models.Task) {
+func (h *TaskHandler) printTaskDetail(task *models.Task, noMetadata bool) {
 	fmt.Printf("Task ID: %d\n", task.ID)
 	fmt.Printf("UUID: %s\n", task.UUID)
 	fmt.Printf("Description: %s\n", task.Description)
···
 		fmt.Printf("Due: %s\n", task.Due.Format("2006-01-02 15:04"))
 	}
 
-	fmt.Printf("Created: %s\n", task.Entry.Format("2006-01-02 15:04"))
-	fmt.Printf("Modified: %s\n", task.Modified.Format("2006-01-02 15:04"))
+	if !noMetadata {
+		fmt.Printf("Created: %s\n", task.Entry.Format("2006-01-02 15:04"))
+		fmt.Printf("Modified: %s\n", task.Modified.Format("2006-01-02 15:04"))
 
-	if task.Start != nil {
-		fmt.Printf("Started: %s\n", task.Start.Format("2006-01-02 15:04"))
-	}
+		if task.Start != nil {
+			fmt.Printf("Started: %s\n", task.Start.Format("2006-01-02 15:04"))
+		}
 
-	if task.End != nil {
-		fmt.Printf("Completed: %s\n", task.End.Format("2006-01-02 15:04"))
+		if task.End != nil {
+			fmt.Printf("Completed: %s\n", task.End.Format("2006-01-02 15:04"))
+		}
 	}
 
 	if len(task.Annotations) > 0 {
···
 	}
 }
 
+func (h *TaskHandler) printTaskJSON(task *models.Task) error {
+	jsonData, err := json.MarshalIndent(task, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal task to JSON: %w", err)
+	}
+	fmt.Println(string(jsonData))
+	return nil
+}
+
 func removeString(slice []string, item string) []string {
 	var result []string
 	for _, s := range slice {
···
 }
 
 func pluralize(count int) string {
-	if count == 1 {
+	rule := plural.Cardinal.MatchPlural(language.English, count, 0, 0, 0, 0)
+	switch rule {
+	case plural.One:
 		return ""
+	default:
+		return "s"
 	}
-	return "s"
 }

internal/handlers/tasks_test.go

···
 		_, cleanup := setupTaskTest(t)
 		defer cleanup()
 
+		handler, err := NewTaskHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+		defer handler.Close()
+
 		t.Run("creates task successfully", func(t *testing.T) {
 			ctx := context.Background()
 			args := []string{"Buy groceries", "and", "cook dinner"}
 
-			err := CreateTask(ctx, args)
+			err := handler.Create(ctx, args, "", "", "", []string{})
 			if err != nil {
 				t.Errorf("CreateTask failed: %v", err)
 			}
 
-			handler, err := NewTaskHandler()
-			if err != nil {
-				t.Fatalf("Failed to create handler: %v", err)
-			}
-			defer handler.Close()
-
 			tasks, err := handler.repos.Tasks.GetPending(ctx)
 			if err != nil {
 				t.Fatalf("Failed to get pending tasks: %v", err)
···
 			ctx := context.Background()
 			args := []string{}
 
-			err := CreateTask(ctx, args)
+			err := handler.Create(ctx, args, "", "", "", []string{})
 			if err == nil {
 				t.Error("Expected error for empty description")
 			}
···
 				t.Errorf("Expected error about required description, got: %v", err)
 			}
 		})
+
+		t.Run("creates task with flags", func(t *testing.T) {
+			ctx := context.Background()
+			args := []string{"Task", "with", "flags"}
+			priority := "A"
+			project := "test-project" 
+			due := "2024-12-31"
+			tags := []string{"urgent", "work"}
+
+			err := handler.Create(ctx, args, priority, project, due, tags)
+			if err != nil {
+				t.Errorf("CreateTask with flags failed: %v", err)
+			}
+
+			tasks, err := handler.repos.Tasks.GetPending(ctx)
+			if err != nil {
+				t.Fatalf("Failed to get pending tasks: %v", err)
+			}
+
+			// Should have 2 tasks now (previous test created one)
+			if len(tasks) < 1 {
+				t.Errorf("Expected at least 1 task, got %d", len(tasks))
+			}
+
+			// Find the task we just created
+			var task *models.Task
+			for _, t := range tasks {
+				if t.Description == "Task with flags" {
+					task = t
+					break
+				}
+			}
+
+			if task == nil {
+				t.Fatal("Could not find created task")
+			}
+
+			if task.Priority != priority {
+				t.Errorf("Expected priority '%s', got '%s'", priority, task.Priority)
+			}
+
+			if task.Project != project {
+				t.Errorf("Expected project '%s', got '%s'", project, task.Project)
+			}
+
+			if task.Due == nil {
+				t.Error("Expected due date to be set")
+			} else if task.Due.Format("2006-01-02") != due {
+				t.Errorf("Expected due date '%s', got '%s'", due, task.Due.Format("2006-01-02"))
+			}
+
+			if len(task.Tags) != len(tags) {
+				t.Errorf("Expected %d tags, got %d", len(tags), len(task.Tags))
+			} else {
+				for i, tag := range tags {
+					if task.Tags[i] != tag {
+						t.Errorf("Expected tag '%s' at index %d, got '%s'", tag, i, task.Tags[i])
+					}
+				}
+			}
+		})
+
+		t.Run("fails with invalid due date format", func(t *testing.T) {
+			ctx := context.Background()
+			args := []string{"Task", "with", "invalid", "date"}
+			invalidDue := "invalid-date"
+
+			err := handler.Create(ctx, args, "", "", invalidDue, []string{})
+			if err == nil {
+				t.Error("Expected error for invalid due date format")
+			}
+
+			if !strings.Contains(err.Error(), "invalid due date format") {
+				t.Errorf("Expected error about invalid date format, got: %v", err)
+			}
+		})
 	})
 
 	t.Run("List", func(t *testing.T) {
···
 		}
 
 		t.Run("lists pending tasks by default (static mode)", func(t *testing.T) {
-			err := ListTasks(ctx, true, false, "", "", "")
+			err := handler.List(ctx, true, false, "", "", "")
 			if err != nil {
 				t.Errorf("ListTasks failed: %v", err)
 			}
 		})
 
 		t.Run("filters by status (static mode)", func(t *testing.T) {
-			err := ListTasks(ctx, true, false, "completed", "", "")
+			err := handler.List(ctx, true, false, "completed", "", "")
 			if err != nil {
 				t.Errorf("ListTasks with status filter failed: %v", err)
 			}
 		})
 
 		t.Run("filters by priority (static mode)", func(t *testing.T) {
-			err := ListTasks(ctx, true, false, "", "A", "")
+			err := handler.List(ctx, true, false, "", "A", "")
 			if err != nil {
 				t.Errorf("ListTasks with priority filter failed: %v", err)
 			}
 		})
 
 		t.Run("filters by project (static mode)", func(t *testing.T) {
-			err := ListTasks(ctx, true, false, "", "", "work")
+			err := handler.List(ctx, true, false, "", "", "work")
 			if err != nil {
 				t.Errorf("ListTasks with project filter failed: %v", err)
 			}
 		})
 
 		t.Run("show all tasks (static mode)", func(t *testing.T) {
-			err := ListTasks(ctx, true, true, "", "", "")
+			err := handler.List(ctx, true, true, "", "", "")
 			if err != nil {
 				t.Errorf("ListTasks with show all failed: %v", err)
 			}
···
 
 		ctx := context.Background()
 
-		// Create test task
 		handler, err := NewTaskHandler()
 		if err != nil {
 			t.Fatalf("Failed to create handler: %v", err)
···
 		t.Run("updates task by ID", func(t *testing.T) {
 			args := []string{strconv.FormatInt(id, 10), "--description", "Updated description"}
 
-			err := UpdateTask(ctx, args)
+			err := handler.Update(ctx, args)
 			if err != nil {
 				t.Errorf("UpdateTask failed: %v", err)
 			}
···
 		t.Run("updates task by UUID", func(t *testing.T) {
 			args := []string{task.UUID, "--status", "completed"}
 
-			err := UpdateTask(ctx, args)
+			err := handler.Update(ctx, args)
 			if err != nil {
 				t.Errorf("UpdateTask by UUID failed: %v", err)
 			}
···
 				"--due", "2024-12-31",
 			}
 
-			err := UpdateTask(ctx, args)
+			err := handler.Update(ctx, args)
 			if err != nil {
 				t.Errorf("UpdateTask with multiple fields failed: %v", err)
 			}
···
 				"--add-tag=urgent",
 			}
 
-			err := UpdateTask(ctx, args)
+			err := handler.Update(ctx, args)
 			if err != nil {
 				t.Errorf("UpdateTask with add tags failed: %v", err)
 			}
···
 				"--remove-tag=urgent",
 			}
 
-			err = UpdateTask(ctx, args)
+			err = handler.Update(ctx, args)
 			if err != nil {
 				t.Errorf("UpdateTask with remove tag failed: %v", err)
 			}
···
 		t.Run("fails with missing task ID", func(t *testing.T) {
 			args := []string{}
 
-			err := UpdateTask(ctx, args)
+			err := handler.Update(ctx, args)
 			if err == nil {
 				t.Error("Expected error for missing task ID")
 			}
···
 		t.Run("fails with invalid task ID", func(t *testing.T) {
 			args := []string{"99999", "--description", "test"}
 
-			err := UpdateTask(ctx, args)
+			err := handler.Update(ctx, args)
 			if err == nil {
 				t.Error("Expected error for invalid task ID")
 			}
···
 		t.Run("deletes task by ID", func(t *testing.T) {
 			args := []string{strconv.FormatInt(id, 10)}
 
-			err := DeleteTask(ctx, args)
+			err := handler.Delete(ctx, args)
 			if err != nil {
 				t.Errorf("DeleteTask failed: %v", err)
 			}
···
 
 			args := []string{task2.UUID}
 
-			err = DeleteTask(ctx, args)
+			err = handler.Delete(ctx, args)
 			if err != nil {
 				t.Errorf("DeleteTask by UUID failed: %v", err)
 			}
···
 		t.Run("fails with missing task ID", func(t *testing.T) {
 			args := []string{}
 
-			err := DeleteTask(ctx, args)
+			err := handler.Delete(ctx, args)
 			if err == nil {
 				t.Error("Expected error for missing task ID")
 			}
···
 		t.Run("fails with invalid task ID", func(t *testing.T) {
 			args := []string{"99999"}
 
-			err := DeleteTask(ctx, args)
+			err := handler.Delete(ctx, args)
 			if err == nil {
 				t.Error("Expected error for invalid task ID")
 			}
···
 		t.Run("views task by ID", func(t *testing.T) {
 			args := []string{strconv.FormatInt(id, 10)}
 
-			err := ViewTask(ctx, args)
+			err := handler.View(ctx, args, "detailed", false, false)
 			if err != nil {
 				t.Errorf("ViewTask failed: %v", err)
 			}
···
 		t.Run("views task by UUID", func(t *testing.T) {
 			args := []string{task.UUID}
 
-			err := ViewTask(ctx, args)
+			err := handler.View(ctx, args, "detailed", false, false)
 			if err != nil {
 				t.Errorf("ViewTask by UUID failed: %v", err)
 			}
···
 		t.Run("fails with missing task ID", func(t *testing.T) {
 			args := []string{}
 
-			err := ViewTask(ctx, args)
+			err := handler.View(ctx, args, "detailed", false, false)
 			if err == nil {
 				t.Error("Expected error for missing task ID")
 			}
···
 		t.Run("fails with invalid task ID", func(t *testing.T) {
 			args := []string{"99999"}
 
-			err := ViewTask(ctx, args)
+			err := handler.View(ctx, args, "detailed", false, false)
 			if err == nil {
 				t.Error("Expected error for invalid task ID")
 			}
···
 				t.Errorf("Expected error about task not found, got: %v", err)
 			}
 		})
+
+		t.Run("uses brief format", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10)}
+			err := handler.View(ctx, args, "brief", false, false)
+			if err != nil {
+				t.Errorf("ViewTask with brief format failed: %v", err)
+			}
+		})
+
+		t.Run("hides metadata", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10)}
+			err := handler.View(ctx, args, "detailed", false, true)
+			if err != nil {
+				t.Errorf("ViewTask with no-metadata failed: %v", err)
+			}
+		})
+
+		t.Run("outputs JSON", func(t *testing.T) {
+			args := []string{strconv.FormatInt(id, 10)}
+			err := handler.View(ctx, args, "detailed", true, false)
+			if err != nil {
+				t.Errorf("ViewTask with JSON output failed: %v", err)
+			}
+		})
 	})
 
 	t.Run("Done", func(t *testing.T) {
···
 		t.Run("marks task as done by ID", func(t *testing.T) {
 			args := []string{strconv.FormatInt(id, 10)}
 
-			err := DoneTask(ctx, args)
+			err := handler.Done(ctx, args)
 			if err != nil {
 				t.Errorf("DoneTask failed: %v", err)
 			}
···
 
 			args := []string{strconv.FormatInt(id2, 10)}
 
-			err = DoneTask(ctx, args)
+			err = handler.Done(ctx, args)
 			if err != nil {
 				t.Errorf("DoneTask on completed task failed: %v", err)
 			}
···
 
 			args := []string{task3.UUID}
 
-			err = DoneTask(ctx, args)
+			err = handler.Done(ctx, args)
 			if err != nil {
 				t.Errorf("DoneTask by UUID failed: %v", err)
 			}
···
 		t.Run("fails with missing task ID", func(t *testing.T) {
 			args := []string{}
 
-			err := DoneTask(ctx, args)
+			err := handler.Done(ctx, args)
 			if err == nil {
 				t.Error("Expected error for missing task ID")
 			}
···
 		t.Run("fails with invalid task ID", func(t *testing.T) {
 			args := []string{"99999"}
 
-			err := DoneTask(ctx, args)
+			err := handler.Done(ctx, args)
 			if err == nil {
 				t.Error("Expected error for invalid task ID")
 			}
···
 				}
 			}()
 
-			handler.printTaskDetail(task)
+			handler.printTaskDetail(task, false)
 		})
 	})
 
···
 		}
 
 		t.Run("lists projects successfully", func(t *testing.T) {
-			err := ListProjects(ctx, true)
+			err := handler.ListProjects(ctx, true)
 			if err != nil {
 				t.Errorf("ListProjects failed: %v", err)
 			}
···
 			_, cleanup2 := setupTaskTest(t)
 			defer cleanup2()
 
-			err := ListProjects(ctx, true)
+			err := handler.ListProjects(ctx, true)
 			if err != nil {
 				t.Errorf("ListProjects with no projects failed: %v", err)
 			}
···
 		}
 
 		t.Run("lists tags successfully", func(t *testing.T) {
-			err := ListTags(ctx, true)
+			err := handler.ListTags(ctx, true)
 			if err != nil {
 				t.Errorf("ListTags failed: %v", err)
 			}
···
 			_, cleanup2 := setupTaskTest(t)
 			defer cleanup2()
 
-			err := ListTags(ctx, true)
+			err := handler.ListTags(ctx, true)
 			if err != nil {
 				t.Errorf("ListTags with no tags failed: %v", err)
 			}