feat: docgen

README.md

···
 
 # Add a book to your reading list
 noteleaf media book add "The Name of the Wind"
+
+# Generate docs
+noteleaf docgen --format docusaurus --out ./website/docs/manual
 ```
 
 ## Status

ROADMAP.md

···
 - [ ] Encryption support
 - [ ] Advanced classification
 
+### Local API Server
+
+A local HTTP server daemon that exposes Noteleaf data for web UIs and extensions. Runs on the user's machine and provides programmatic access to tasks, notes, and media.
+
+#### Architecture
+
+- [ ] Daemon mode via `noteleaf server start/stop/status`
+- [ ] Binds to localhost by default (configurable port)
+- [ ] HTTP/REST API using existing repository layer
+- [ ] Shares same SQLite database as CLI
+- [ ] Middleware: logging, CORS (for localhost web UIs), compression
+- [ ] Health and status endpoints
+
+#### Daemon Management
+
+- [ ] Commands: `start`, `stop`, `restart`, `status`
+- [ ] PID file tracking for process management
+- [ ] Systemd service file for Linux
+- [ ] launchd plist for macOS
+- [ ] Graceful shutdown with active request draining
+- [ ] Auto-restart on crash option
+- [ ] Configurable bind address and port
+- [ ] Log file rotation
+
+#### API Endpoints
+
+RESTful design matching CLI command structure:
+
+- [ ] `GET /api/v1/tasks` - List tasks with filters
+- [ ] `POST /api/v1/tasks` - Create task
+- [ ] `GET /api/v1/tasks/:id` - Get task details
+- [ ] `PUT /api/v1/tasks/:id` - Update task
+- [ ] `DELETE /api/v1/tasks/:id` - Delete task
+- [ ] `POST /api/v1/tasks/:id/start` - Start time tracking
+- [ ] `POST /api/v1/tasks/:id/stop` - Stop time tracking
+- [ ] `GET /api/v1/tasks/:id/time-entries` - Get time entries
+- [ ] Similar CRUD endpoints for notes, books, movies, TV shows, articles
+- [ ] `GET /api/v1/projects` - List all projects
+- [ ] `GET /api/v1/tags` - List all tags
+- [ ] `GET /api/v1/contexts` - List all contexts
+- [ ] `GET /api/v1/stats` - Dashboard statistics
+
+#### Real-time Updates
+
+- [ ] WebSocket endpoint for live data updates
+- [ ] Server-Sent Events (SSE) as fallback
+- [ ] Event types: task created/updated/deleted, note modified, etc.
+- [ ] Subscribe to specific domains or IDs
+- [ ] Change notification for web UI reactivity
+
+#### Authentication & Security
+
+- [ ] Optional API token authentication (disabled by default for localhost)
+- [ ] Token stored in config file
+- [ ] Token rotation command
+- [ ] CORS configuration for allowed origins
+- [ ] Localhost-only binding by default (security through network isolation)
+- [ ] Optional TLS for local network access
+
+#### Extension System
+
+- [ ] Webhook endpoints for extension registration
+- [ ] Event hooks for task/note lifecycle:
+    - [ ] Before/after create, update, delete
+    - [ ] Task completion, start, stop
+    - [ ] Note archive/unarchive
+- [ ] Webhook delivery with retries
+- [ ] Extension manifest for discovery
+- [ ] JavaScript plugin API (embedded V8/goja runtime)
+- [ ] Plugin sandbox for security
+
+#### Web UI
+
+- [ ] Reference web UI implementation
+- [ ] Static file serving from embedded assets
+- [ ] Single-page application architecture
+- [ ] Responsive design (desktop, tablet, mobile)
+- [ ] Features:
+    - [ ] Task board view (Kanban)
+    - [ ] Calendar view for tasks
+    - [ ] Note editor with Markdown preview
+    - [ ] Media queue management
+    - [ ] Search and filtering
+    - [ ] Keyboard shortcuts matching CLI
+
+#### Configuration
+
+- [ ] Server config section in noteleaf.toml:
+    - [ ] bind_address (default: 127.0.0.1)
+    - [ ] port (default: 8080)
+    - [ ] enable_auth (default: false)
+    - [ ] api_token (optional)
+    - [ ] enable_websocket (default: true)
+    - [ ] log_level (default: info)
+- [ ] Environment variable overrides
+- [ ] CLI flag overrides for daemon commands
+
+#### Monitoring & Diagnostics
+
+- [ ] `GET /health` - Health check endpoint
+- [ ] `GET /metrics` - Prometheus-compatible metrics
+- [ ] Request logging (access log)
+- [ ] Error logging with stack traces
+- [ ] Performance metrics (request duration, DB query time)
+- [ ] Active connections and goroutine count
+- [ ] Memory and CPU usage stats
+
+#### Client Libraries
+
+- [ ] Go client library for extensions
+- [ ] JavaScript/TypeScript client for web UIs
+- [ ] OpenAPI/Swagger specification
+- [ ] Auto-generated API documentation
+
 ## Technical Infrastructure
 
 ### Completed

cmd/commands.go

···
 }
 
 func (c *MovieCommand) Create() *cobra.Command {
-	root := &cobra.Command{Use: "movie", Short: "Manage movie watch queue"}
+	root := &cobra.Command{
+		Use:   "movie",
+		Short: "Manage movie watch queue",
+		Long: `Track movies you want to watch.
+
+Search TMDB for movies and add them to your queue. Mark movies as watched when
+completed. Maintains a history of your movie watching activity.`,
+	}
 
 	addCmd := &cobra.Command{
 		Use:   "add [search query...]",
···
 	root.AddCommand(&cobra.Command{
 		Use:   "list [--all|--watched|--queued]",
 		Short: "List movies in queue with status filtering",
+		Long: `Display movies in your queue with optional status filters.
+
+Shows movie titles, release years, and current status. Filter by --all to show
+everything, --watched for completed movies, or --queued for unwatched items.
+Default shows queued movies only.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			var status string
 			if len(args) > 0 {
···
 		Use:     "watched [id]",
 		Short:   "Mark movie as watched",
 		Aliases: []string{"seen"},
+		Long:    "Mark a movie as watched with current timestamp. Moves the movie from queued to watched status.",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.MarkWatched(cmd.Context(), args[0])
···
 		Use:     "remove [id]",
 		Short:   "Remove movie from queue",
 		Aliases: []string{"rm"},
+		Long:    "Remove a movie from your watch queue. Use this for movies you no longer want to track.",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.Remove(cmd.Context(), args[0])
···
 }
 
 func (c *TVCommand) Create() *cobra.Command {
-	root := &cobra.Command{Use: "tv", Short: "Manage TV show watch queue"}
+	root := &cobra.Command{
+		Use:   "tv",
+		Short: "Manage TV show watch queue",
+		Long: `Track TV shows and episodes.
+
+Search TMDB for TV shows and add them to your queue. Track which shows you're
+currently watching, mark episodes as watched, and maintain a complete history
+of your viewing activity.`,
+	}
 
 	addCmd := &cobra.Command{
 		Use:   "add [search query...]",
···
 	root.AddCommand(&cobra.Command{
 		Use:   "list [--all|--queued|--watching|--watched]",
 		Short: "List TV shows in queue with status filtering",
+		Long: `Display TV shows in your queue with optional status filters.
+
+Shows show titles, air dates, and current status. Filter by --all, --queued,
+--watching for shows in progress, or --watched for completed series. Default
+shows queued shows only.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			var status string
 			if len(args) > 0 {
···
 	root.AddCommand(&cobra.Command{
 		Use:   "watching [id]",
 		Short: "Mark TV show as currently watching",
+		Long:  "Mark a TV show as currently watching. Use this when you start watching a series.",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.MarkTVShowWatching(cmd.Context(), args[0])
···
 		Use:     "watched [id]",
 		Short:   "Mark TV show/episodes as watched",
 		Aliases: []string{"seen"},
+		Long: `Mark TV show episodes or entire series as watched.
+
+Updates episode tracking and completion status. Can mark individual episodes
+or complete seasons/series depending on ID format.`,
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.MarkWatched(cmd.Context(), args[0])
···
 		Use:     "remove [id]",
 		Short:   "Remove TV show from queue",
 		Aliases: []string{"rm"},
+		Long:    "Remove a TV show from your watch queue. Use this for shows you no longer want to track.",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.Remove(cmd.Context(), args[0])
···
 }
 
 func (c *BookCommand) Create() *cobra.Command {
-	root := &cobra.Command{Use: "book", Short: "Manage reading list"}
+	root := &cobra.Command{
+		Use:   "book",
+		Short: "Manage reading list",
+		Long: `Track books and reading progress.
+
+Search Google Books API to add books to your reading list. Track which books
+you're reading, update progress percentages, and maintain a history of finished
+books.`,
+	}
 
 	addCmd := &cobra.Command{
 		Use:   "add [search query...]",
···
 	root.AddCommand(&cobra.Command{
 		Use:   "list [--all|--reading|--finished|--queued]",
 		Short: "Show reading queue with progress",
+		Long: `Display books in your reading list with progress indicators.
+
+Shows book titles, authors, and reading progress percentages. Filter by --all,
+--reading for books in progress, --finished for completed books, or --queued
+for books not yet started. Default shows queued books only.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			var status string
 			if len(args) > 0 {
···
 	root.AddCommand(&cobra.Command{
 		Use:   "reading <id>",
 		Short: "Mark book as currently reading",
+		Long:  "Mark a book as currently reading. Use this when you start a book from your queue.",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.UpdateStatus(cmd.Context(), args[0], "reading")
···
 		Use:     "finished <id>",
 		Short:   "Mark book as completed",
 		Aliases: []string{"read"},
+		Long:    "Mark a book as finished with current timestamp. Sets reading progress to 100%.",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.UpdateStatus(cmd.Context(), args[0], "finished")
···
 		Use:     "remove <id>",
 		Short:   "Remove from reading list",
 		Aliases: []string{"rm"},
+		Long:    "Remove a book from your reading list. Use this for books you no longer want to track.",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.UpdateStatus(cmd.Context(), args[0], "removed")
···
 	root.AddCommand(&cobra.Command{
 		Use:   "progress <id> <percentage>",
 		Short: "Update reading progress percentage (0-100)",
+		Long: `Set reading progress for a book.
+
+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),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			progress, err := strconv.Atoi(args[1])
···
 	root.AddCommand(&cobra.Command{
 		Use:   "update <id> <status>",
 		Short: "Update book status (queued|reading|finished|removed)",
+		Long: `Change a book's status directly.
+
+Valid statuses are: queued (not started), reading (in progress), finished
+(completed), or removed (no longer tracking).`,
 		Args:  cobra.ExactArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return c.handler.UpdateStatus(cmd.Context(), args[0], args[1])
···
 }
 
 func (c *NoteCommand) Create() *cobra.Command {
-	root := &cobra.Command{Use: "note", Short: "Manage notes"}
+	root := &cobra.Command{
+		Use:   "note",
+		Short: "Manage notes",
+		Long: `Create and organize markdown notes with tags.
+
+Write notes in markdown format, organize them with tags, browse them in an
+interactive TUI, and edit them in your preferred editor. Notes are stored as
+files on disk with metadata tracked in the database.`,
+	}
 
 	createCmd := &cobra.Command{
 		Use:     "create [title] [content...]",
 		Short:   "Create a new note",
 		Aliases: []string{"new"},
+		Long: `Create a new markdown note.
+
+Provide a title and optional content inline, or use --interactive to open an
+editor. Use --file to import content from an existing markdown file. Notes
+support tags for organization and full-text search.
+
+Examples:
+  noteleaf note create "Meeting notes" "Discussed project timeline"
+  noteleaf note create -i
+  noteleaf note create --file ~/documents/draft.md`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			interactive, _ := cmd.Flags().GetBool("interactive")
 			editor, _ := cmd.Flags().GetBool("editor")
···
 		Use:     "read [note-id]",
 		Short:   "Display formatted note content with syntax highlighting",
 		Aliases: []string{"view"},
+		Long: `Display note content with formatted markdown rendering.
+
+Shows the note with syntax highlighting, proper formatting, and metadata.
+Useful for quick viewing without opening an editor.`,
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if noteID, err := parseID("note", args); err != nil {
···
 	root.AddCommand(&cobra.Command{
 		Use:   "edit [note-id]",
 		Short: "Edit note in configured editor",
+		Long: `Open note in your configured text editor.
+
+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),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if noteID, err := parseID("note", args); err != nil {
···
 		Use:     "remove [note-id]",
 		Short:   "Permanently removes the note file and metadata",
 		Aliases: []string{"rm", "delete", "del"},
+		Long: `Delete a note permanently.
+
+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),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if noteID, err := parseID("note", args); err != nil {
···
 }
 
 func (c *ArticleCommand) Create() *cobra.Command {
-	root := &cobra.Command{Use: "article", Short: "Manage saved articles"}
+	root := &cobra.Command{
+		Use:   "article",
+		Short: "Manage saved articles",
+		Long: `Save and archive web articles locally.
+
+Parse articles from supported websites, extract clean content, and save as
+both markdown and HTML. Maintains a searchable archive of articles with
+metadata including author, title, and publication date.`,
+	}
 
 	addCmd := &cobra.Command{
 		Use:   "add <url>",
···
 		Use:     "view <id>",
 		Short:   "View article details and content preview",
 		Aliases: []string{"show"},
+		Long: `Display article metadata and summary.
+
+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),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if articleID, err := parseID("article", args); err != nil {
···
 		Use:     "remove <id>",
 		Short:   "Remove article and associated files",
 		Aliases: []string{"rm", "delete"},
+		Long: `Delete an article and its files permanently.
+
+Removes the article metadata from the database and deletes associated markdown
+and HTML files. This operation cannot be undone.`,
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if articleID, err := parseID("article", args); err != nil {

cmd/main.go

···
 	"github.com/stormlightlabs/noteleaf/internal/store"
 	"github.com/stormlightlabs/noteleaf/internal/ui"
 	"github.com/stormlightlabs/noteleaf/internal/utils"
+	"github.com/stormlightlabs/noteleaf/tools"
 )
 
 var (
···
 	return &cobra.Command{
 		Use:   "status",
 		Short: "Show application status and configuration",
+		Long: `Display comprehensive application status information.
+
+Shows database location, configuration file path, data directories, and current
+settings. Use this command to verify your noteleaf installation and diagnose
+configuration issues.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return handlers.Status(cmd.Context(), args, cmd.OutOrStdout())
 		},
···
 	return &cobra.Command{
 		Use:   "reset",
 		Short: "Reset the application (removes all data)",
+		Long: `Remove all application data and return to initial state.
+
+This command deletes the database, all media files, notes, and articles. The
+configuration file is preserved. Use with caution as this operation cannot be
+undone. You will be prompted for confirmation before deletion proceeds.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return handlers.Reset(cmd.Context(), args)
 		},
···
 func rootCmd() *cobra.Command {
 	root := &cobra.Command{
 		Use:   "noteleaf",
-		Long:  ui.Georgia.ColoredInViewport(),
 		Short: "A TaskWarrior-inspired CLI with notes, media queues and reading lists",
+		Long: `noteleaf - personal information manager for the command line
+
+A comprehensive CLI tool for managing tasks, notes, articles, and media queues.
+Inspired by TaskWarrior, noteleaf combines todo management with reading lists,
+watch queues, and a personal knowledge base.
+
+Core features include hierarchical tasks with dependencies, recurring tasks,
+time tracking, markdown notes with tags, article archiving, and media queue
+management for books, movies, and TV shows.`,
 		RunE: func(c *cobra.Command, args []string) error {
 			if len(args) == 0 {
 				return c.Help()
···
 	root := &cobra.Command{
 		Use:   "setup",
 		Short: "Initialize and manage application setup",
+		Long: `Initialize noteleaf for first use.
+
+Creates the database, configuration file, and required data directories. Run
+this command after installing noteleaf or when setting up a new environment.
+Safe to run multiple times as it will skip existing resources.`,
 		RunE: func(c *cobra.Command, args []string) error {
 			return handlers.Setup(c.Context(), args)
 		},
···
 		root.AddCommand(cmd)
 	}
 
-	mediaCmd := &cobra.Command{Use: "media", Short: "Manage media queues (books, movies, TV shows)"}
+	mediaCmd := &cobra.Command{
+		Use:   "media",
+		Short: "Manage media queues (books, movies, TV shows)",
+		Long: `Track and manage reading lists and watch queues.
+
+Organize books, movies, and TV shows you want to consume. Search external
+databases to add items, track reading/watching progress, and maintain a
+history of completed media.`,
+	}
 	mediaCmd.GroupID = "core"
 	mediaCmd.AddCommand(NewMovieCommand(movieHandler).Create())
 	mediaCmd.AddCommand(NewTVCommand(tvHandler).Create())
···
 		cmd.GroupID = "management"
 		root.AddCommand(cmd)
 	}
+
+	root.AddCommand(tools.NewDocGenCommand(root))
 
 	opts := []fang.Option{
 		fang.WithVersion("0.1.0"),

cmd/task_commands.go

···
 }
 
 func (c *TaskCommand) Create() *cobra.Command {
-	root := &cobra.Command{Use: "todo", Aliases: []string{"task"}, Short: "task management"}
+	root := &cobra.Command{
+		Use:     "todo",
+		Aliases: []string{"task"},
+		Short:   "task management",
+		Long: `Manage tasks with TaskWarrior-inspired features.
+
+Track todos with priorities, projects, contexts, and tags. Supports hierarchical
+tasks with parent/child relationships, task dependencies, recurring tasks, and
+time tracking. Tasks can be filtered by status, priority, project, or context.`,
+	}
 
 	for _, init := range []func(*handlers.TaskHandler) *cobra.Command{
 		addTaskCmd, listTaskCmd, viewTaskCmd, updateTaskCmd, editTaskCmd,
···
 		Use:     "add [description]",
 		Short:   "Add a new task",
 		Aliases: []string{"create", "new"},
+		Long: `Create a new task with description and optional attributes.
+
+Tasks can be created with priority levels (low, medium, high, urgent), assigned
+to projects and contexts, tagged for organization, and configured with due dates
+and recurrence rules. Dependencies can be established to ensure tasks are
+completed in order.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			description := strings.Join(args, " ")
···
 	viewCmd := &cobra.Command{
 		Use:   "view [task-id]",
 		Short: "View task by ID",
+		Long: `Display detailed information for a specific task.
+
+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),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			format, _ := cmd.Flags().GetString("format")
···
 	updateCmd := &cobra.Command{
 		Use:   "update [task-id]",
 		Short: "Update task properties",
+		Long: `Modify attributes of an existing task.
+
+Update any task property including description, status, priority, project,
+context, due date, recurrence rule, or parent task. Add or remove tags and
+dependencies. Multiple attributes can be updated in a single command.
+
+Examples:
+  noteleaf todo update 123 --priority urgent --due tomorrow
+  noteleaf todo update 456 --add-tag urgent --project website`,
 		Args:  cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			taskID := args[0]
···
 		Use:     "projects",
 		Short:   "List projects",
 		Aliases: []string{"proj"},
+		Long: `Display all projects with task counts.
+
+Shows each project used in your tasks along with the number of tasks in each
+project. Use --todo-txt to format output with +project syntax for compatibility
+with todo.txt tools.`,
 		RunE: func(c *cobra.Command, args []string) error {
 			static, _ := c.Flags().GetBool("static")
 			todoTxt, _ := c.Flags().GetBool("todo-txt")
···
 		Use:     "tags",
 		Short:   "List tags",
 		Aliases: []string{"t"},
+		Long: `Display all tags used across tasks.
+
+Shows each tag with the number of tasks using it. Tags provide flexible
+categorization orthogonal to projects and contexts.`,
 		RunE: func(c *cobra.Command, args []string) error {
 			static, _ := c.Flags().GetBool("static")
 			defer h.Close()
···
 	cmd := &cobra.Command{
 		Use:   "start [task-id]",
 		Short: "Start time tracking for a task",
+		Long: `Begin tracking time spent on a task.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			taskID := args[0]
···
 	return &cobra.Command{
 		Use:   "stop [task-id]",
 		Short: "Stop time tracking for a task",
+		Long: `End time tracking for the active task.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			taskID := args[0]
···
 		Use:     "edit [task-id]",
 		Short:   "Edit task interactively with status picker and priority toggle",
 		Aliases: []string{"e"},
+		Long: `Open interactive editor for task modification.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			taskID := args[0]
···
 	return &cobra.Command{
 		Use:   "delete [task-id]",
 		Short: "Delete a task",
+		Long: `Permanently remove a task from the database.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 		Use:     "contexts",
 		Short:   "List contexts (locations)",
 		Aliases: []string{"con", "loc", "ctx", "locations"},
+		Long: `Display all contexts with task counts.
+
+Contexts represent locations or environments where tasks can be completed (e.g.,
+@home, @office, @errands). Use --todo-txt to format output with @context syntax
+for compatibility with todo.txt tools.`,
 		RunE: func(c *cobra.Command, args []string) error {
 			static, _ := c.Flags().GetBool("static")
 			todoTxt, _ := c.Flags().GetBool("todo-txt")
···
 		Use:     "done [task-id]",
 		Short:   "Mark task as completed",
 		Aliases: []string{"complete"},
+		Long: `Mark a task as completed with current timestamp.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 		Use:     "recur",
 		Short:   "Manage task recurrence",
 		Aliases: []string{"repeat"},
+		Long: `Configure recurring task patterns.
+
+Create tasks that repeat on a schedule using iCalendar recurrence rules (RRULE).
+Supports daily, weekly, monthly, and yearly patterns with optional end dates.`,
 	}
 
 	setCmd := &cobra.Command{
 		Use:   "set [task-id]",
 		Short: "Set recurrence rule for a task",
+		Long: `Apply a recurrence rule to create repeating task instances.
+
+Uses iCalendar RRULE syntax (e.g., "FREQ=DAILY" for daily tasks, "FREQ=WEEKLY;BYDAY=MO,WE,FR"
+for specific weekdays). When a recurring task is completed, the next instance is
+automatically generated.
+
+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),
 		RunE: func(c *cobra.Command, args []string) error {
 			rule, _ := c.Flags().GetString("rule")
···
 	clearCmd := &cobra.Command{
 		Use:   "clear [task-id]",
 		Short: "Clear recurrence rule from a task",
+		Long: `Remove recurrence from a task.
+
+Converts a recurring task to a one-time task. Existing future instances are not
+affected.`,
 		Args:  cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 	showCmd := &cobra.Command{
 		Use:   "show [task-id]",
 		Short: "Show recurrence details for a task",
+		Long: `Display recurrence rule and schedule information.
+
+Shows the RRULE pattern, next occurrence date, and recurrence end date if
+configured.`,
 		Args:  cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 		Use:     "depend",
 		Short:   "Manage task dependencies",
 		Aliases: []string{"dep", "deps"},
+		Long: `Create and manage task dependencies.
+
+Establish relationships where one task must be completed before another can
+begin. Useful for multi-step workflows and project management.`,
 	}
 
 	addCmd := &cobra.Command{
 		Use:   "add [task-id] [depends-on-uuid]",
 		Short: "Add a dependency to a task",
+		Long: `Make a task dependent on another task's completion.
+
+The first task cannot be started until the second task is completed. Use task
+UUIDs to specify dependencies.`,
 		Args:  cobra.ExactArgs(2),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 		Use:     "remove [task-id] [depends-on-uuid]",
 		Short:   "Remove a dependency from a task",
 		Aliases: []string{"rm"},
+		Long:    "Delete a dependency relationship between two tasks.",
 		Args:    cobra.ExactArgs(2),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 		Use:     "list [task-id]",
 		Short:   "List dependencies for a task",
 		Aliases: []string{"ls"},
+		Long:    "Show all tasks that must be completed before this task can be started.",
 		Args:    cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()
···
 	blockedByCmd := &cobra.Command{
 		Use:   "blocked-by [task-id]",
 		Short: "Show tasks blocked by this task",
+		Long:  "Display all tasks that depend on this task's completion.",
 		Args:  cobra.ExactArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			defer h.Close()

codecov.yml

···
   - "**/vendor/**"
   - "internal/**/test_utilities.go"
   - "internal/handlers/handler_test_suite.go"
+  - "internal/tools/docgen.go"

go.mod

···
 )
 
 require (
+	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+require (
 	github.com/PuerkitoBio/goquery v1.10.3
 	github.com/andybalholm/cascadia v1.3.3 // indirect
 	github.com/antchfx/htmlquery v1.3.4

go.sum

···
 github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf/go.mod h1:B3UgsnsBZS/eX42BlaNiJkD1pPOUa+oF1IYC6Yd2CEU=
 github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
 github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/cpuguy83/go-md2man/v2 v2.0.6 h1:XJtiaUW6dEEqVuZiMTn1ldk455QWwEIsMIJlo5vtkx0=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
···
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d h1:hrujxIzL1woJ7AwssoOcM/tq5JjjG2yYOc8odClEiXA=
 github.com/saintfish/chardet v0.0.0-20230101081208-5e3ef4b5456d/go.mod h1:uugorj2VCxiV1x+LzaIdVa9b4S4qGAcH6cbhh4qVxOU=
···
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
 google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

tools/docgen.go

···
+package tools
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
+)
+
+// NewDocGenCommand creates a hidden command for generating CLI documentation
+func NewDocGenCommand(root *cobra.Command) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:    "docgen",
+		Short:  "Generate CLI documentation",
+		Hidden: true,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			out, _ := cmd.Flags().GetString("out")
+			format, _ := cmd.Flags().GetString("format")
+			front, _ := cmd.Flags().GetBool("frontmatter")
+
+			if err := os.MkdirAll(out, 0o755); err != nil {
+				return fmt.Errorf("failed to create output directory: %w", err)
+			}
+
+			root.DisableAutoGenTag = true
+
+			switch format {
+			case "docusaurus":
+				if err := generateDocusaurusDocs(root, out); err != nil {
+					return fmt.Errorf("failed to generate docusaurus documentation: %w", err)
+				}
+			case "markdown":
+				if front {
+					prep := func(filename string) string {
+						base := filepath.Base(filename)
+						name := strings.TrimSuffix(base, filepath.Ext(base))
+						title := strings.ReplaceAll(name, "_", " ")
+						return fmt.Sprintf("---\ntitle: %q\nslug: %q\ndescription: \"CLI reference for %s\"\n---\n\n", title, name, title)
+					}
+					link := func(name string) string { return strings.ToLower(name) }
+					if err := doc.GenMarkdownTreeCustom(root, out, prep, link); err != nil {
+						return fmt.Errorf("failed to generate markdown documentation: %w", err)
+					}
+				} else {
+					if err := doc.GenMarkdownTree(root, out); err != nil {
+						return fmt.Errorf("failed to generate markdown documentation: %w", err)
+					}
+				}
+			case "man":
+				hdr := &doc.GenManHeader{Title: strings.ToUpper(root.Name()), Section: "1"}
+				if err := doc.GenManTree(root, hdr, out); err != nil {
+					return fmt.Errorf("failed to generate man pages: %w", err)
+				}
+			case "rest":
+				if err := doc.GenReSTTree(root, out); err != nil {
+					return fmt.Errorf("failed to generate ReStructuredText documentation: %w", err)
+				}
+			default:
+				return fmt.Errorf("unknown format: %s", format)
+			}
+
+			fmt.Fprintf(cmd.OutOrStdout(), "Documentation generated in %s\n", out)
+			return nil
+		},
+	}
+
+	cmd.Flags().StringP("out", "o", "./docs/cli", "output directory")
+	cmd.Flags().StringP("format", "f", "markdown", "output format (docusaurus|markdown|man|rest)")
+	cmd.Flags().Bool("frontmatter", false, "prepend simple YAML front matter to markdown")
+
+	return cmd
+}
+
+// CategoryJSON represents the _category_.json structure for Docusaurus
+type CategoryJSON struct {
+	Label       string `json:"label"`
+	Position    int    `json:"position"`
+	Link        *Link  `json:"link,omitempty"`
+	Collapsed   bool   `json:"collapsed,omitempty"`
+	Description string `json:"description,omitempty"`
+}
+
+// Link represents a link in _category_.json
+type Link struct {
+	Type        string `json:"type"`
+	Description string `json:"description,omitempty"`
+}
+
+// generateDocusaurusDocs creates combined, Docusaurus-compatible documentation
+func generateDocusaurusDocs(root *cobra.Command, outDir string) error {
+	if err := os.MkdirAll(outDir, 0o755); err != nil {
+		return fmt.Errorf("failed to create output directory: %w", err)
+	}
+
+	category := CategoryJSON{
+		Label:    "CLI Reference",
+		Position: 3,
+		Link: &Link{
+			Type:        "generated-index",
+			Description: "Complete command-line reference for noteleaf",
+		},
+	}
+	categoryJSON, err := json.MarshalIndent(category, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal category json: %w", err)
+	}
+	if err := os.WriteFile(filepath.Join(outDir, "_category_.json"), categoryJSON, 0o644); err != nil {
+		return fmt.Errorf("failed to write category json: %w", err)
+	}
+
+	indexContent := generateIndexPage(root)
+	if err := os.WriteFile(filepath.Join(outDir, "index.md"), []byte(indexContent), 0o644); err != nil {
+		return fmt.Errorf("failed to write index.md: %w", err)
+	}
+
+	commandGroups := map[string]struct {
+		title       string
+		position    int
+		commands    []string
+		description string
+	}{
+		"tasks": {
+			title:       "Task Management",
+			position:    1,
+			commands:    []string{"todo", "task"},
+			description: "Manage tasks with TaskWarrior-inspired features",
+		},
+		"notes": {
+			title:       "Notes",
+			position:    2,
+			commands:    []string{"note"},
+			description: "Create and organize markdown notes",
+		},
+		"articles": {
+			title:       "Articles",
+			position:    3,
+			commands:    []string{"article"},
+			description: "Save and archive web articles",
+		},
+		"books": {
+			title:       "Books",
+			position:    4,
+			commands:    []string{"media book"},
+			description: "Manage reading list and track progress",
+		},
+		"movies": {
+			title:       "Movies",
+			position:    5,
+			commands:    []string{"media movie"},
+			description: "Track movies in watch queue",
+		},
+		"tv-shows": {
+			title:       "TV Shows",
+			position:    6,
+			commands:    []string{"media tv"},
+			description: "Manage TV show watching",
+		},
+		"configuration": {
+			title:       "Configuration",
+			position:    7,
+			commands:    []string{"config"},
+			description: "Manage application configuration",
+		},
+		"management": {
+			title:       "Management",
+			position:    8,
+			commands:    []string{"status", "setup", "reset"},
+			description: "Application management commands",
+		},
+	}
+
+	for filename, group := range commandGroups {
+		content := generateCombinedPage(root, group.title, group.position, group.commands, group.description)
+		outputFile := filepath.Join(outDir, filename+".md")
+		if err := os.WriteFile(outputFile, []byte(content), 0o644); err != nil {
+			return fmt.Errorf("failed to write %s: %w", outputFile, err)
+		}
+	}
+
+	return nil
+}
+
+// generateIndexPage creates the index/overview page
+func generateIndexPage(root *cobra.Command) string {
+	var b strings.Builder
+
+	b.WriteString("---\n")
+	b.WriteString("id: index\n")
+	b.WriteString("title: CLI Reference\n")
+	b.WriteString("sidebar_label: Overview\n")
+	b.WriteString("sidebar_position: 0\n")
+	b.WriteString("description: Complete command-line reference for noteleaf\n")
+	b.WriteString("---\n\n")
+
+	b.WriteString("# noteleaf CLI Reference\n\n")
+
+	if root.Long != "" {
+		b.WriteString(root.Long)
+		b.WriteString("\n\n")
+	} else if root.Short != "" {
+		b.WriteString(root.Short)
+		b.WriteString("\n\n")
+	}
+
+	b.WriteString("## Usage\n\n")
+	b.WriteString("```bash\n")
+	b.WriteString(root.UseLine())
+	b.WriteString("\n```\n\n")
+
+	b.WriteString("## Command Groups\n\n")
+	b.WriteString("- **[Task Management](tasks)** - Manage todos, projects, and time tracking\n")
+	b.WriteString("- **[Notes](notes)** - Create and organize markdown notes\n")
+	b.WriteString("- **[Articles](articles)** - Save and archive web articles\n")
+	b.WriteString("- **[Books](books)** - Track reading list and progress\n")
+	b.WriteString("- **[Movies](movies)** - Manage movie watch queue\n")
+	b.WriteString("- **[TV Shows](tv-shows)** - Track TV show watching\n")
+	b.WriteString("- **[Configuration](configuration)** - Manage settings\n")
+	b.WriteString("- **[Management](management)** - Application management\n\n")
+
+	return b.String()
+}
+
+// generateCombinedPage creates a combined documentation page for a command group
+func generateCombinedPage(root *cobra.Command, title string, position int, commandPaths []string, description string) string {
+	var b strings.Builder
+
+	slug := strings.ToLower(strings.ReplaceAll(title, " ", "-"))
+	b.WriteString("---\n")
+	b.WriteString(fmt.Sprintf("id: %s\n", slug))
+	b.WriteString(fmt.Sprintf("title: %s\n", title))
+	b.WriteString(fmt.Sprintf("sidebar_position: %d\n", position))
+	b.WriteString(fmt.Sprintf("description: %s\n", description))
+	b.WriteString("---\n\n")
+
+	for _, cmdPath := range commandPaths {
+		cmd := findCommand(root, strings.Split(cmdPath, " "))
+		if cmd == nil {
+			continue
+		}
+
+		b.WriteString(fmt.Sprintf("## %s\n\n", cmd.Name()))
+		if cmd.Long != "" {
+			b.WriteString(cmd.Long)
+			b.WriteString("\n\n")
+		} else if cmd.Short != "" {
+			b.WriteString(cmd.Short)
+			b.WriteString("\n\n")
+		}
+
+		b.WriteString("```bash\n")
+		b.WriteString(cmd.UseLine())
+		b.WriteString("\n```\n\n")
+
+		if cmd.HasSubCommands() {
+			b.WriteString("### Subcommands\n\n")
+			for _, sub := range cmd.Commands() {
+				if sub.Hidden {
+					continue
+				}
+				generateSubcommandSection(&b, sub, 4)
+			}
+		}
+
+		if cmd.HasFlags() {
+			b.WriteString("### Options\n\n")
+			b.WriteString("```\n")
+			b.WriteString(cmd.Flags().FlagUsages())
+			b.WriteString("```\n\n")
+		}
+	}
+
+	return b.String()
+}
+
+// generateSubcommandSection generates documentation for a subcommand
+func generateSubcommandSection(b *strings.Builder, cmd *cobra.Command, level int) {
+	prefix := strings.Repeat("#", level)
+
+	fmt.Fprintf(b, "%s %s\n\n", prefix, cmd.Name())
+
+	if cmd.Long != "" {
+		b.WriteString(cmd.Long)
+		b.WriteString("\n\n")
+	} else if cmd.Short != "" {
+		b.WriteString(cmd.Short)
+		b.WriteString("\n\n")
+	}
+
+	b.WriteString("**Usage:**\n\n")
+	b.WriteString("```bash\n")
+	b.WriteString(cmd.UseLine())
+	b.WriteString("\n```\n\n")
+
+	if cmd.HasLocalFlags() {
+		b.WriteString("**Options:**\n\n")
+		b.WriteString("```\n")
+		b.WriteString(cmd.LocalFlags().FlagUsages())
+		b.WriteString("```\n\n")
+	}
+
+	if len(cmd.Aliases) > 0 {
+		fmt.Fprintf(b, "**Aliases:** %s\n\n", strings.Join(cmd.Aliases, ", "))
+	}
+
+	if cmd.HasSubCommands() {
+		for _, sub := range cmd.Commands() {
+			if sub.Hidden {
+				continue
+			}
+			generateSubcommandSection(b, sub, level+1)
+		}
+	}
+}
+
+// findCommand finds a command by path
+func findCommand(root *cobra.Command, path []string) *cobra.Command {
+	if len(path) == 0 {
+		return root
+	}
+
+	for _, cmd := range root.Commands() {
+		if cmd.Name() == path[0] || contains(cmd.Aliases, path[0]) {
+			if len(path) == 1 {
+				return cmd
+			}
+			return findCommand(cmd, path[1:])
+		}
+	}
+
+	return nil
+}
+
+// contains checks if a string is in a slice
+func contains(slice []string, str string) bool {
+	return slices.Contains(slice, str)
+}

website/.markdownlint.json

···
+{
+    "MD040": false,
+    "MD013": false,
+    "MD025": false
+}

website/docs/manual/_category_.json

···
 {
-  "label": "Tutorial - Basics",
-  "position": 2,
-  "link": {
-    "type": "generated-index",
-    "description": "5 minutes to learn the most important Docusaurus concepts."
-  }
+    "label": "CLI Reference",
+    "position": 3,
+    "link": {
+        "type": "generated-index",
+        "description": "Complete command-line reference for noteleaf"
+    }
 }

website/docs/manual/articles.md

···
+---
+id: articles
+title: Articles
+sidebar_position: 3
+description: Save and archive web articles
+---
+
+## article
+
+Save and archive web articles locally.
+
+Parse articles from supported websites, extract clean content, and save as
+both markdown and HTML. Maintains a searchable archive of articles with
+metadata including author, title, and publication date.
+
+```bash
+noteleaf article
+```
+
+### Subcommands
+
+#### add
+
+Parse and save article content from a supported website.
+
+The article will be parsed using domain-specific XPath rules and saved
+as both Markdown and HTML files. Article metadata is stored in the database.
+
+**Usage:**
+
+```bash
+noteleaf article add <url>
+```
+
+#### list
+
+List saved articles with optional filtering.
+
+Use query to filter by title, or use flags for more specific filtering.
+
+**Usage:**
+
+```bash
+noteleaf article list [query] [flags]
+```
+
+**Options:**
+
+```
+      --author string   Filter by author
+  -l, --limit int       Limit number of results (0 = no limit)
+```
+
+**Aliases:** ls
+
+#### view
+
+Display article metadata and summary.
+
+Shows article title, author, publication date, URL, and a brief content
+preview. Use 'read' command to view the full article content.
+
+**Usage:**
+
+```bash
+noteleaf article view <id>
+```
+
+**Aliases:** show
+
+#### read
+
+Read the full markdown content of an article with beautiful formatting.
+
+This displays the complete article content using syntax highlighting and proper formatting.
+
+**Usage:**
+
+```bash
+noteleaf article read <id>
+```
+
+#### remove
+
+Delete an article and its files permanently.
+
+Removes the article metadata from the database and deletes associated markdown
+and HTML files. This operation cannot be undone.
+
+**Usage:**
+
+```bash
+noteleaf article remove <id>
+```
+
+**Aliases:** rm, delete
+

website/docs/manual/books.md

···
+---
+id: books
+title: Books
+sidebar_position: 4
+description: Manage reading list and track progress
+---
+
+## book
+
+Track books and reading progress.
+
+Search Google Books API to add books to your reading list. Track which books
+you're reading, update progress percentages, and maintain a history of finished
+books.
+
+```bash
+noteleaf media book
+```
+
+### Subcommands
+
+#### add
+
+Search for books and add them to your reading list.
+
+By default, shows search results in a simple list format where you can select by number.
+Use the -i flag for an interactive interface with navigation keys.
+
+**Usage:**
+
+```bash
+noteleaf media book add [search query...] [flags]
+```
+
+**Options:**
+
+```
+  -i, --interactive   Use interactive interface for book selection
+```
+
+#### list
+
+Display books in your reading list with progress indicators.
+
+Shows book titles, authors, and reading progress percentages. Filter by --all,
+--reading for books in progress, --finished for completed books, or --queued
+for books not yet started. Default shows queued books only.
+
+**Usage:**
+
+```bash
+noteleaf media book list [--all|--reading|--finished|--queued]
+```
+
+#### reading
+
+Mark a book as currently reading. Use this when you start a book from your queue.
+
+**Usage:**
+
+```bash
+noteleaf media book reading <id>
+```
+
+#### finished
+
+Mark a book as finished with current timestamp. Sets reading progress to 100%.
+
+**Usage:**
+
+```bash
+noteleaf media book finished <id>
+```
+
+**Aliases:** read
+
+#### remove
+
+Remove a book from your reading list. Use this for books you no longer want to track.
+
+**Usage:**
+
+```bash
+noteleaf media book remove <id>
+```
+
+**Aliases:** rm
+
+#### progress
+
+Set reading progress for a book.
+
+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.
+
+**Usage:**
+
+```bash
+noteleaf media book progress <id> <percentage>
+```
+
+#### update
+
+Change a book's status directly.
+
+Valid statuses are: queued (not started), reading (in progress), finished
+(completed), or removed (no longer tracking).
+
+**Usage:**
+
+```bash
+noteleaf media book update <id> <status>
+```
+

website/docs/manual/configuration.md

···
+---
+id: configuration
+title: Configuration
+sidebar_position: 7
+description: Manage application configuration
+---
+
+## config
+
+Manage noteleaf configuration
+
+```bash
+noteleaf config
+```
+
+### Subcommands
+
+#### get
+
+Display configuration values.
+
+If no key is provided, displays all configuration values.
+Otherwise, displays the value for the specified key.
+
+**Usage:**
+
+```bash
+noteleaf config get [key]
+```
+
+#### set
+
+Update a configuration value.
+
+Available keys:
+  database_path      - Custom database file path
+  data_dir           - Custom data directory
+  date_format        - Date format string (default: 2006-01-02)
+  color_scheme       - Color scheme (default: default)
+  default_view       - Default view mode (default: list)
+  default_priority   - Default task priority
+  editor             - Preferred text editor
+  articles_dir       - Articles storage directory
+  notes_dir          - Notes storage directory
+  auto_archive       - Auto-archive completed items (true/false)
+  sync_enabled       - Enable synchronization (true/false)
+  sync_endpoint      - Synchronization endpoint URL
+  sync_token         - Synchronization token
+  export_format      - Default export format (default: json)
+  movie_api_key      - API key for movie database
+  book_api_key       - API key for book database
+
+**Usage:**
+
+```bash
+noteleaf config set <key> <value>
+```
+
+#### path
+
+Display the path to the configuration file being used.
+
+**Usage:**
+
+```bash
+noteleaf config path
+```
+
+#### reset
+
+Reset all configuration values to their defaults.
+
+**Usage:**
+
+```bash
+noteleaf config reset
+```
+

website/docs/manual/index.md

···
+---
+id: index
+title: CLI Reference
+sidebar_label: Overview
+sidebar_position: 0
+description: Complete command-line reference for noteleaf
+---
+
+# noteleaf CLI Reference
+
+noteleaf - personal information manager for the command line
+
+A comprehensive CLI tool for managing tasks, notes, articles, and media queues.
+Inspired by TaskWarrior, noteleaf combines todo management with reading lists,
+watch queues, and a personal knowledge base.
+
+Core features include hierarchical tasks with dependencies, recurring tasks,
+time tracking, markdown notes with tags, article archiving, and media queue
+management for books, movies, and TV shows.
+
+## Usage
+
+```bash
+noteleaf
+```
+
+## Command Groups
+
+- **[Task Management](tasks)** - Manage todos, projects, and time tracking
+- **[Notes](notes)** - Create and organize markdown notes
+- **[Articles](articles)** - Save and archive web articles
+- **[Books](books)** - Track reading list and progress
+- **[Movies](movies)** - Manage movie watch queue
+- **[TV Shows](tv-shows)** - Track TV show watching
+- **[Configuration](configuration)** - Manage settings
+- **[Management](management)** - Application management
+

website/docs/manual/management.md

···
+---
+id: management
+title: Management
+sidebar_position: 8
+description: Application management commands
+---
+
+## status
+
+Display comprehensive application status information.
+
+Shows database location, configuration file path, data directories, and current
+settings. Use this command to verify your noteleaf installation and diagnose
+configuration issues.
+
+```bash
+noteleaf status
+```
+
+## setup
+
+Initialize noteleaf for first use.
+
+Creates the database, configuration file, and required data directories. Run
+this command after installing noteleaf or when setting up a new environment.
+Safe to run multiple times as it will skip existing resources.
+
+```bash
+noteleaf setup
+```
+
+### Subcommands
+
+#### seed
+
+Add sample tasks, books, and notes to the database for testing and demonstration purposes
+
+**Usage:**
+
+```bash
+noteleaf setup seed [flags]
+```
+
+**Options:**
+
+```
+  -f, --force   Clear existing data and re-seed
+```
+
+## reset
+
+Remove all application data and return to initial state.
+
+This command deletes the database, all media files, notes, and articles. The
+configuration file is preserved. Use with caution as this operation cannot be
+undone. You will be prompted for confirmation before deletion proceeds.
+
+```bash
+noteleaf reset
+```
+

website/docs/manual/movies.md

···
+---
+id: movies
+title: Movies
+sidebar_position: 5
+description: Track movies in watch queue
+---
+
+## movie
+
+Track movies you want to watch.
+
+Search TMDB for movies and add them to your queue. Mark movies as watched when
+completed. Maintains a history of your movie watching activity.
+
+```bash
+noteleaf media movie
+```
+
+### Subcommands
+
+#### add
+
+Search for movies and add them to your watch queue.
+
+By default, shows search results in a simple list format where you can select by number.
+Use the -i flag for an interactive interface with navigation keys.
+
+**Usage:**
+
+```bash
+noteleaf media movie add [search query...] [flags]
+```
+
+**Options:**
+
+```
+  -i, --interactive   Use interactive interface for movie selection
+```
+
+#### list
+
+Display movies in your queue with optional status filters.
+
+Shows movie titles, release years, and current status. Filter by --all to show
+everything, --watched for completed movies, or --queued for unwatched items.
+Default shows queued movies only.
+
+**Usage:**
+
+```bash
+noteleaf media movie list [--all|--watched|--queued]
+```
+
+#### watched
+
+Mark a movie as watched with current timestamp. Moves the movie from queued to watched status.
+
+**Usage:**
+
+```bash
+noteleaf media movie watched [id]
+```
+
+**Aliases:** seen
+
+#### remove
+
+Remove a movie from your watch queue. Use this for movies you no longer want to track.
+
+**Usage:**
+
+```bash
+noteleaf media movie remove [id]
+```
+
+**Aliases:** rm
+

website/docs/manual/notes.md

···
+---
+id: notes
+title: Notes
+sidebar_position: 2
+description: Create and organize markdown notes
+---
+
+## note
+
+Create and organize markdown notes with tags.
+
+Write notes in markdown format, organize them with tags, browse them in an
+interactive TUI, and edit them in your preferred editor. Notes are stored as
+files on disk with metadata tracked in the database.
+
+```bash
+noteleaf note
+```
+
+### Subcommands
+
+#### create
+
+Create a new markdown note.
+
+Provide a title and optional content inline, or use --interactive to open an
+editor. Use --file to import content from an existing markdown file. Notes
+support tags for organization and full-text search.
+
+Examples:
+  noteleaf note create "Meeting notes" "Discussed project timeline"
+  noteleaf note create -i
+  noteleaf note create --file ~/documents/draft.md
+
+**Usage:**
+
+```bash
+noteleaf note create [title] [content...] [flags]
+```
+
+**Options:**
+
+```
+  -e, --editor        Prompt to open note in editor after creation
+  -f, --file string   Create note from markdown file
+  -i, --interactive   Open interactive editor
+```
+
+**Aliases:** new
+
+#### list
+
+Opens interactive TUI browser for navigating and viewing notes
+
+**Usage:**
+
+```bash
+noteleaf note list [--archived] [--static] [--tags=tag1,tag2] [flags]
+```
+
+**Options:**
+
+```
+  -a, --archived      Show archived notes
+  -s, --static        Show static list instead of interactive TUI
+      --tags string   Filter by tags (comma-separated)
+```
+
+**Aliases:** ls
+
+#### read
+
+Display note content with formatted markdown rendering.
+
+Shows the note with syntax highlighting, proper formatting, and metadata.
+Useful for quick viewing without opening an editor.
+
+**Usage:**
+
+```bash
+noteleaf note read [note-id]
+```
+
+**Aliases:** view
+
+#### edit
+
+Open note in your configured text editor.
+
+Uses the editor specified in your noteleaf configuration or the EDITOR
+environment variable. Changes are automatically saved when you close the
+editor.
+
+**Usage:**
+
+```bash
+noteleaf note edit [note-id]
+```
+
+#### remove
+
+Delete a note permanently.
+
+Removes both the markdown file and database metadata. This operation cannot be
+undone. You will be prompted for confirmation before deletion.
+
+**Usage:**
+
+```bash
+noteleaf note remove [note-id]
+```
+
+**Aliases:** rm, delete, del
+

website/docs/manual/tasks.md

···
+---
+id: task-management
+title: Task Management
+sidebar_position: 1
+description: Manage tasks with TaskWarrior-inspired features
+---
+
+## todo
+
+Manage tasks with TaskWarrior-inspired features.
+
+Track todos with priorities, projects, contexts, and tags. Supports hierarchical
+tasks with parent/child relationships, task dependencies, recurring tasks, and
+time tracking. Tasks can be filtered by status, priority, project, or context.
+
+```bash
+noteleaf todo
+```
+
+### Subcommands
+
+#### add
+
+Create a new task with description and optional attributes.
+
+Tasks can be created with priority levels (low, medium, high, urgent), assigned
+to projects and contexts, tagged for organization, and configured with due dates
+and recurrence rules. Dependencies can be established to ensure tasks are
+completed in order.
+
+Examples:
+  noteleaf todo add "Write documentation" --priority high --project docs
+  noteleaf todo add "Weekly review" --recur "FREQ=WEEKLY" --due 2024-01-15
+
+**Usage:**
+
+```bash
+noteleaf todo add [description] [flags]
+```
+
+**Options:**
+
+```
+  -c, --context string      Set task context
+      --depends-on string   Set task dependencies (comma-separated UUIDs)
+  -d, --due string          Set due date (YYYY-MM-DD)
+      --parent string       Set parent task UUID
+  -p, --priority string     Set task priority
+      --project string      Set task project
+      --recur string        Set recurrence rule (e.g., FREQ=DAILY)
+  -t, --tags strings        Add tags to task
+      --until string        Set recurrence end date (YYYY-MM-DD)
+```
+
+**Aliases:** create, new
+
+#### list
+
+List tasks with optional filtering and display modes.
+
+By default, shows tasks in an interactive TaskWarrior-like interface.
+Use --static to show a simple text list instead.
+Use --all to show all tasks, otherwise only pending tasks are shown.
+
+**Usage:**
+
+```bash
+noteleaf todo list [flags]
+```
+
+**Options:**
+
+```
+  -a, --all               Show all tasks (default: pending only)
+      --context string    Filter by context
+  -i, --interactive       Force interactive mode (default)
+      --priority string   Filter by priority
+      --project string    Filter by project
+      --static            Use static text output instead of interactive
+      --status string     Filter by status
+```
+
+**Aliases:** ls
+
+#### view
+
+Display detailed information for a specific task.
+
+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.
+
+**Usage:**
+
+```bash
+noteleaf todo view [task-id] [flags]
+```
+
+**Options:**
+
+```
+      --format string   Output format (detailed, brief) (default "detailed")
+      --json            Output as JSON
+      --no-metadata     Hide creation/modification timestamps
+```
+
+#### update
+
+Modify attributes of an existing task.
+
+Update any task property including description, status, priority, project,
+context, due date, recurrence rule, or parent task. Add or remove tags and
+dependencies. Multiple attributes can be updated in a single command.
+
+Examples:
+  noteleaf todo update 123 --priority urgent --due tomorrow
+  noteleaf todo update 456 --add-tag urgent --project website
+
+**Usage:**
+
+```bash
+noteleaf todo update [task-id] [flags]
+```
+
+**Options:**
+
+```
+      --add-depends string      Add task dependencies (comma-separated UUIDs)
+      --add-tag strings         Add tags to task
+  -c, --context string          Set task context
+      --description string      Update task description
+  -d, --due string              Set due date (YYYY-MM-DD)
+      --parent string           Set parent task UUID
+  -p, --priority string         Set task priority
+      --project string          Set task project
+      --recur string            Set recurrence rule (e.g., FREQ=DAILY)
+      --remove-depends string   Remove task dependencies (comma-separated UUIDs)
+      --remove-tag strings      Remove tags from task
+      --status string           Update task status
+  -t, --tags strings            Add tags to task
+      --until string            Set recurrence end date (YYYY-MM-DD)
+```
+
+#### edit
+
+Open interactive editor for task modification.
+
+Provides a user-friendly interface with status picker and priority toggle.
+Easier than using multiple command-line flags for complex updates.
+
+**Usage:**
+
+```bash
+noteleaf todo edit [task-id]
+```
+
+**Aliases:** e
+
+#### delete
+
+Permanently remove a task from the database.
+
+This operation cannot be undone. Consider updating the task status to
+'deleted' instead if you want to preserve the record for historical purposes.
+
+**Usage:**
+
+```bash
+noteleaf todo delete [task-id]
+```
+
+#### projects
+
+Display all projects with task counts.
+
+Shows each project used in your tasks along with the number of tasks in each
+project. Use --todo-txt to format output with +project syntax for compatibility
+with todo.txt tools.
+
+**Usage:**
+
+```bash
+noteleaf todo projects [flags]
+```
+
+**Options:**
+
+```
+      --static     Use static text output instead of interactive
+      --todo-txt   Format output with +project prefix for todo.txt compatibility
+```
+
+**Aliases:** proj
+
+#### tags
+
+Display all tags used across tasks.
+
+Shows each tag with the number of tasks using it. Tags provide flexible
+categorization orthogonal to projects and contexts.
+
+**Usage:**
+
+```bash
+noteleaf todo tags [flags]
+```
+
+**Options:**
+
+```
+      --static   Use static text output instead of interactive
+```
+
+**Aliases:** t
+
+#### contexts
+
+Display all contexts with task counts.
+
+Contexts represent locations or environments where tasks can be completed (e.g.,
+@home, @office, @errands). Use --todo-txt to format output with @context syntax
+for compatibility with todo.txt tools.
+
+**Usage:**
+
+```bash
+noteleaf todo contexts [flags]
+```
+
+**Options:**
+
+```
+      --static     Use static text output instead of interactive
+      --todo-txt   Format output with @context prefix for todo.txt compatibility
+```
+
+**Aliases:** con, loc, ctx, locations
+
+#### done
+
+Mark a task as completed with current timestamp.
+
+Sets the task status to 'completed' and records the completion time. For
+recurring tasks, generates the next instance based on the recurrence rule.
+
+**Usage:**
+
+```bash
+noteleaf todo done [task-id]
+```
+
+**Aliases:** complete
+
+#### start
+
+Begin tracking time spent on a task.
+
+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.
+
+**Usage:**
+
+```bash
+noteleaf todo start [task-id] [flags]
+```
+
+**Options:**
+
+```
+  -n, --note string   Add a note to the time entry
+```
+
+#### stop
+
+End time tracking for the active task.
+
+Records the end time and calculates duration for the current work session.
+Duration is added to the task's total time tracked.
+
+**Usage:**
+
+```bash
+noteleaf todo stop [task-id]
+```
+
+#### timesheet
+
+Show time tracking summary for tasks.
+
+By default shows time entries for the last 7 days.
+Use --task to show timesheet for a specific task.
+Use --days to change the date range.
+
+**Usage:**
+
+```bash
+noteleaf todo timesheet [flags]
+```
+
+**Options:**
+
+```
+  -d, --days int      Number of days to show in timesheet (default 7)
+  -t, --task string   Show timesheet for specific task ID
+```
+
+#### recur
+
+Configure recurring task patterns.
+
+Create tasks that repeat on a schedule using iCalendar recurrence rules (RRULE).
+Supports daily, weekly, monthly, and yearly patterns with optional end dates.
+
+**Usage:**
+
+```bash
+noteleaf todo recur
+```
+
+**Aliases:** repeat
+
+##### set
+
+Apply a recurrence rule to create repeating task instances.
+
+Uses iCalendar RRULE syntax (e.g., "FREQ=DAILY" for daily tasks, "FREQ=WEEKLY;BYDAY=MO,WE,FR"
+for specific weekdays). When a recurring task is completed, the next instance is
+automatically generated.
+
+Examples:
+  noteleaf todo recur set 123 --rule "FREQ=DAILY"
+  noteleaf todo recur set 456 --rule "FREQ=WEEKLY;BYDAY=MO" --until 2024-12-31
+
+**Usage:**
+
+```bash
+noteleaf todo recur set [task-id] [flags]
+```
+
+**Options:**
+
+```
+      --rule string    Recurrence rule (e.g., FREQ=DAILY)
+      --until string   Recurrence end date (YYYY-MM-DD)
+```
+
+##### clear
+
+Remove recurrence from a task.
+
+Converts a recurring task to a one-time task. Existing future instances are not
+affected.
+
+**Usage:**
+
+```bash
+noteleaf todo recur clear [task-id]
+```
+
+##### show
+
+Display recurrence rule and schedule information.
+
+Shows the RRULE pattern, next occurrence date, and recurrence end date if
+configured.
+
+**Usage:**
+
+```bash
+noteleaf todo recur show [task-id]
+```
+
+#### depend
+
+Create and manage task dependencies.
+
+Establish relationships where one task must be completed before another can
+begin. Useful for multi-step workflows and project management.
+
+**Usage:**
+
+```bash
+noteleaf todo depend
+```
+
+**Aliases:** dep, deps
+
+##### add
+
+Make a task dependent on another task's completion.
+
+The first task cannot be started until the second task is completed. Use task
+UUIDs to specify dependencies.
+
+**Usage:**
+
+```bash
+noteleaf todo depend add [task-id] [depends-on-uuid]
+```
+
+##### remove
+
+Delete a dependency relationship between two tasks.
+
+**Usage:**
+
+```bash
+noteleaf todo depend remove [task-id] [depends-on-uuid]
+```
+
+**Aliases:** rm
+
+##### list
+
+Show all tasks that must be completed before this task can be started.
+
+**Usage:**
+
+```bash
+noteleaf todo depend list [task-id]
+```
+
+**Aliases:** ls
+
+##### blocked-by
+
+Display all tasks that depend on this task's completion.
+
+**Usage:**
+
+```bash
+noteleaf todo depend blocked-by [task-id]
+```
+
+## todo
+
+Manage tasks with TaskWarrior-inspired features.
+
+Track todos with priorities, projects, contexts, and tags. Supports hierarchical
+tasks with parent/child relationships, task dependencies, recurring tasks, and
+time tracking. Tasks can be filtered by status, priority, project, or context.
+
+```bash
+noteleaf todo
+```
+
+### Subcommands
+
+#### add
+
+Create a new task with description and optional attributes.
+
+Tasks can be created with priority levels (low, medium, high, urgent), assigned
+to projects and contexts, tagged for organization, and configured with due dates
+and recurrence rules. Dependencies can be established to ensure tasks are
+completed in order.
+
+Examples:
+  noteleaf todo add "Write documentation" --priority high --project docs
+  noteleaf todo add "Weekly review" --recur "FREQ=WEEKLY" --due 2024-01-15
+
+**Usage:**
+
+```bash
+noteleaf todo add [description] [flags]
+```
+
+**Options:**
+
+```
+  -c, --context string      Set task context
+      --depends-on string   Set task dependencies (comma-separated UUIDs)
+  -d, --due string          Set due date (YYYY-MM-DD)
+      --parent string       Set parent task UUID
+  -p, --priority string     Set task priority
+      --project string      Set task project
+      --recur string        Set recurrence rule (e.g., FREQ=DAILY)
+  -t, --tags strings        Add tags to task
+      --until string        Set recurrence end date (YYYY-MM-DD)
+```
+
+**Aliases:** create, new
+
+#### list
+
+List tasks with optional filtering and display modes.
+
+By default, shows tasks in an interactive TaskWarrior-like interface.
+Use --static to show a simple text list instead.
+Use --all to show all tasks, otherwise only pending tasks are shown.
+
+**Usage:**
+
+```bash
+noteleaf todo list [flags]
+```
+
+**Options:**
+
+```
+  -a, --all               Show all tasks (default: pending only)
+      --context string    Filter by context
+  -i, --interactive       Force interactive mode (default)
+      --priority string   Filter by priority
+      --project string    Filter by project
+      --static            Use static text output instead of interactive
+      --status string     Filter by status
+```
+
+**Aliases:** ls
+
+#### view
+
+Display detailed information for a specific task.
+
+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.
+
+**Usage:**
+
+```bash
+noteleaf todo view [task-id] [flags]
+```
+
+**Options:**
+
+```
+      --format string   Output format (detailed, brief) (default "detailed")
+      --json            Output as JSON
+      --no-metadata     Hide creation/modification timestamps
+```
+
+#### update
+
+Modify attributes of an existing task.
+
+Update any task property including description, status, priority, project,
+context, due date, recurrence rule, or parent task. Add or remove tags and
+dependencies. Multiple attributes can be updated in a single command.
+
+Examples:
+  noteleaf todo update 123 --priority urgent --due tomorrow
+  noteleaf todo update 456 --add-tag urgent --project website
+
+**Usage:**
+
+```bash
+noteleaf todo update [task-id] [flags]
+```
+
+**Options:**
+
+```
+      --add-depends string      Add task dependencies (comma-separated UUIDs)
+      --add-tag strings         Add tags to task
+  -c, --context string          Set task context
+      --description string      Update task description
+  -d, --due string              Set due date (YYYY-MM-DD)
+      --parent string           Set parent task UUID
+  -p, --priority string         Set task priority
+      --project string          Set task project
+      --recur string            Set recurrence rule (e.g., FREQ=DAILY)
+      --remove-depends string   Remove task dependencies (comma-separated UUIDs)
+      --remove-tag strings      Remove tags from task
+      --status string           Update task status
+  -t, --tags strings            Add tags to task
+      --until string            Set recurrence end date (YYYY-MM-DD)
+```
+
+#### edit
+
+Open interactive editor for task modification.
+
+Provides a user-friendly interface with status picker and priority toggle.
+Easier than using multiple command-line flags for complex updates.
+
+**Usage:**
+
+```bash
+noteleaf todo edit [task-id]
+```
+
+**Aliases:** e
+
+#### delete
+
+Permanently remove a task from the database.
+
+This operation cannot be undone. Consider updating the task status to
+'deleted' instead if you want to preserve the record for historical purposes.
+
+**Usage:**
+
+```bash
+noteleaf todo delete [task-id]
+```
+
+#### projects
+
+Display all projects with task counts.
+
+Shows each project used in your tasks along with the number of tasks in each
+project. Use --todo-txt to format output with +project syntax for compatibility
+with todo.txt tools.
+
+**Usage:**
+
+```bash
+noteleaf todo projects [flags]
+```
+
+**Options:**
+
+```
+      --static     Use static text output instead of interactive
+      --todo-txt   Format output with +project prefix for todo.txt compatibility
+```
+
+**Aliases:** proj
+
+#### tags
+
+Display all tags used across tasks.
+
+Shows each tag with the number of tasks using it. Tags provide flexible
+categorization orthogonal to projects and contexts.
+
+**Usage:**
+
+```bash
+noteleaf todo tags [flags]
+```
+
+**Options:**
+
+```
+      --static   Use static text output instead of interactive
+```
+
+**Aliases:** t
+
+#### contexts
+
+Display all contexts with task counts.
+
+Contexts represent locations or environments where tasks can be completed (e.g.,
+@home, @office, @errands). Use --todo-txt to format output with @context syntax
+for compatibility with todo.txt tools.
+
+**Usage:**
+
+```bash
+noteleaf todo contexts [flags]
+```
+
+**Options:**
+
+```
+      --static     Use static text output instead of interactive
+      --todo-txt   Format output with @context prefix for todo.txt compatibility
+```
+
+**Aliases:** con, loc, ctx, locations
+
+#### done
+
+Mark a task as completed with current timestamp.
+
+Sets the task status to 'completed' and records the completion time. For
+recurring tasks, generates the next instance based on the recurrence rule.
+
+**Usage:**
+
+```bash
+noteleaf todo done [task-id]
+```
+
+**Aliases:** complete
+
+#### start
+
+Begin tracking time spent on a task.
+
+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.
+
+**Usage:**
+
+```bash
+noteleaf todo start [task-id] [flags]
+```
+
+**Options:**
+
+```
+  -n, --note string   Add a note to the time entry
+```
+
+#### stop
+
+End time tracking for the active task.
+
+Records the end time and calculates duration for the current work session.
+Duration is added to the task's total time tracked.
+
+**Usage:**
+
+```bash
+noteleaf todo stop [task-id]
+```
+
+#### timesheet
+
+Show time tracking summary for tasks.
+
+By default shows time entries for the last 7 days.
+Use --task to show timesheet for a specific task.
+Use --days to change the date range.
+
+**Usage:**
+
+```bash
+noteleaf todo timesheet [flags]
+```
+
+**Options:**
+
+```
+  -d, --days int      Number of days to show in timesheet (default 7)
+  -t, --task string   Show timesheet for specific task ID
+```
+
+#### recur
+
+Configure recurring task patterns.
+
+Create tasks that repeat on a schedule using iCalendar recurrence rules (RRULE).
+Supports daily, weekly, monthly, and yearly patterns with optional end dates.
+
+**Usage:**
+
+```bash
+noteleaf todo recur
+```
+
+**Aliases:** repeat
+
+##### set
+
+Apply a recurrence rule to create repeating task instances.
+
+Uses iCalendar RRULE syntax (e.g., "FREQ=DAILY" for daily tasks, "FREQ=WEEKLY;BYDAY=MO,WE,FR"
+for specific weekdays). When a recurring task is completed, the next instance is
+automatically generated.
+
+Examples:
+  noteleaf todo recur set 123 --rule "FREQ=DAILY"
+  noteleaf todo recur set 456 --rule "FREQ=WEEKLY;BYDAY=MO" --until 2024-12-31
+
+**Usage:**
+
+```bash
+noteleaf todo recur set [task-id] [flags]
+```
+
+**Options:**
+
+```
+      --rule string    Recurrence rule (e.g., FREQ=DAILY)
+      --until string   Recurrence end date (YYYY-MM-DD)
+```
+
+##### clear
+
+Remove recurrence from a task.
+
+Converts a recurring task to a one-time task. Existing future instances are not
+affected.
+
+**Usage:**
+
+```bash
+noteleaf todo recur clear [task-id]
+```
+
+##### show
+
+Display recurrence rule and schedule information.
+
+Shows the RRULE pattern, next occurrence date, and recurrence end date if
+configured.
+
+**Usage:**
+
+```bash
+noteleaf todo recur show [task-id]
+```
+
+#### depend
+
+Create and manage task dependencies.
+
+Establish relationships where one task must be completed before another can
+begin. Useful for multi-step workflows and project management.
+
+**Usage:**
+
+```bash
+noteleaf todo depend
+```
+
+**Aliases:** dep, deps
+
+##### add
+
+Make a task dependent on another task's completion.
+
+The first task cannot be started until the second task is completed. Use task
+UUIDs to specify dependencies.
+
+**Usage:**
+
+```bash
+noteleaf todo depend add [task-id] [depends-on-uuid]
+```
+
+##### remove
+
+Delete a dependency relationship between two tasks.
+
+**Usage:**
+
+```bash
+noteleaf todo depend remove [task-id] [depends-on-uuid]
+```
+
+**Aliases:** rm
+
+##### list
+
+Show all tasks that must be completed before this task can be started.
+
+**Usage:**
+
+```bash
+noteleaf todo depend list [task-id]
+```
+
+**Aliases:** ls
+
+##### blocked-by
+
+Display all tasks that depend on this task's completion.
+
+**Usage:**
+
+```bash
+noteleaf todo depend blocked-by [task-id]
+```
+

website/docs/manual/tv-shows.md

···
+---
+id: tv-shows
+title: TV Shows
+sidebar_position: 6
+description: Manage TV show watching
+---
+
+## tv
+
+Track TV shows and episodes.
+
+Search TMDB for TV shows and add them to your queue. Track which shows you're
+currently watching, mark episodes as watched, and maintain a complete history
+of your viewing activity.
+
+```bash
+noteleaf media tv
+```
+
+### Subcommands
+
+#### add
+
+Search for TV shows and add them to your watch queue.
+
+By default, shows search results in a simple list format where you can select by number.
+Use the -i flag for an interactive interface with navigation keys.
+
+**Usage:**
+
+```bash
+noteleaf media tv add [search query...] [flags]
+```
+
+**Options:**
+
+```
+  -i, --interactive   Use interactive interface for TV show selection
+```
+
+#### list
+
+Display TV shows in your queue with optional status filters.
+
+Shows show titles, air dates, and current status. Filter by --all, --queued,
+--watching for shows in progress, or --watched for completed series. Default
+shows queued shows only.
+
+**Usage:**
+
+```bash
+noteleaf media tv list [--all|--queued|--watching|--watched]
+```
+
+#### watching
+
+Mark a TV show as currently watching. Use this when you start watching a series.
+
+**Usage:**
+
+```bash
+noteleaf media tv watching [id]
+```
+
+#### watched
+
+Mark TV show episodes or entire series as watched.
+
+Updates episode tracking and completion status. Can mark individual episodes
+or complete seasons/series depending on ID format.
+
+**Usage:**
+
+```bash
+noteleaf media tv watched [id]
+```
+
+**Aliases:** seen
+
+#### remove
+
+Remove a TV show from your watch queue. Use this for shows you no longer want to track.
+
+**Usage:**
+
+```bash
+noteleaf media tv remove [id]
+```
+
+**Aliases:** rm
+