chore: remove dead code

cmd/commands.go

···
 	"github.com/stormlightlabs/noteleaf/internal/handlers"
 )
 
-func parseID(k string, args []string) (int64, error) {
-	id, err := strconv.ParseInt(args[0], 10, 64)
-	if err != nil {
-		return id, fmt.Errorf("invalid %v ID: %s", k, args[0])
-	}
-
-	return id, err
-}
-
 // CommandGroup represents a group of related CLI commands
 type CommandGroup interface {
 	Create() *cobra.Command
···
 
 Updates episode tracking and completion status. Can mark individual episodes
 or complete seasons/series depending on ID format.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.MarkWatched(cmd.Context(), args[0])
 		},
···
 Specify a percentage value between 0 and 100 to indicate how far you've
 progressed through the book. Automatically updates status to 'reading' if not
 already set.`,
-		Args:  cobra.ExactArgs(2),
+		Args: cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			progress, err := strconv.Atoi(args[1])
 			if err != nil {
···
 
 Valid statuses are: queued (not started), reading (in progress), finished
 (completed), or removed (no longer tracking).`,
-		Args:  cobra.ExactArgs(2),
+		Args: cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.UpdateStatus(cmd.Context(), args[0], args[1])
 		},
···
 	handler *handlers.NoteHandler
 }
 
-// NewNoteCommand creates a new NoteCommand with the given handler
+// NewNoteCommand creates a new [NoteCommand] with the given handler
 func NewNoteCommand(handler *handlers.NoteHandler) *NoteCommand {
 	return &NoteCommand{handler: handler}
 }
···
 
 Shows the note with syntax highlighting, proper formatting, and metadata.
 Useful for quick viewing without opening an editor.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if noteID, err := parseID("note", args); err != nil {
+			if noteID, err := handlers.ParseID(args[0], "note"); err != nil {
 				return err
 			} else {
 				defer c.handler.Close()
···
 Uses the editor specified in your noteleaf configuration or the EDITOR
 environment variable. Changes are automatically saved when you close the
 editor.`,
-		Args:  cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if noteID, err := parseID("note", args); err != nil {
+			if noteID, err := handlers.ParseID(args[0], "note"); err != nil {
 				return err
 			} else {
 				defer c.handler.Close()
···
 
 Removes both the markdown file and database metadata. This operation cannot be
 undone. You will be prompted for confirmation before deletion.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if noteID, err := parseID("note", args); err != nil {
+			if noteID, err := handlers.ParseID(args[0], "note"); err != nil {
 				return err
 			} else {
 				defer c.handler.Close()
···
 
 Shows article title, author, publication date, URL, and a brief content
 preview. Use 'read' command to view the full article content.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if articleID, err := parseID("article", args); err != nil {
+			if articleID, err := handlers.ParseID(args[0], "article"); err != nil {
 				return err
 			} else {
 				defer c.handler.Close()
···
 This displays the complete article content using syntax highlighting and proper formatting.`,
 		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if articleID, err := parseID("article", args); err != nil {
+			if articleID, err := handlers.ParseID(args[0], "article"); err != nil {
 				return err
 			} else {
 				defer c.handler.Close()
···
 
 Removes the article metadata from the database and deletes associated markdown
 and HTML files. This operation cannot be undone.`,
-		Args:    cobra.ExactArgs(1),
+		Args: cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if articleID, err := parseID("article", args); err != nil {
+			if articleID, err := handlers.ParseID(args[0], "article"); err != nil {
 				return err
 			} else {
 				defer c.handler.Close()

internal/handlers/handlers.go

···
 	"io"
 	"os"
 	"path/filepath"
+	"strconv"
 
 	"github.com/stormlightlabs/noteleaf/internal/store"
 	"github.com/stormlightlabs/noteleaf/internal/utils"
 )
+
+// ParseID converts a string ID to int64
+func ParseID(id string, itemType string) (int64, error) {
+	itemID, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("invalid %s ID: %s", itemType, id)
+	}
+	return itemID, nil
+}
 
 // Setup initializes the application database and configuration
 func Setup(ctx context.Context, args []string) error {

internal/handlers/media_utilities.go

···
-package handlers
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strconv"
-
-	"github.com/stormlightlabs/noteleaf/internal/models"
-)
-
-// MediaPrinter defines how to format a media item for display
-type MediaPrinter[T any] func(item *T)
-
-// ListMediaItems is a generic utility for listing media items with status filtering
-func ListMediaItems[T any](
-	ctx context.Context,
-	status string,
-	mediaType string,
-	listAll func(ctx context.Context) ([]*T, error),
-	listByStatus func(ctx context.Context, status string) ([]*T, error),
-	printer MediaPrinter[T],
-) error {
-	var items []*T
-	var err error
-
-	if status == "" {
-		items, err = listAll(ctx)
-		if err != nil {
-			return fmt.Errorf("failed to list %s: %w", mediaType, err)
-		}
-	} else {
-		items, err = listByStatus(ctx, status)
-		if err != nil {
-			return fmt.Errorf("failed to get %s %s: %w", status, mediaType, err)
-		}
-	}
-
-	if len(items) == 0 {
-		if status == "" {
-			fmt.Printf("No %s found\n", mediaType)
-		} else {
-			fmt.Printf("No %s %s found\n", status, mediaType)
-		}
-		return nil
-	}
-
-	fmt.Printf("Found %d %s:\n\n", len(items), mediaType)
-	for _, item := range items {
-		printer(item)
-	}
-
-	return nil
-}
-
-// PromptUserChoice prompts the user to select from a list of results
-func PromptUserChoice(reader io.Reader, maxChoices int) (int, error) {
-	fmt.Print("\nEnter number to add (1-", maxChoices, "), or 0 to cancel: ")
-
-	var choice int
-	if reader != nil {
-		if _, err := fmt.Fscanf(reader, "%d", &choice); err != nil {
-			return 0, fmt.Errorf("invalid input")
-		}
-	} else {
-		if _, err := fmt.Scanf("%d", &choice); err != nil {
-			return 0, fmt.Errorf("invalid input")
-		}
-	}
-
-	if choice == 0 {
-		fmt.Println("Cancelled.")
-		return 0, nil
-	}
-	if choice < 1 || choice > maxChoices {
-		return 0, fmt.Errorf("invalid choice: %d", choice)
-	}
-	return choice, nil
-}
-
-// ParseID converts a string ID to int64
-func ParseID(id string, itemType string) (int64, error) {
-	itemID, err := strconv.ParseInt(id, 10, 64)
-	if err != nil {
-		return 0, fmt.Errorf("invalid %s ID: %s", itemType, id)
-	}
-	return itemID, nil
-}
-
-// PrintSearchResults displays search results with a type-specific formatter
-func PrintSearchResults[T models.Model](results []*models.Model, formatter func(*models.Model, int)) error {
-	if len(results) == 0 {
-		fmt.Println("No results found.")
-		return nil
-	}
-
-	fmt.Printf("Found %d result(s):\n\n", len(results))
-	for i, result := range results {
-		formatter(result, i+1)
-	}
-	return nil
-}