docs(wip): new user facing docs

website/TODO.md

···
 
 This document tracks documentation coverage for the Noteleaf website. The goal is to provide comprehensive documentation for both the productivity system features and the leaflet.pub publishing capabilities.
 
-## Core Concepts
-
-- [ ] Introduction to Noteleaf
-  - [ ] What is Noteleaf?
-  - [ ] Why terminal-based productivity?
-  - [ ] Unified data model philosophy
-- [ ] Installation and Setup
-  - [ ] System requirements
-  - [ ] Building from source
-  - [ ] Configuration overview
-  - [ ] Database initialization
-  - [ ] Seeding sample data
-- [ ] Architecture Overview
-  - [ ] Application structure
-  - [ ] Storage and database
-  - [ ] TUI framework (Bubble Tea)
-  - [ ] Color palette and design system
-
-## Task Management
-
-- [ ] Task Basics
-  - [ ] Creating tasks
-  - [ ] Task properties (priority, project, tags, due dates)
-  - [ ] Task statuses and lifecycle
-  - [ ] Task dependencies
-- [ ] Task Operations
-  - [ ] Listing and filtering tasks
-  - [ ] Updating tasks
-  - [ ] Completing and deleting tasks
-  - [ ] Recurring tasks
-- [ ] Time Tracking
-  - [ ] Starting and stopping time tracking
-  - [ ] Viewing timesheets
-  - [ ] Time reports and analytics
-- [ ] Task Organization
-  - [ ] Projects
-  - [ ] Contexts
-  - [ ] Tags
-  - [ ] Custom attributes
-- [ ] Advanced Task Features
-  - [ ] Task queries and filters
-  - [ ] Custom views
-  - [ ] Batch operations
-  - [ ] Task templates
-
-## Note Taking
-
-- [ ] Note Basics
-  - [ ] Creating notes
-  - [ ] Note metadata (title, tags, dates)
-  - [ ] Markdown support
-- [ ] Note Operations
-  - [ ] Creating from command line vs editor
-  - [ ] Creating from files
-  - [ ] Editing notes
-  - [ ] Reading and viewing notes
-  - [ ] Searching notes
-- [ ] Note Organization
-  - [ ] Tagging system
-  - [ ] Linking notes to tasks
-  - [ ] Note templates
-- [ ] Advanced Note Features
-  - [ ] Full-text search
-  - [ ] Note exports
-  - [ ] Backlinks and references
-
-## Media Tracking
-
-- [ ] Books
-  - [ ] Adding books (manual and Open Library integration)
-  - [ ] Reading progress tracking
-  - [ ] Reading status (to-read, reading, finished)
-  - [ ] Book metadata and search
-  - [ ] Reading lists
-- [ ] Movies
-  - [ ] Adding movies
-  - [ ] Watch status
-  - [ ] Movie metadata
-  - [ ] Watchlists
-- [ ] TV Shows
-  - [ ] Adding TV shows
-  - [ ] Watch status
-  - [ ] Episode tracking
-  - [ ] Show metadata
-- [ ] Media Organization
-  - [ ] Tags and categories
-  - [ ] Custom lists
-  - [ ] Ratings and reviews
-  - [ ] Linking media to notes
-
-## Articles
-
-- [ ] Article Management
-  - [ ] Saving articles from URLs
-  - [ ] Article parsing and extraction
-  - [ ] Reading articles in terminal
-  - [ ] Article metadata (author, date, source)
-- [ ] Article Organization
-  - [ ] Filtering by author
-  - [ ] Tagging articles
-  - [ ] Read/unread status
-  - [ ] Article archives
-
-## Leaflet.pub Publishing
-
-- [ ] Introduction to Leaflet
-  - [ ] What is leaflet.pub?
-  - [ ] ATProto and decentralized publishing
-  - [ ] How Noteleaf integrates with Leaflet
-- [ ] Publications
-  - [ ] Creating publications
-  - [ ] Publication metadata
-  - [ ] Managing publications
-- [ ] Documents
-  - [ ] Document structure
-  - [ ] Creating documents
-  - [ ] Document drafts
-  - [ ] Publishing workflow
-- [ ] Rich Text and Blocks
-  - [ ] Text blocks
-  - [ ] Headers
-  - [ ] Code blocks
-  - [ ] Images and media
-  - [ ] Blockquotes
-  - [ ] Lists
-  - [ ] Horizontal rules
-- [ ] Rich Text Formatting
-  - [ ] Bold, italic, code
-  - [ ] Links
-  - [ ] Strikethrough, underline, highlight
-  - [ ] Facets and styling
-- [ ] Publishing Workflow
-  - [ ] Converting notes to leaflet documents
-  - [ ] Draft management
-  - [ ] Publishing to leaflet.pub
-  - [ ] Updating published documents
-  - [ ] Authentication and identity
-
-## Configuration
-
-- [ ] Configuration File
-  - [ ] Config file location and structure
-  - [ ] Configuration options reference
-  - [ ] Editor integration
-  - [ ] Default values
-- [ ] Environment Variables
-  - [ ] Supported environment variables
-  - [ ] Overriding defaults
-- [ ] Customization
-  - [ ] Custom themes (if supported)
-  - [ ] Keyboard shortcuts
-  - [ ] Output formats
-
 ## TUI (Terminal UI)
 
 - [ ] Interactive Mode
···
   - [ ] Service layer
   - [ ] Data models
   - [ ] UI component system
-
-## Troubleshooting
-
-- [ ] Common Issues
-  - [ ] Database errors
-  - [ ] Configuration problems
-  - [ ] Integration failures
-- [ ] Debugging
-  - [ ] Verbose output
-  - [ ] Log files
-  - [ ] Development mode
-- [ ] FAQ
-  - [ ] General questions
-  - [ ] Platform-specific issues
-  - [ ] Performance optimization
 
 ## Examples and Tutorials
 

website/docs/Configuration.md

···
+---
+id: configuration
+title: Configuration
+sidebar_label: Configuration
+sidebar_position: 6
+description: Reference for configuration locations, defaults, and options.
+---
+
 # Configuration
 
 Noteleaf stores its configuration in a TOML file. The configuration file location depends on your operating system and can be overridden with environment variables.
···
 ```sh
 export NOTELEAF_CONFIG=/path/to/custom/config.toml
 ```
+
+### File Structure
+
+Configuration is stored as [TOML](https://toml.io). Each key maps 1:1 with the fields shown by `noteleaf config show`. A minimal file looks like:
+
+```toml
+date_format = "2006-01-02"
+color_scheme = "default"
+```
+
+There is no required ordering—the parser loads the file, applies defaults for missing keys, and writes a normalized version whenever you run `noteleaf config set ...`. This means you can edit the file manually or stick entirely to CLI helpers.
 
 ## Configuration Options
 
···
 **Type:** String (ISO8601)
 **Default:** None
 
+## Editor Integration
+
+The `editor` key wires Noteleaf into your preferred text editor. Resolution order:
+
+1. `editor` inside `.noteleaf.conf.toml`
+2. `$EDITOR` environment variable
+3. System default (usually `vi` on Unix)
+
+Where it is used:
+
+- `noteleaf note edit <id>` always opens the configured editor.
+- `noteleaf note create -e` or `--editor` lets you capture inline text and immediately refine it in the editor.
+- Interactive creation (`noteleaf note create -i`) respects the same setting when you choose to open the note.
+
+Example configuration:
+
+```toml
+editor = "nvim"
+```
+
+If you frequently switch editors, leave the config empty and export `$EDITOR` before launching Noteleaf:
+
+```sh
+EDITOR="zed" noteleaf note edit 5
+```
+
 ## Managing Configuration
 
 ### View Current Configuration
···
 
 ## Environment Variables
 
-Noteleaf respects the following environment variables:
+Environment overrides are resolved before configuration values. Set them when you need temporary behavior (CI jobs, alternate workspaces, etc.).
 
-- `NOTELEAF_CONFIG` - Custom path to configuration file
-- `NOTELEAF_DATA_DIR` - Custom path to data directory
-- `EDITOR` - Default text editor (fallback if `editor` config not set)
+| Variable | Purpose | Notes |
+|----------|---------|-------|
+| `NOTELEAF_CONFIG` | Absolute path to the TOML file | Overrides platform defaults. Parent directories are created automatically. |
+| `NOTELEAF_DATA_DIR` | Root directory for the SQLite DB, notes, articles, and attachments | Useful for portable installs (USB drive, synced folder). |
+| `EDITOR` | Fallback editor when the `editor` config key is empty | Checked by all note-related commands. |
 
-Example:
+Usage example:
 
 ```sh
-export NOTELEAF_CONFIG=~/.config/noteleaf/config.toml
-export NOTELEAF_DATA_DIR=~/Documents/noteleaf-data
-export EDITOR=nvim
+export NOTELEAF_CONFIG=~/.config/noteleaf/work.conf.toml
+export NOTELEAF_DATA_DIR=~/Sync/workspace-data
+export EDITOR=helix
 ```
+
+Because `NOTELEAF_DATA_DIR` cascades to the article and note directories, a single export is all you need to relocate the entire knowledge base.
+
+## Customization
+
+### Themes and Colors
+
+The `color_scheme` option controls how Fang (the underlying Cobra replacement) styles command help and certain UI components. Right now the only valid value is `"default"`, which maps to Noteleaf’s Iceberg-inspired palette. Future releases will add explicit `light`/`dark` options; until then customization requires overriding your terminal theme or building Noteleaf from source with changes in `internal/ui/palette.go`.
+
+```toml
+color_scheme = "default"  # leave blank to adopt upcoming auto-mode
+```
+
+### Keyboard Shortcuts
+
+All interactive views share the same key map:
+
+| Keys | Action |
+|------|--------|
+| `↑ / k`, `↓ / j` | Move selection |
+| `enter` | Open the selected row |
+| `v` | View details in a side panel (where supported) |
+| `/` | Search/filter (live) |
+| `r` | Reload data |
+| `?` | Show full help, including custom actions for the current view |
+| `q`, `ctrl+c` | Quit the view |
+| `esc`, `backspace` | Exit search/help/detail panels |
+| `1-9` | Jump directly to the corresponding row index |
+
+Press `?` inside any list/table to confirm the bindings—this uses Bubble Tea’s built-in help component so it always reflects the current screen.
+
+### Output Formats
+
+- `export_format` sets the default for future export commands (currently `json`).
+- Task commands support JSON today: `noteleaf todo view 12 --json` or `noteleaf todo list --static --json`.
+- The `--format` flag on `noteleaf todo view` switches between `detailed` and `brief` layouts, which is handy when scripting.
+
+Examples:
+
+```sh
+noteleaf todo view 12 --format brief --json | jq '.status'
+noteleaf todo list --static --json > tasks.json
+noteleaf config set export_format "csv"   # prepare for upcoming exporters
+```
+
+Even when there is no dedicated exporter yet, the SQLite database lives in the open, so you can always run your own `SELECT ...` queries or use `sqlite-utils` to produce CSV/JSON.

website/docs/Quickstart.md

···
+---
+id: quickstart
+title: Quickstart Guide
+sidebar_label: Quickstart
+sidebar_position: 1
+description: Install Noteleaf and learn the essentials in minutes.
+---
+
 # Quickstart Guide
 
 This guide will walk you through installing Noteleaf and getting productive with tasks, notes, and media tracking in under 15 minutes.

website/docs/articles/_category_.json

···
+{
+    "label": "Articles",
+    "position": 6,
+    "link": {
+        "type": "generated-index",
+        "title": "Article Archive",
+        "description": "Save, read, and organize web articles locally."
+    }
+}

website/docs/articles/management.md

···
+---
+title: Article Management
+sidebar_label: Management
+description: Save URLs, inspect metadata, and read articles without leaving the CLI.
+sidebar_position: 2
+---
+
+# Article Management
+
+## Save Articles from URLs
+
+```sh
+noteleaf article add https://example.com/long-form-piece
+```
+
+What happens:
+
+1. The CLI checks the database to ensure the URL was not imported already.  
+2. It fetches the page with a reader-friendly User-Agent (`curl/8.4.0`) and English `Accept-Language` headers to avoid blocked responses.  
+3. Parsed content is written to Markdown and HTML files under `articles_dir`.  
+4. A database record is inserted with all metadata and file paths.
+
+If parsing fails (unsupported domain, network issue, etc.) nothing is written to disk, so partial entries never appear in your archive.
+
+## Parsing and Extraction
+
+The parser uses a two-layer strategy:
+
+1. **Domain-specific rules** check the XPath selectors defined in `internal/articles/rules`. These rules strip unwanted elements (cookie banners, nav bars), capture the main body, and record author/date fields accurately.  
+2. **Heuristic fallback** scores every DOM node, penalizes high link-density sections, and picks the most “article-like” block. It also pulls metadata from JSON-LD `Article` objects when available.
+
+During saving, the Markdown file gets a generated header:
+
+```markdown
+# Article Title
+
+**Author:** Jane Smith
+
+**Date:** 2024-01-02
+
+**Source:** https://example.com/long-form-piece
+
+**Saved:** 2024-02-05 10:45:12
+```
+
+Everything after the `---` separator is the cleaned article content.
+
+## Reading in the Terminal
+
+There are two ways to inspect what you saved:
+
+- `noteleaf article view <id>` shows metadata, verifies whether the files still exist, and prints the first ~20 lines as a preview.  
+- `noteleaf article read <id>` renders the full Markdown using [Charm’s Glamour](https://github.com/charmbracelet/glamour), giving you syntax highlighting, proper headings, and wrapped paragraphs directly in the terminal.
+
+If you prefer your editor, open the Markdown path printed by `view`. Both Markdown and HTML copies belong to you, so feel free to annotate or reformat them.
+
+## Article Metadata Reference
+
+Use `noteleaf article list` to see titles and authors:
+
+```sh
+noteleaf article list                 # newest first
+noteleaf article list "sqlite"        # full-text filter on titles
+noteleaf article list --author "Kim"  # author filter
+noteleaf article list -l 5            # top 5 results
+```
+
+Each entry includes the created timestamp. The `view` command provides the raw paths so you can script around them, for example:
+
+```sh
+md=$(noteleaf article view 12 | rg 'Markdown:' | awk '{print $3}')
+$EDITOR "$md"
+```
+
+All metadata lives in the SQLite `articles` table, making it easy to run your own reports with `sqlite3` if needed.

website/docs/articles/organization.md

···
+---
+title: Article Organization
+sidebar_label: Organization
+description: Filter your archive, add lightweight tags, and keep backups tidy.
+sidebar_position: 3
+---
+
+# Article Organization
+
+## Filter by Author or Title
+
+`noteleaf article list` accepts both a free-form query (matches the title) and dedicated flags:
+
+```sh
+# Anything with "SQLite" in the title
+noteleaf article list SQLite
+
+# Limit to a single author
+noteleaf article list --author "Ada Palmer"
+
+# Cap the output for quick reviews
+noteleaf article list --author "Ada Palmer" --limit 3
+```
+
+Because the database stores created timestamps, results come back with the newest article first, making it easy to run weekly reviews.
+
+## Tagging Articles
+
+There is no first-class tagging UI yet, but Markdown files are yours to edit. Common patterns:
+
+```markdown
+---
+tags: [distributed-systems, reference]
+project: moonshot
+---
+```
+
+Drop that block right after the generated metadata and tools like `rg` or `ripgrep --json` can surface tagged snippets instantly. You can also maintain a separate note that lists article IDs per topic if you prefer not to edit the captured files.
+
+## Read vs Unread
+
+Opening an article in the terminal does not flip a status flag. Use one of these lightweight conventions instead:
+
+- Prefix the Markdown filename with `read-` once you are done.
+- Keep a running checklist note (e.g., “Articles Inbox”) that references IDs and mark them off as you read them.
+- Create a task linked to the article ID (`todo add "Summarize article #14"`), then close the task when you finish.
+
+All three approaches work today and will map cleanly to future built-in read/unread tracking.
+
+## Archiving and Backups
+
+The archive lives under `articles_dir`. By default that is `<data_dir>/articles`, where `<data_dir>` depends on your OS:
+
+| Platform | Default |
+|----------|---------|
+| Linux    | `~/.local/share/noteleaf/articles` |
+| macOS    | `~/Library/Application Support/noteleaf/articles` |
+| Windows  | `%LOCALAPPDATA%\noteleaf\articles` |
+
+You can override the location via the `articles_dir` setting in `~/.config/noteleaf/.noteleaf.conf.toml` (or by pointing `NOTELEAF_DATA_DIR` to a different root before launching the CLI).
+
+Because every import produces Markdown + HTML, the directory is perfect for version control:
+
+```sh
+cd ~/.local/share/noteleaf/articles
+git init
+git add .
+git commit -m "Initial snapshot of article archive"
+```
+
+Pair that with your cloud backup tool of choice and you have a durable, fully-offline knowledge base that still integrates seamlessly with Noteleaf’s search commands.

website/docs/articles/overview.md

···
+---
+title: Article Overview
+sidebar_label: Overview
+description: How the article parser saves content for offline reading.
+sidebar_position: 1
+---
+
+# Article Overview
+
+The `noteleaf article` command turns any supported URL into two files on disk:
+
+- A clean Markdown document (great for terminal reading).
+- A rendered HTML copy (handy for rich export or sharing).
+
+Both files live inside your configured `articles_dir` (defaults to `<data_dir>/articles`). The SQLite database stores the metadata and file paths so you can query, list, and delete articles without worrying about directories.
+
+## How Parsing Works
+
+1. **Domain rules first**: Each supported site has a small XPath rule file (`internal/articles/rules/*.txt`).
+2. **Heuristic fallback**: When no rule exists, the parser falls back to the readability-style heuristic extractor that scores DOM nodes, removes nav bars, and preserves headings/links.
+3. **Metadata extraction**: The parser also looks for OpenGraph/JSON-LD tags to capture author names and publish dates.
+
+You can see the currently loaded rule set by running:
+
+```sh
+noteleaf article --help
+```
+
+The help output prints the supported domains and the storage directory that is currently in use.
+
+## Saved Metadata
+
+Every article record contains:
+
+- URL and canonical title
+- Author (if present in metadata)
+- Publication date (stored as plain text, e.g., `2024-01-02`)
+- Markdown file path
+- HTML file path
+- Created/modified timestamps
+
+These fields make it easy to build reading logs, cite sources in notes, or reference articles from tasks.
+
+## Commands at a Glance
+
+| Command                           | Purpose |
+|----------------------------------|---------|
+| `noteleaf article add <url>`     | Parse, save, and index a URL |
+| `noteleaf article list [query]`  | Show saved items; filter with `--author` or `--limit` |
+| `noteleaf article view <id>`     | Inspect metadata + a short preview |
+| `noteleaf article read <id>`     | Render the Markdown nicely in your terminal |
+| `noteleaf article remove <id>`   | Delete the DB entry and the files |
+
+The CLI automatically prevents duplicate imports by checking the URL before parsing.

website/docs/concepts/_category_.json

···
+{
+    "label": "Concepts",
+    "position": 2,
+    "link": {
+        "type": "generated-index",
+        "title": "Concepts",
+        "description": "Core ideas, architecture, and design principles behind Noteleaf."
+    }
+}

website/docs/concepts/architecture.md

···
+---
+title: Architecture Overview
+sidebar_label: Architecture
+description: Application structure, storage, and UI layers.
+sidebar_position: 3
+---
+
+# Architecture Overview
+
+## Architecture Overview
+
+### Application Structure
+
+Noteleaf follows a clean architecture pattern with clear separation of concerns:
+
+```
+cmd/                    - CLI commands and user interface
+internal/
+  handlers/            - Business logic and orchestration
+  repo/                - Database access layer
+  ui/                  - Terminal UI components (Bubble Tea)
+  models/              - Domain models
+  public/              - Leaflet.pub integration
+```
+
+Each layer has defined responsibilities with minimal coupling between them.
+
+### Storage and Database
+
+**SQLite Database**: All structured data (tasks, metadata, relationships) lives in a single SQLite file at `~/.local/share/noteleaf/noteleaf.db` (Linux) or `~/Library/Application Support/noteleaf/noteleaf.db` (macOS).
+
+**Markdown Files**: Note content is stored as individual markdown files on disk. The database tracks metadata while keeping your notes in a portable, human-readable format.
+
+**Database Schema**: Tables for tasks, notes, articles, books, movies, TV shows, publications, and linking tables for tags and relationships. Migrations handle schema evolution.
+
+### TUI Framework (Bubble Tea)
+
+The interactive interface is built with [Bubble Tea](https://github.com/charmbracelet/bubbletea), a Go framework for terminal user interfaces based on The Elm Architecture:
+
+- **Model**: Application state (current view, selected item, filters)
+- **Update**: State transitions based on user input
+- **View**: Render the current state to the terminal
+
+This architecture makes the UI predictable, testable, and composable. Each screen is an independent component that can be developed and tested in isolation.

website/docs/concepts/data-model.md

···
+---
+title: Unified Data Model
+sidebar_label: Data Model
+description: How tasks, notes, and media connect inside Noteleaf.
+sidebar_position: 2
+---
+
+# Unified Data Model
+
+## Philosophy
+
+Noteleaf treats all personal information as interconnected. Tasks, notes, articles, books, movies, and TV shows exist in a single database where relationships between items are first-class citizens:
+
+- Link notes to tasks to document your work
+- Tag books and articles with the same taxonomy as your tasks
+- Track reading lists alongside project work
+- Connect media items to research notes
+
+This unified approach mirrors how knowledge work actually happens—projects involve research, reading generates ideas, and ideas spawn tasks.

website/docs/concepts/design-system.md

···
+---
+title: Design System
+sidebar_label: Design System
+description: Color palette guidance that keeps the terminal UI cohesive.
+sidebar_position: 4
+---
+
+# Design System
+
+## Color Palette and Design System
+
+Noteleaf uses a carefully chosen color palette defined in `internal/ui/palette.go`:
+
+**Brand Colors**:
+
+- **Malibu** (`#00A4FF`): Primary blue for accents and highlights
+- **Julep** (`#00FFB2`): Success green for completed items
+- **Sriracha** (`#EB4268`): Warning red for urgent/error states
+- **Tang** (`#FF985A`): Orange for warnings and attention
+- **Lichen** (`#5CDFEA`): Teal for informational elements
+
+**Neutral Palette** (Dark to Light):
+
+- **Pepper** (`#201F26`): Dark background
+- **BBQ** (`#2d2c35`): Secondary background
+- **Charcoal** (`#3A3943`): Tertiary background
+- **Iron** (`#4D4C57`): Borders and subtle elements
+- **Oyster** (`#605F6B`): Muted text
+- **Smoke** (`#BFBCC8`): Secondary text
+- **Salt** (`#F1EFEF`): Primary text in dark mode
+- **Butter** (`#FFFAF1`): Light background
+
+This palette ensures consistency across all UI components and provides excellent contrast for readability in terminal environments.

website/docs/concepts/getting-started.md

···
+---
+title: Getting Started
+sidebar_label: Getting Started
+description: Installation steps, configuration overview, and ways to find help.
+sidebar_position: 5
+---
+
+# Getting Started
+
+## Installation and Setup
+
+### System Requirements
+
+- Go 1.24 or higher
+- SQLite 3.35 or higher (usually bundled)
+- Terminal with 256-color support
+- Unix-like OS (Linux, macOS, WSL)
+
+### Building from Source
+
+Clone the repository and build:
+
+```sh
+git clone https://github.com/stormlightlabs/noteleaf
+cd noteleaf
+go build -o ./tmp/noteleaf ./cmd
+```
+
+Install to your GOPATH:
+
+```sh
+go install
+```
+
+### Database Initialization
+
+Run setup to create the database and configuration file:
+
+```sh
+noteleaf setup
+```
+
+This creates:
+
+- Database at platform-specific application data directory
+- Configuration file at platform-specific config directory
+- Default settings for editor, priorities, and display options
+
+### Seeding Sample Data
+
+For exploration and testing, populate the database with example data:
+
+```sh
+noteleaf setup seed
+```
+
+This creates sample tasks, notes, books, and other items to help you understand the system's capabilities.
+
+## Configuration Overview
+
+Configuration lives in `config.toml` at the platform-specific config directory.
+
+**Editor Settings**:
+
+```toml
+[editor]
+command = "nvim"
+args = []
+```
+
+**Task Defaults**:
+
+```toml
+[task]
+default_priority = "medium"
+default_status = "pending"
+```
+
+**Display Options**:
+
+```toml
+[display]
+date_format = "2006-01-02"
+time_format = "15:04"
+```
+
+View current configuration:
+
+```sh
+noteleaf config show
+```
+
+Update settings:
+
+```sh
+noteleaf config set editor vim
+```
+
+See the [Configuration](../Configuration.md) guide for complete options.
+
+## Getting Help
+
+Every command includes help text:
+
+```sh
+noteleaf --help
+noteleaf task --help
+noteleaf task add --help
+```
+
+For detailed command reference, run `noteleaf --help` and drill into the subcommand-specific help pages.

website/docs/concepts/overview.md

···
+---
+title: Overview
+sidebar_label: Overview
+description: Noteleaf philosophy and reasons for a terminal-first approach.
+sidebar_position: 1
+---
+
+# Overview
+
+## What is Noteleaf?
+
+Noteleaf is a terminal-based personal information manager that combines task management, note-taking, media tracking, and decentralized publishing into a unified system. Built for developers and power users who prefer keyboard-driven workflows, Noteleaf brings TaskWarrior-inspired task management together with a personal knowledge base and reading list tracker.
+
+## Why the Terminal?
+
+Terminal applications offer several advantages for focused productivity work:
+
+**Keyboard-First Interface**: Navigate and manage information without context-switching to a mouse. Every action is a keystroke away, making workflows faster once learned.
+
+**Scriptability**: Command-line tools integrate seamlessly with shell scripts, automation tools, and other CLI utilities. Noteleaf can be incorporated into your existing terminal-based workflow.
+
+**Distraction-Free**: Terminal UIs remove visual clutter and web-based distractions, keeping you focused on the task at hand.
+
+**Performance**: Native applications built with Go start instantly and consume minimal resources compared to Electron-based alternatives.
+
+**Data Ownership**: Your data lives in a local SQLite database and markdown files. No cloud dependencies, no vendor lock-in, no privacy concerns.

website/docs/development/ARCHITECTURE.md

···
-# System Architecture
-
-Noteleaf is a CLI/TUI application for task and content management built on Go with SQLite persistence and terminal-based interfaces.
-
-## Core Architecture
-
-### Application Structure
-
-The application follows a layered architecture with clear separation between presentation, business logic, and data access layers.
-
-**Entry Point** - `cmd/main.go` initializes the application with dependency injection, creates handlers, and configures the Cobra command tree using the CommandGroup pattern.
-
-**CLI Framework** - Built on `spf13/cobra` with `charmbracelet/fang` providing enhanced CLI features including color schemes, versioning, and improved help formatting.
-
-**TUI Components** - Interactive interfaces use `charmbracelet/bubbletea` for state management and `charmbracelet/lipgloss` for styling with a consistent color palette system in `internal/ui/colors.go`.
-
-### Data Layer
-
-**Database** - SQLite with schema migrations in `internal/store/sql/migrations/`. The `internal/store` package manages database connections and configuration.
-
-**Repository Pattern** - Data access abstracts through repository interfaces in `internal/repo/` with validation logic ensuring data integrity at the persistence boundary.
-
-**Models** - Entity definitions in `internal/models/` implement standardized Model interfaces with common fields (ID, Created, Modified).
-
-### Business Logic
-
-**Handlers** - Business logic resides in `internal/handlers/` with one handler per domain (TaskHandler, NoteHandler, ArticleHandler, etc.).
-Handlers receive repository dependencies through constructor injection.
-
-**Services** - Domain-specific operations in `internal/services/` handle complex business workflows and external integrations.
-
-**Validation** - Schema-based validation at repository level with custom ValidationError types providing detailed field-level error messages.
-
-## Domain Features
-
-### Content Management
-
-**Articles** - Web scraping using `gocolly/colly` with domain-specific extraction rules stored in `internal/articles/rules/`.
-Articles are parsed to markdown and stored with dual file references (markdown + HTML).
-
-**Tasks** - Todo/task management inspired by TaskWarrior with filtering, status tracking, and interactive TUI views.
-
-**Notes** - Simple note management with markdown support and glamour-based terminal rendering.
-
-**Media Queues** - Separate queues for books, movies, and TV shows with status tracking and metadata management.
-
-### User Interface
-
-**Command Groups** - Commands organized into core functionality (task, note, article, media) and management operations (setup, config, status) using the CommandGroup interface pattern.
-
-**Interactive Views** - Bubbletea-based TUI components for list navigation, item selection, and data entry with consistent styling through the lipgloss color system.
-
-**Terminal Output** - Markdown rendering through `charmbracelet/glamour` for rich text display in terminal environments.
-
-## Dependencies
-
-**CLI/TUI** - Cobra command framework, Bubbletea state management, Lipgloss styling, Fang CLI enhancements.
-
-**Data** - SQLite driver (`mattn/go-sqlite3`), TOML configuration parsing.
-
-**Content Processing** - Colly web scraping, HTML/XML query libraries, Glamour markdown rendering, text processing utilities.
-
-**Utilities** - UUID generation, time handling, logging through `charmbracelet/log`.
-
-## Design Decisions and Tradeoffs
-
-### Technology Choices
-
-**Go over Rust** - Go was selected for its simplicity, excellent CLI ecosystem (Cobra, Charm libraries), and faster development velocity.
-While Rust + Ratatui would provide better memory safety and potentially superior performance, Go's straightforward concurrency model and mature tooling ecosystem made it the pragmatic choice for rapid prototyping and iteration.
-
-**SQLite over PostgreSQL** - SQLite provides zero-configuration deployment and sufficient performance for single-user CLI applications.
-The embedded database eliminates setup complexity while supporting full SQL features needed for filtering and querying.
-PostgreSQL would add deployment overhead without meaningful benefits for this use case.
-
-**Repository Pattern over Active Record** - Repository interfaces enable clean separation between business logic and data access, facilitating testing through dependency injection.
-This pattern scales better than Active Record for complex domain logic while maintaining clear boundaries between layers.
-
-### Architectural Tradeoffs
-
-**CommandGroup Interface** - Centralizes command registration while enabling modular command organization.
-The pattern requires additional abstraction but provides consistent dependency injection and testing capabilities across all command groups.
-
-**Handler-based Business Logic** - Business logic in handlers rather than rich domain models keeps the codebase simple and avoids over-engineering.
-While this approach may not scale to complex business rules, it provides clear separation of concerns for the current feature set.
-
-**Dual Storage for Articles** - Articles store both markdown and HTML versions to balance processing speed with format flexibility.
-This doubles storage requirements but eliminates runtime conversion overhead and preserves original formatting.
-
-### Component Interactions
-
-**Handler → Repository → Database** - Request flow follows a linear path from CLI commands through business logic to data persistence.
-This pattern ensures consistent validation and error handling while maintaining clear separation of concerns.
-
-**TUI State Management** - Bubbletea's unidirectional data flow provides predictable state updates for interactive components.
-The model-view-update pattern ensures consistent UI behavior across different terminal environments.
-
-**Configuration and Migration** - Application startup validates configuration and runs database migrations before initializing handlers.
-This fail-fast approach prevents runtime errors and ensures consistent database schema across deployments.

website/docs/development/TESTING.md

···
-# Testing Documentation
-
-This document outlines the testing patterns and practices used in the `noteleaf` application.
-
-## Overview
-
-The codebase follows Go's standard testing practices with specialized testing utilities for complex scenarios.
-Tests use the standard library along with carefully selected dependencies like faker for data generation and BubbleTea for TUI testing.
-This approach keeps dependencies minimal while providing robust testing infrastructure for interactive components and complex integrations.
-
-### Organization
-
-Each package contains its own test files alongside the source code. Test files are organized by functionality and mirror the structure of the source code they test.
-The codebase includes four main test utility files that provide specialized testing infrastructure:
-
-- `internal/services/test_utilities.go` - HTTP mocking and media service testing
-- `internal/repo/test_utilities.go` - Database testing and data generation
-- `internal/ui/test_utilities.go` - TUI testing framework and interactive component testing
-- `internal/handlers/test_utilities.go` - Handler testing with database isolation and input simulation
-
-## Patterns
-
-### Handler Creation
-
-Tests create real handler instances using temporary databases to ensure test isolation.
-Factory functions handle both database setup and handler initialization, returning both the handler and a cleanup function.
-
-### Database Isolation
-
-Tests use temporary directories and environment variable manipulation to create isolated database instances.
-Each test gets its own temporary SQLite database that is automatically cleaned up after the test completes.
-
-The `setupCommandTest` function creates a temporary directory, sets `XDG_CONFIG_HOME` to point to it, and initializes the database schema.
-This ensures tests don't interfere with each other or with development data.
-
-### Resource Management
-
-Tests properly manage resources using cleanup functions returned by factory methods.
-The cleanup function handles both handler closure and temporary directory removal.
-This pattern ensures complete resource cleanup even if tests fail.
-
-### Error Handling
-
-Tests use `t.Fatal` for setup errors that prevent test execution and `t.Error` for test assertion failures.
-Fatal errors stop test execution while errors allow tests to continue checking other conditions.
-
-### Context Cancellation
-
-Error case testing frequently uses context cancellation to simulate database and network failures.
-The pattern creates a context, immediately cancels it, then calls the function under test to verify error handling.
-This provides a reliable way to test error paths without requiring complex mock setups or external failure injection.
-
-### Command Structure
-
-Command group tests verify cobra command structure including use strings, aliases, short descriptions, and subcommand presence.
-Tests check that commands are properly configured without executing their logic.
-
-### Interface Compliance
-
-Tests verify interface compliance using compile-time checks with blank identifier assignments.
-This ensures structs implement expected interfaces without runtime overhead.
-
-## Test Infrastructure
-
-### Test Utility Frameworks
-
-The codebase provides comprehensive testing utilities organized by layer and functionality.
-Each test utility file contains specialized helpers, mocks, and test infrastructure for its respective domain.
-
-#### Database Testing Utilities
-
-`internal/repo/test_utilities.go` provides comprehensive database testing infrastructure:
-
-- **In-Memory Database Creation**: `CreateTestDB` creates isolated SQLite databases with full schema
-- **Sample Data Factories**: Functions like `CreateSampleTask`, `CreateSampleBook` generate realistic test data
-- **Faker Integration**: Uses jaswdr/faker for generating realistic fake data with `CreateFakeArticle`
-- **Test Setup Helpers**: `SetupTestData` creates a full set of sample data across all models
-- **Custom Assertions**: Generic assertion helpers like `AssertEqual`, `AssertContains`, `AssertNoError`
-
-#### HTTP Service Testing
-
-`internal/services/test_utilities.go` provides HTTP mocking and media service testing:
-
-- **Mock Configuration**: `MockConfig` structure for configuring service behavior
-- **Function Replacement**: `SetupMediaMocks` replaces service functions with controllable mocks
-- **Sample Data Access**: Helper functions that use embedded HTML samples for realistic testing
-- **Specialized Scenarios**: Pre-configured mock setups for success and failure scenarios
-- **Assertion Helpers**: Domain-specific assertions for movies, TV shows, and error conditions
-
-#### TUI Testing Framework
-
-`internal/ui/test_utilities.go` provides a comprehensive BubbleTea testing framework:
-
-- **TUITestSuite**: Complete testing infrastructure for interactive TUI components
-- **Controlled I/O**: `ControlledOutput` and `ControlledInput` for deterministic testing
-- **Message Simulation**: Key press simulation, message queuing, and timing control
-- **State Verification**: Model state checking and view content assertions
-- **Timeout Handling**: Configurable timeouts for async operations
-- **Mock Repository**: Test doubles for repository interfaces
-
-#### Handler Testing Infrastructure
-
-`internal/handlers/test_utilities.go` provides end-to-end handler testing:
-
-- **Environment Isolation**: `HandlerTestHelper` creates isolated test environments
-- **Input Simulation**: `InputSimulator` for testing interactive components that use `fmt.Scanf`
-- **HTTP Mocking**: Comprehensive HTTP server mocking for external API testing
-- **Database Helpers**: Database corruption and error scenario testing
-- **Editor Mocking**: `MockEditor` for testing file editing workflows
-- **Assertion Helpers**: Handler-specific assertions and verification functions
-
-### Advanced Testing Patterns
-
-#### Input Simulation for Interactive Components
-
-Interactive handlers that use `fmt.Scanf` require special testing infrastructure with an `io.Reader` implementation.
-
-The `InputSimulator` provides controlled input sequences that prevent tests from hanging while maintaining coverage of interactive code paths.
-
-#### TUI Testing with BubbleTea Framework
-
-The TUI testing framework addresses the fundamental challenge of testing interactive terminal applications in a deterministic, concurrent environment.
-BubbleTea's message-passing architecture creates unique testing requirements that standard Go testing patterns cannot adequately address.
-
-The framework implements a controlled execution environment that replaces BubbleTea's typical program loop with a deterministic testing harness.
-Rather than running an actual terminal program, the "testing suite" directly manages model state transitions by simulating the Update/View cycle.
-This approach eliminates the non-deterministic behavior inherent in real terminal interactions while preserving the exact message flow patterns that production code experiences.
-
-State verification relies on function composition patterns where test conditions are expressed as closures that capture specific model states.
-The `WaitFor` mechanism uses polling with configurable timeouts, addressing the async nature of BubbleTea model updates without creating race conditions.
-This pattern bridges imperative test assertions with BubbleTea's declarative update model.
-This is inspired by front-end/TS/JS testing patterns.
-
-The framework's I/O abstraction layer replaces terminal input/output with controlled buffers that implement standard Go interfaces.
-This design maintains interface compatibility while providing complete control over timing and content.
-The controlled I/O system captures all output for later verification and injects precise input sequences, enabling complex interaction testing without external dependencies.
-
-Concurrency management uses channels and context propagation to coordinate between the testing framework and the model under test.
-The suite manages goroutine lifecycle and ensures proper cleanup, preventing test interference and resource leaks.
-This architecture supports testing of models that perform background operations or handle async events.
-
-#### HTTP Service Mocking
-
-Service testing uses HTTP mocking with request capture. A `MockServer` is instantiated, and its URL is used in test scoped services.
-
-#### Database Schema Testing
-
-Database tests use comprehensive schema setup with (automatic) cleanup
-
-#### Environment Manipulation
-
-Environment testing utilities provide controlled environment manipulation. Environment variables are restored after instantiation.
-
-## Test Organization Patterns
-
-### Single Root Test
-
-The preferred test organization pattern uses a single root test function with nested subtests using `t.Run`.
-This provides clear hierarchical organization and allows running specific test sections while maintaining shared setup and context.
-This pattern offers several advantages: clear test hierarchy with logical grouping, ability to run specific test sections, consistent test structure across the codebase, and shared setup that can be inherited by subtests.
-
-### Integration vs Unit Testing
-
-The codebase emphasizes integration testing over heavy mocking by using real handlers and services to verify actual behavior rather than mocked interactions.
-The goal is to catch integration issues while maintaining test reliability.
-
-### Static Output
-
-UI components support static output modes for testing. Tests capture output using bytes.Buffer and verify content using string contains checks rather than exact string matching for better test maintainability.
-
-### Standard Output Redirection
-
-For testing functions that write to stdout, tests use a pipe redirection pattern with goroutines to capture output.
-The pattern saves the original stdout, redirects to a pipe, captures output in a separate goroutine, and restores stdout after the test.
-This ensures clean output capture without interfering with the testing framework.
-
-## Utilities
-
-### Test Data Generation
-
-The codebase uses sophisticated data generation strategies:
-
-- **Factory Functions**: Each package provides factory functions for creating valid test data
-- **Faker Integration**: Uses `jaswdr/faker` for generating realistic fake data with proper randomization
-- **Sample Data Creators**: Functions like `CreateSampleTask`, `CreateSampleBook` provide consistent test data
-- **Embedded Resources**: Services use embedded HTML samples from real API responses for realistic testing
-
-### Assertion Helpers
-
-Custom assertion functions provide clear error messages and reduce test code duplication:
-
-- **Generic Assertions**: `AssertEqual`, `AssertNoError`, `AssertContains` for common checks
-- **Domain-Specific Assertions**: `AssertMovieInResults`, `AssertNoteExists` for specialized verification
-- **TUI Assertions**: `AssertViewContains`, `AssertModelState` for BubbleTea model testing
-- **HTTP Assertions**: `AssertRequestMade` for verifying HTTP interactions
-
-### Mock Infrastructure
-
-Each layer provides specialized mocking capabilities:
-
-- **Service Mocking**: Function replacement with configurable behavior and embedded test data
-- **HTTP Mocking**: `HTTPMockServer` with request capture and response customization
-- **Input Mocking**: `InputSimulator` for deterministic interactive component testing
-- **Editor Mocking**: `MockEditor` for file editing workflow testing
-- **Repository Mocking**: `MockTaskRepository` for TUI component testing
-
-### Environment and Resource Management
-
-Testing utilities provide comprehensive resource management:
-
-- **Environment Isolation**: `EnvironmentTestHelper` for controlled environment variable manipulation
-- **Database Isolation**: Temporary SQLite databases with automatic cleanup
-- **File System Isolation**: Temporary directories with automatic cleanup
-- **Process Isolation**: Handler helpers that create completely isolated test environments
-
-## Testing CLI Commands
-
-Command group tests focus on structure verification rather than execution testing.
-Tests check command configuration, subcommand presence, and interface compliance. This approach ensures command trees are properly constructed without requiring complex execution mocking.
-
-### CommandGroup Interface Testing
-
-The CommandGroup interface enables testable CLI architecture. Tests verify that command groups implement the interface correctly and return properly configured cobra commands.
-This pattern separates command structure from command execution.
-
-Interface compliance is tested using compile-time checks within the "Interface Implementations" subtest, ensuring all command structs properly implement the CommandGroup interface without runtime overhead.
-
-## Performance Considerations
-
-Tests avoid expensive operations in setup functions. Handler creation uses real instances but tests focus on structure verification rather than full execution paths.
-This keeps test suites fast while maintaining coverage of critical functionality.
-
-The single root test pattern allows for efficient resource management where setup costs can be amortized across multiple related test cases.
-
-## Interactive Component Testing
-
-The codebase provides comprehensive testing infrastructure for interactive components, including both terminal UI applications and command-line interfaces that require user input.
-
-### Input Simulation Framework
-
-Interactive handlers that use `fmt.Scanf` require specialized testing infrastructure:
-
-- **InputSimulator**: Provides controlled input sequences that implement `io.Reader`
-- **Menu Selection Helpers**: `MenuSelection`, `MenuCancel`, `MenuSequence` for common interaction patterns
-- **Handler Integration**: Handlers can accept `io.Reader` for input, enabling deterministic testing
-- **Cleanup Management**: Automatic cleanup prevents resource leaks in test environments
-
-### TUI Testing with BubbleTea
-
-The TUI testing framework provides complete testing infrastructure for interactive terminal interfaces:
-
-- **TUITestSuite**: Comprehensive testing framework for BubbleTea models
-- **Message Simulation**: Key press simulation, window resize events, and custom message handling
-- **State Verification**: Model state checking with custom condition functions
-- **View Assertions**: Content verification and output capture
-- **Timing Control**: Configurable timeouts and delay handling for async operations
-- **Mock Integration**: Repository mocking for isolated component testing
-
-### Interactive Test Scenarios
-
-Interactive handlers should test comprehensive scenarios:
-
-- **Valid user selections** - User chooses valid menu options and inputs
-- **Cancellation flows** - User chooses to cancel operations (option 0 or escape keys)
-- **Invalid choices** - User selects out-of-range options or provides invalid input
-- **Navigation patterns** - Keyboard navigation, scrolling, and multi-step interactions
-- **Error handling** - Network errors, service failures, and data validation errors
-- **Empty states** - Search returns no results, empty lists, and missing data
-- **Edge cases** - Boundary conditions, malformed input, and resource constraints
-
-### TUI Component Testing Patterns
-
-BubbleTea components use specialized testing patterns:
-
-- **Key Sequence Testing**: Simulate complex user interactions with timing
-- **State Transition Testing**: Verify model state changes through user actions
-- **View Content Testing**: Assert specific content appears in rendered output
-- **Async Operation Testing**: Handle loading states and network operations
-- **Responsive Design Testing**: Test different terminal sizes and window resize handling
-
-This comprehensive testing approach ensures interactive components work reliably in automated environments while maintaining full coverage of user interaction paths.
-
-## Errors
-
-Error coverage follows a systematic approach to identify and test failure scenarios:
-
-1. **Context Cancellation** - Primary method for testing database and network timeout scenarios
-2. **Invalid Input** - Malformed data, empty inputs, boundary conditions
-3. **Resource Exhaustion** - Database connection failures, memory limits
-4. **Constraint Violations** - Duplicate keys, foreign key failures
-5. **State Validation** - Testing functions with invalid system states
-6. **Interactive Input** - Invalid user choices, cancellation handling, input simulation errors

website/docs/examples/articles.md

···
-# Article Examples
-
-Examples of saving and managing articles using Noteleaf.
-
-## Saving Articles
-
-### Save Article from URL
-
-```sh
-noteleaf article add https://example.com/interesting-article
-```
-
-### Save with Custom Title
-
-```sh
-noteleaf article add https://example.com/article --title "My Custom Title"
-```
-
-### Save Multiple Articles
-
-```sh
-noteleaf article add https://example.com/article-1
-noteleaf article add https://example.com/article-2
-noteleaf article add https://example.com/article-3
-```
-
-## Viewing Articles
-
-### List All Articles
-
-```sh
-noteleaf article list
-```
-
-### Filter by Author
-
-```sh
-noteleaf article list --author "Jane Smith"
-noteleaf article list --author "John Doe"
-```
-
-### Filter with Query
-
-```sh
-noteleaf article list --query "golang"
-noteleaf article list --query "machine learning"
-```
-
-### Limit Results
-
-```sh
-noteleaf article list --limit 10
-noteleaf article list --limit 5
-```
-
-### View Article Content
-
-Display in terminal:
-
-```sh
-noteleaf article view 1
-```
-
-Read in browser:
-
-```sh
-noteleaf article read 1
-```
-
-## Managing Articles
-
-### Update Article Metadata
-
-Update title:
-
-```sh
-noteleaf article update 1 --title "Updated Title"
-```
-
-Update author:
-
-```sh
-noteleaf article update 1 --author "Jane Doe"
-```
-
-Add notes:
-
-```sh
-noteleaf article update 1 --notes "Great insights on API design"
-```
-
-### Remove Article
-
-```sh
-noteleaf article remove 1
-```
-
-Remove multiple:
-
-```sh
-noteleaf article remove 1 2 3
-```
-
-## Common Workflows
-
-### Reading List Management
-
-Save articles to read later:
-
-```sh
-noteleaf article add https://blog.example.com/microservices
-noteleaf article add https://dev.to/understanding-async
-noteleaf article add https://medium.com/best-practices
-
-# View reading list
-noteleaf article list
-```
-
-### Research Collection
-
-Collect articles for research:
-
-```sh
-# Save research articles
-noteleaf article add https://arxiv.org/paper1 --notes "Research: ML optimization"
-noteleaf article add https://arxiv.org/paper2 --notes "Research: Neural networks"
-
-# Find research articles
-noteleaf article list --query "Research"
-```
-
-### Technical Documentation
-
-Archive technical articles:
-
-```sh
-noteleaf article add https://docs.example.com/api-guide --notes "Category: Documentation"
-noteleaf article add https://tutorials.example.com/setup --notes "Category: Tutorial"
-
-# Find documentation
-noteleaf article list --query "Documentation"
-```
-
-### Author Following
-
-Track articles by favorite authors:
-
-```sh
-# Save articles
-noteleaf article add https://blog.author1.com/post1 --author "Martin Fowler"
-noteleaf article add https://blog.author1.com/post2 --author "Martin Fowler"
-
-# View articles by author
-noteleaf article list --author "Martin Fowler"
-```
-
-### Topic Collections
-
-Organize by topic using notes:
-
-```sh
-# Backend articles
-noteleaf article add https://example.com/databases --notes "Topic: Backend, Database"
-noteleaf article add https://example.com/caching --notes "Topic: Backend, Performance"
-
-# Frontend articles
-noteleaf article add https://example.com/react --notes "Topic: Frontend, React"
-noteleaf article add https://example.com/css --notes "Topic: Frontend, CSS"
-
-# Find by topic
-noteleaf article list --query "Backend"
-noteleaf article list --query "Frontend"
-```
-
-### Daily Reading Routine
-
-Save articles during the day:
-
-```sh
-# Morning
-noteleaf article add https://news.ycombinator.com/article1
-noteleaf article add https://reddit.com/r/programming/article2
-
-# Evening - review saved articles
-noteleaf article list
-noteleaf article view 1
-noteleaf article view 2
-```
-
-### Offline Reading
-
-Save articles for offline access:
-
-```sh
-# Save articles before travel
-noteleaf article add https://longform.com/essay1
-noteleaf article add https://magazine.com/feature
-
-# Read offline (articles are saved locally)
-noteleaf article view 1
-noteleaf article view 2
-```
-
-### Archive and Cleanup
-
-Remove read articles:
-
-```sh
-# List articles
-noteleaf article list
-
-# Remove articles you've read
-noteleaf article remove 1 2 3 4 5
-
-# Keep only recent articles (manual filtering)
-noteleaf article list --limit 20
-```
-
-### Share-worthy Content
-
-Mark articles worth sharing:
-
-```sh
-noteleaf article add https://excellent.article.com --notes "Share: Twitter, Newsletter"
-noteleaf article add https://must-read.com/post --notes "Share: Team, Blog"
-
-# Find share-worthy articles
-noteleaf article list --query "Share"
-```
-
-### Learning Path
-
-Create structured learning collections:
-
-```sh
-# Beginner articles
-noteleaf article add https://tutorial.com/intro --notes "Level: Beginner, Go"
-noteleaf article add https://tutorial.com/basics --notes "Level: Beginner, Go"
-
-# Advanced articles
-noteleaf article add https://advanced.com/patterns --notes "Level: Advanced, Go"
-
-# Find by level
-noteleaf article list --query "Beginner"
-noteleaf article list --query "Advanced"
-```
-
-### Weekly Digests
-
-Collect interesting articles weekly:
-
-```sh
-# Week 1
-noteleaf article add https://example.com/week1-1 --notes "Week: 2024-W01"
-noteleaf article add https://example.com/week1-2 --notes "Week: 2024-W01"
-
-# Week 2
-noteleaf article add https://example.com/week2-1 --notes "Week: 2024-W02"
-
-# Review week's articles
-noteleaf article list --query "2024-W01"
-```
-
-## Exporting Articles
-
-### Export Article to File
-
-```sh
-noteleaf article export 1 --format markdown > article.md
-noteleaf article export 1 --format html > article.html
-```
-
-### Export Multiple Articles
-
-```sh
-noteleaf article export --all --format markdown --output articles/
-```
-
-### Export by Query
-
-```sh
-noteleaf article export --query "golang" --format markdown --output go-articles/
-```
-
-## Integration with Notes
-
-### Create Note from Article
-
-After reading:
-
-```sh
-# Read article
-noteleaf article view 1
-
-# Create summary note
-noteleaf note create "Article Summary: Title" "
-Source: [Article URL]
-Author: [Author Name]
-
-Key Points:
-- Point 1
-- Point 2
-
-My Thoughts:
-- Observation 1
-- Observation 2
-" --tags article-summary,topic
-```
-
-### Link Article to Task
-
-Create follow-up task:
-
-```sh
-# Save article
-noteleaf article add https://example.com/implement-feature
-
-# Create related task
-noteleaf task add "Implement feature from article #1" --tags implementation
-```
-
-## Article Statistics
-
-### Count Articles
-
-```sh
-noteleaf article list | wc -l
-```
-
-### Articles by Author
-
-```sh
-noteleaf article list --author "Author Name" | wc -l
-```
-
-### Articles by Topic
-
-```sh
-noteleaf article list --query "topic" | wc -l
-```

website/docs/examples/media.md

···
-# Media Examples
-
-Examples of managing your reading lists and watch queues using Noteleaf.
-
-## Books
-
-### Adding Books
-
-Search and add from Open Library:
-
-```sh
-noteleaf media book add "The Name of the Wind"
-noteleaf media book add "Project Hail Mary"
-noteleaf media book add "Dune"
-```
-
-Add by author:
-
-```sh
-noteleaf media book add "Foundation by Isaac Asimov"
-```
-
-Add with specific year:
-
-```sh
-noteleaf media book add "1984 by George Orwell 1949"
-```
-
-### Viewing Books
-
-List all books:
-
-```sh
-noteleaf media book list
-```
-
-Filter by status:
-
-```sh
-noteleaf media book list --status queued
-noteleaf media book list --status reading
-noteleaf media book list --status finished
-```
-
-### Managing Reading Status
-
-Start reading:
-
-```sh
-noteleaf media book reading 1
-```
-
-Mark as finished:
-
-```sh
-noteleaf media book finished 1
-```
-
-### Tracking Progress
-
-Update reading progress (percentage):
-
-```sh
-noteleaf media book progress 1 25
-noteleaf media book progress 1 50
-noteleaf media book progress 1 75
-```
-
-Update with page numbers:
-
-```sh
-noteleaf media book progress 1 150 --total 400
-```
-
-### Book Details
-
-View book details:
-
-```sh
-noteleaf media book view 1
-```
-
-### Updating Book Information
-
-Update book notes:
-
-```sh
-noteleaf media book update 1 --notes "Excellent worldbuilding and magic system"
-```
-
-Add rating:
-
-```sh
-noteleaf media book update 1 --rating 5
-```
-
-### Removing Books
-
-Remove from list:
-
-```sh
-noteleaf media book remove 1
-```
-
-## Movies
-
-### Adding Movies
-
-Add movie:
-
-```sh
-noteleaf media movie add "The Matrix"
-noteleaf media movie add "Inception"
-noteleaf media movie add "Interstellar"
-```
-
-Add with year:
-
-```sh
-noteleaf media movie add "Blade Runner 1982"
-```
-
-### Viewing Movies
-
-List all movies:
-
-```sh
-noteleaf media movie list
-```
-
-Filter by status:
-
-```sh
-noteleaf media movie list --status queued
-noteleaf media movie list --status watched
-```
-
-### Managing Watch Status
-
-Mark as watched:
-
-```sh
-noteleaf media movie watched 1
-```
-
-### Movie Details
-
-View movie details:
-
-```sh
-noteleaf media movie view 1
-```
-
-### Updating Movie Information
-
-Add notes and rating:
-
-```sh
-noteleaf media movie update 1 --notes "Mind-bending sci-fi" --rating 5
-```
-
-### Removing Movies
-
-Remove from list:
-
-```sh
-noteleaf media movie remove 1
-```
-
-## TV Shows
-
-### Adding TV Shows
-
-Add TV show:
-
-```sh
-noteleaf media tv add "Breaking Bad"
-noteleaf media tv add "The Wire"
-noteleaf media tv add "Better Call Saul"
-```
-
-### Viewing TV Shows
-
-List all shows:
-
-```sh
-noteleaf media tv list
-```
-
-Filter by status:
-
-```sh
-noteleaf media tv list --status queued
-noteleaf media tv list --status watching
-noteleaf media tv list --status watched
-```
-
-### Managing Watch Status
-
-Start watching:
-
-```sh
-noteleaf media tv watching 1
-```
-
-Mark as finished:
-
-```sh
-noteleaf media tv watched 1
-```
-
-Put on hold:
-
-```sh
-noteleaf media tv update 1 --status on-hold
-```
-
-### TV Show Details
-
-View show details:
-
-```sh
-noteleaf media tv view 1
-```
-
-### Updating TV Show Information
-
-Update current episode:
-
-```sh
-noteleaf media tv update 1 --season 2 --episode 5
-```
-
-Add notes and rating:
-
-```sh
-noteleaf media tv update 1 --notes "Intense character development" --rating 5
-```
-
-### Removing TV Shows
-
-Remove from list:
-
-```sh
-noteleaf media tv remove 1
-```
-
-## Common Workflows
-
-### Weekend Watch List
-
-Plan your weekend viewing:
-
-```sh
-# Add movies
-noteleaf media movie add "The Shawshank Redemption"
-noteleaf media movie add "Pulp Fiction"
-noteleaf media movie add "Forrest Gump"
-
-# View queue
-noteleaf media movie list --status queued
-```
-
-### Reading Challenge
-
-Track annual reading goal:
-
-```sh
-# Add books to queue
-noteleaf media book add "The Lord of the Rings"
-noteleaf media book add "The Hobbit"
-noteleaf media book add "Mistborn"
-
-# Check progress
-noteleaf media book list --status finished
-noteleaf media book list --status reading
-```
-
-### Binge Watching Tracker
-
-Track TV series progress:
-
-```sh
-# Start series
-noteleaf media tv add "Game of Thrones"
-noteleaf media tv watching 1
-
-# Update progress
-noteleaf media tv update 1 --season 1 --episode 1
-noteleaf media tv update 1 --season 1 --episode 2
-
-# View current shows
-noteleaf media tv list --status watching
-```
-
-### Media Recommendations
-
-Keep track of recommendations:
-
-```sh
-# Add recommended items
-noteleaf media book add "Sapiens" --notes "Recommended by John"
-noteleaf media movie add "Parasite" --notes "Won Best Picture 2020"
-noteleaf media tv add "Succession" --notes "From Reddit recommendations"
-
-# View recommendations
-noteleaf media book list --static | grep "Recommended"
-```
-
-### Review and Rating
-
-After finishing, add review:
-
-```sh
-# Book review
-noteleaf media book finished 1
-noteleaf media book update 1 \
-  --rating 5 \
-  --notes "Masterful storytelling. The magic system is one of the best in fantasy."
-
-# Movie review
-noteleaf media movie watched 2
-noteleaf media movie update 2 \
-  --rating 4 \
-  --notes "Great cinematography but slow pacing in second act."
-
-# TV show review
-noteleaf media tv watched 3
-noteleaf media tv update 3 \
-  --rating 5 \
-  --notes "Best character development I've seen. Final season was perfect."
-```
-
-### Genre Organization
-
-Organize by genre using notes:
-
-```sh
-noteleaf media book add "Snow Crash" --notes "Genre: Cyberpunk"
-noteleaf media book add "Neuromancer" --notes "Genre: Cyberpunk"
-noteleaf media book add "The Expanse" --notes "Genre: Space Opera"
-
-# Find by genre
-noteleaf media book list --static | grep "Cyberpunk"
-```
-
-### Currently Consuming
-
-See what you're currently reading/watching:
-
-```sh
-noteleaf media book list --status reading
-noteleaf media tv list --status watching
-```
-
-### Completed This Month
-
-View completed items:
-
-```sh
-noteleaf media book list --status finished
-noteleaf media movie list --status watched
-noteleaf media tv list --status watched
-```
-
-### Clear Finished Items
-
-Archive or remove completed media:
-
-```sh
-# Remove watched movies
-noteleaf media movie remove 1 2 3
-
-# Remove finished books
-noteleaf media book remove 4 5 6
-```
-
-## Statistics and Reports
-
-### Reading Statistics
-
-Count books by status:
-
-```sh
-echo "Queued: $(noteleaf media book list --status queued --static | wc -l)"
-echo "Reading: $(noteleaf media book list --status reading --static | wc -l)"
-echo "Finished: $(noteleaf media book list --status finished --static | wc -l)"
-```
-
-### Viewing Habits
-
-Track watch queue size:
-
-```sh
-echo "Movies to watch: $(noteleaf media movie list --status queued --static | wc -l)"
-echo "Shows in progress: $(noteleaf media tv list --status watching --static | wc -l)"
-```

website/docs/examples/notes.md

···
-# Note Examples
-
-Examples of note-taking workflows using Noteleaf.
-
-## Creating Notes
-
-### Create Note from Command Line
-
-```sh
-noteleaf note create "Meeting Notes" "Discussed Q4 roadmap and priorities"
-```
-
-### Create Note with Tags
-
-```sh
-noteleaf note create "API Design Ideas" "REST vs GraphQL considerations" --tags api,design
-```
-
-### Create Note from File
-
-```sh
-noteleaf note create --file notes.md
-```
-
-### Create Note Interactively
-
-Opens your editor for composition:
-
-```sh
-noteleaf note create --interactive
-```
-
-Specify editor:
-
-```sh
-EDITOR=vim noteleaf note create --interactive
-```
-
-### Create Note with Multiple Paragraphs
-
-```sh
-noteleaf note create "Project Retrospective" "
-What went well:
-- Good team collaboration
-- Met all deadlines
-- Quality code reviews
-
-What to improve:
-- Better documentation
-- More automated tests
-- Earlier stakeholder feedback
-"
-```
-
-## Viewing Notes
-
-### List All Notes
-
-Interactive mode:
-
-```sh
-noteleaf note list
-```
-
-Static output:
-
-```sh
-noteleaf note list --static
-```
-
-### Filter by Tags
-
-```sh
-noteleaf note list --tags meeting
-noteleaf note list --tags api,design
-```
-
-### View Archived Notes
-
-```sh
-noteleaf note list --archived
-```
-
-### Read a Note
-
-Display note content:
-
-```sh
-noteleaf note read 1
-```
-
-### Search Notes
-
-```sh
-noteleaf note search "API design"
-noteleaf note search "meeting notes"
-```
-
-## Editing Notes
-
-### Edit Note in Editor
-
-Opens note in your editor:
-
-```sh
-noteleaf note edit 1
-```
-
-With specific editor:
-
-```sh
-EDITOR=nvim noteleaf note edit 1
-```
-
-### Update Note Title
-
-```sh
-noteleaf note update 1 --title "Updated Meeting Notes"
-```
-
-### Add Tags to Note
-
-```sh
-noteleaf note tag 1 --add important,todo
-```
-
-### Remove Tags from Note
-
-```sh
-noteleaf note tag 1 --remove draft
-```
-
-## Organizing Notes
-
-### Archive a Note
-
-```sh
-noteleaf note archive 1
-```
-
-### Unarchive a Note
-
-```sh
-noteleaf note unarchive 1
-```
-
-### Delete a Note
-
-```sh
-noteleaf note remove 1
-```
-
-With confirmation:
-
-```sh
-noteleaf note remove 1 --confirm
-```
-
-## Common Workflows
-
-### Quick Meeting Notes
-
-```sh
-noteleaf note create "Team Standup $(date +%Y-%m-%d)" --interactive --tags meeting,standup
-```
-
-### Project Documentation
-
-```sh
-noteleaf note create "Project Architecture" "$(cat architecture.md)" --tags docs,architecture
-```
-
-### Research Notes
-
-Create research note:
-
-```sh
-noteleaf note create "GraphQL Research" --interactive --tags research,api
-```
-
-List all research notes:
-
-```sh
-noteleaf note list --tags research
-```
-
-### Code Snippets
-
-```sh
-noteleaf note create "Useful Git Commands" "
-# Rebase last 3 commits
-git rebase -i HEAD~3
-
-# Undo last commit
-git reset --soft HEAD~1
-
-# Show files changed in commit
-git show --name-only <commit>
-" --tags git,snippets,reference
-```
-
-### Daily Journal
-
-```sh
-noteleaf note create "Journal $(date +%Y-%m-%d)" --interactive --tags journal
-```
-
-### Ideas and Brainstorming
-
-```sh
-noteleaf note create "Product Ideas" --interactive --tags ideas,product
-```
-
-List all ideas:
-
-```sh
-noteleaf note list --tags ideas
-```
-
-## Exporting Notes
-
-### Export Single Note
-
-```sh
-noteleaf note export 1 --format markdown > note.md
-noteleaf note export 1 --format html > note.html
-```
-
-### Export All Notes
-
-```sh
-noteleaf note export --all --format markdown --output notes/
-```
-
-### Export Notes by Tag
-
-```sh
-noteleaf note export --tags meeting --format markdown --output meetings/
-```
-
-## Advanced Usage
-
-### Template-based Notes
-
-Create a note template file:
-
-```sh
-cat > ~/templates/meeting.md << 'EOF'
-# Meeting: [TITLE]
-Date: [DATE]
-Attendees: [NAMES]
-
-## Agenda
--
-
-## Discussion
--
-
-## Action Items
-- [ ]
-
-## Next Meeting
-Date:
-EOF
-```
-
-Use template:
-
-```sh
-noteleaf note create --file ~/templates/meeting.md
-```
-
-### Linking Notes
-
-Reference other notes in content:
-
-```sh
-noteleaf note create "Implementation Plan" "
-Based on the design in Note #5, we will:
-1. Set up database schema (see Note #12)
-2. Implement API endpoints
-3. Add frontend components
-
-Related: Note #5 (Design), Note #12 (Schema)
-" --tags implementation,plan
-```
-
-### Note Statistics
-
-View note count by tag:
-
-```sh
-noteleaf note list --static | grep -c "tag:meeting"
-```

website/docs/examples/publication.md

···
-# Publication Examples
-
-Examples of publishing notes to leaflet.pub using the AT Protocol integration.
-
-## Overview
-
-The publication system allows you to sync your local notes with leaflet.pub, an AT Protocol-based publishing platform. You can pull drafts from leaflet, publish local notes, and maintain a synchronized writing workflow across platforms.
-
-## Authentication
-
-### Initial Authentication
-
-Authenticate with your BlueSky account:
-
-```sh
-noteleaf pub auth username.bsky.social
-```
-
-This will prompt for your app password interactively.
-
-### Authenticate with Password Flag
-
-Provide credentials directly:
-
-```sh
-noteleaf pub auth username.bsky.social --password "your-app-password"
-```
-
-### Creating an App Password
-
-1. Visit [bsky.app/settings/app-passwords](https://bsky.app/settings/app-passwords)
-2. Create a new app password named "noteleaf"
-3. Use that password (not your main password) for authentication
-
-### Check Authentication Status
-
-```sh
-noteleaf pub status
-```
-
-## Pulling Documents from Leaflet
-
-### Pull All Documents
-
-Fetch all drafts and published documents:
-
-```sh
-noteleaf pub pull
-```
-
-This will:
-- Connect to your leaflet account
-- Fetch all documents in your repository
-- Create new notes for documents not yet synced
-- Update existing notes that have changed
-
-### After Pulling
-
-List the synced notes:
-
-```sh
-noteleaf pub list
-```
-
-View synced notes interactively:
-
-```sh
-noteleaf pub list --interactive
-```
-
-## Publishing Local Notes
-
-### Publish a Note
-
-Create a new document on leaflet from a local note:
-
-```sh
-noteleaf pub post 123
-```
-
-### Publish as Draft
-
-Create as draft instead of publishing immediately:
-
-```sh
-noteleaf pub post 123 --draft
-```
-
-### Preview Before Publishing
-
-See what would be posted without actually posting:
-
-```sh
-noteleaf pub post 123 --preview
-```
-
-### Validate Conversion
-
-Check if markdown conversion will work:
-
-```sh
-noteleaf pub post 123 --validate
-```
-
-## Updating Published Documents
-
-### Update an Existing Document
-
-Update a previously published note:
-
-```sh
-noteleaf pub patch 123
-```
-
-### Preview Update
-
-See what would be updated:
-
-```sh
-noteleaf pub patch 123 --preview
-```
-
-### Validate Update
-
-Check conversion before updating:
-
-```sh
-noteleaf pub patch 123 --validate
-```
-
-## Batch Operations
-
-### Publish Multiple Notes
-
-Create or update multiple documents at once:
-
-```sh
-noteleaf pub push 1 2 3 4 5
-```
-
-This will:
-- Create new documents for notes never published
-- Update existing documents for notes already on leaflet
-
-### Batch Publish as Drafts
-
-```sh
-noteleaf pub push 10 11 12 --draft
-```
-
-## Viewing Publications
-
-### List All Synced Notes
-
-```sh
-noteleaf pub list
-```
-
-Aliases:
-```sh
-noteleaf pub ls
-```
-
-### Filter by Status
-
-Published documents only:
-```sh
-noteleaf pub list --published
-```
-
-Drafts only:
-```sh
-noteleaf pub list --draft
-```
-
-All documents:
-```sh
-noteleaf pub list --all
-```
-
-### Interactive Browser
-
-Browse with TUI interface:
-
-```sh
-noteleaf pub list --interactive
-noteleaf pub list -i
-```
-
-With filters:
-```sh
-noteleaf pub list --published --interactive
-noteleaf pub list --draft -i
-```
-
-## Common Workflows
-
-### Initial Setup and Pull
-
-Set up leaflet integration and pull existing documents:
-
-```sh
-# Authenticate
-noteleaf pub auth username.bsky.social
-
-# Check status
-noteleaf pub status
-
-# Pull all documents
-noteleaf pub pull
-
-# View synced notes
-noteleaf pub list --interactive
-```
-
-### Publishing Workflow
-
-Write locally, then publish to leaflet:
-
-```sh
-# Create a note
-noteleaf note create "My Blog Post" --interactive
-
-# List notes to get ID
-noteleaf note list
-
-# Publish as draft first
-noteleaf pub post 42 --draft
-
-# Review draft on leaflet.pub
-# Make edits locally
-noteleaf note edit 42
-
-# Update the draft
-noteleaf pub patch 42
-
-# When ready, republish without --draft flag
-noteleaf pub post 42
-```
-
-### Sync Workflow
-
-Keep local notes in sync with leaflet:
-
-```sh
-# Pull latest changes from leaflet
-noteleaf pub pull
-
-# Make local edits
-noteleaf note edit 123
-
-# Push changes back
-noteleaf pub patch 123
-
-# Check sync status
-noteleaf pub list --published
-```
-
-### Draft Management
-
-Work with drafts before publishing:
-
-```sh
-# Create drafts
-noteleaf pub post 10 --draft
-noteleaf pub post 11 --draft
-noteleaf pub post 12 --draft
-
-# View all drafts
-noteleaf pub list --draft
-
-# Edit a draft locally
-noteleaf note edit 10
-
-# Update on leaflet
-noteleaf pub patch 10
-
-# Promote draft to published (re-post without --draft)
-noteleaf pub post 10
-```
-
-### Batch Publishing
-
-Publish multiple notes at once:
-
-```sh
-# Create several notes
-noteleaf note create "Post 1" "Content 1"
-noteleaf note create "Post 2" "Content 2"
-noteleaf note create "Post 3" "Content 3"
-
-# Get note IDs
-noteleaf note list --static
-
-# Publish all at once
-noteleaf pub push 50 51 52
-
-# Or as drafts
-noteleaf pub push 50 51 52 --draft
-```
-
-### Review Before Publishing
-
-Always preview and validate before publishing:
-
-```sh
-# Validate markdown conversion
-noteleaf pub post 99 --validate
-
-# Preview the output
-noteleaf pub post 99 --preview
-
-# If everything looks good, publish
-noteleaf pub post 99
-```
-
-### Cross-Platform Editing
-
-Edit on leaflet.pub, sync to local:
-
-```sh
-# Pull changes from leaflet
-noteleaf pub pull
-
-# View what changed
-noteleaf pub list --interactive
-
-# Make additional edits locally
-noteleaf note edit 123
-
-# Push updates back
-noteleaf pub patch 123
-```
-
-### Status Monitoring
-
-Check authentication and publication status:
-
-```sh
-# Check auth status
-noteleaf pub status
-
-# List published documents
-noteleaf pub list --published
-
-# Count publications
-noteleaf pub list --published --static | wc -l
-```
-
-## Troubleshooting
-
-### Re-authenticate
-
-If authentication expires:
-
-```sh
-noteleaf pub auth username.bsky.social
-```
-
-### Check Status
-
-Verify connection:
-
-```sh
-noteleaf pub status
-```
-
-### Force Pull
-
-Re-sync all documents:
-
-```sh
-noteleaf pub pull
-```
-
-### Validate Before Publishing
-
-If publishing fails, validate first:
-
-```sh
-noteleaf pub post 123 --validate
-```
-
-Check for markdown formatting issues that might not convert properly.
-
-## Integration with Notes
-
-### Publishing Flow
-
-```sh
-# Create note locally
-noteleaf note create "Article Title" --interactive
-
-# Add tags for organization
-noteleaf note tag 1 --add published,blog
-
-# Publish to leaflet
-noteleaf pub post 1
-
-# Continue editing locally
-noteleaf note edit 1
-
-# Sync updates
-noteleaf pub patch 1
-```
-
-### Import from Leaflet
-
-```sh
-# Pull from leaflet
-noteleaf pub pull
-
-# View imported notes
-noteleaf pub list
-
-# Edit locally
-noteleaf note edit 123
-
-# Continue working with standard note commands
-noteleaf note read 123
-noteleaf note tag 123 --add imported
-```
-
-## Advanced Usage
-
-### Selective Publishing
-
-Publish only specific notes with a tag:
-
-```sh
-# Tag notes for publication
-noteleaf note tag 10 --add ready-to-publish
-noteleaf note tag 11 --add ready-to-publish
-
-# List tagged notes
-noteleaf note list --tags ready-to-publish
-
-# Publish those notes
-noteleaf pub push 10 11
-```
-
-### Draft Review Cycle
-
-```sh
-# Publish drafts
-noteleaf pub push 1 2 3 --draft
-
-# Review on leaflet.pub in browser
-# Make edits locally based on feedback
-
-# Update drafts
-noteleaf pub push 1 2 3
-
-# When ready, publish (create as non-drafts)
-noteleaf pub post 1
-noteleaf pub post 2
-noteleaf pub post 3
-```
-
-### Publication Archive
-
-Keep track of published work:
-
-```sh
-# Tag published notes
-noteleaf note tag 123 --add published,2024,blog
-
-# List all published notes
-noteleaf note list --tags published
-
-# Archive old publications
-noteleaf note archive 123
-```
-
-## Notes
-
-- Authentication tokens are stored in the configuration file
-- Notes are matched by their leaflet record key (rkey)
-- The `push` command intelligently chooses between `post` and `patch`
-- Draft status is preserved when patching existing documents
-- Use `--preview` and `--validate` flags to test before publishing
-- Pull regularly to stay synced with changes made on leaflet.pub

website/docs/examples/tasks.md

···
-# Task Examples
-
-Examples of common task management workflows using Noteleaf.
-
-## Basic Task Management
-
-### Create a Simple Task
-
-```sh
-noteleaf task add "Buy groceries"
-```
-
-### Create Task with Priority
-
-```sh
-noteleaf task add "Fix critical bug" --priority urgent
-noteleaf task add "Update documentation" --priority low
-```
-
-### Create Task with Project
-
-```sh
-noteleaf task add "Design new homepage" --project website
-noteleaf task add "Refactor auth service" --project backend
-```
-
-### Create Task with Due Date
-
-```sh
-noteleaf task add "Submit report" --due 2024-12-31
-noteleaf task add "Review PRs" --due tomorrow
-```
-
-### Create Task with Tags
-
-```sh
-noteleaf task add "Write blog post" --tags writing,blog
-noteleaf task add "Server maintenance" --tags ops,backend,infra
-```
-
-### Create Task with Context
-
-```sh
-noteleaf task add "Call client" --context phone
-noteleaf task add "Deploy to production" --context office
-```
-
-### Create Task with All Attributes
-
-```sh
-noteleaf task add "Launch marketing campaign" \
-  --project marketing \
-  --priority high \
-  --due 2024-06-15 \
-  --tags campaign,social \
-  --context office
-```
-
-## Viewing Tasks
-
-### List All Tasks
-
-Interactive mode:
-
-```sh
-noteleaf task list
-```
-
-Static output:
-
-```sh
-noteleaf task list --static
-```
-
-### Filter by Status
-
-```sh
-noteleaf task list --status pending
-noteleaf task list --status completed
-```
-
-### Filter by Priority
-
-```sh
-noteleaf task list --priority high
-noteleaf task list --priority urgent
-```
-
-### Filter by Project
-
-```sh
-noteleaf task list --project website
-noteleaf task list --project backend
-```
-
-### Filter by Tags
-
-```sh
-noteleaf task list --tags urgent,bug
-```
-
-### View Task Details
-
-```sh
-noteleaf task view 1
-```
-
-## Updating Tasks
-
-### Mark Task as Done
-
-```sh
-noteleaf task done 1
-```
-
-### Update Task Priority
-
-```sh
-noteleaf task update 1 --priority high
-```
-
-### Update Task Project
-
-```sh
-noteleaf task update 1 --project website
-```
-
-### Add Tags to Task
-
-```sh
-noteleaf task update 1 --add-tags backend,api
-```
-
-### Remove Tags from Task
-
-```sh
-noteleaf task update 1 --remove-tags urgent
-```
-
-### Edit Task Interactively
-
-Opens task in your editor:
-
-```sh
-noteleaf task edit 1
-```
-
-## Time Tracking
-
-### Start Time Tracking
-
-```sh
-noteleaf task start 1
-```
-
-### Stop Time Tracking
-
-```sh
-noteleaf task stop 1
-```
-
-### View Timesheet
-
-All entries:
-
-```sh
-noteleaf task timesheet
-```
-
-Filtered by date:
-
-```sh
-noteleaf task timesheet --from 2024-01-01 --to 2024-01-31
-```
-
-Filtered by project:
-
-```sh
-noteleaf task timesheet --project website
-```
-
-## Project Management
-
-### List All Projects
-
-```sh
-noteleaf task projects
-```
-
-### View Tasks in Project
-
-```sh
-noteleaf task list --project website
-```
-
-## Tag Management
-
-### List All Tags
-
-```sh
-noteleaf task tags
-```
-
-### View Tasks with Tag
-
-```sh
-noteleaf task list --tags urgent
-```
-
-## Context Management
-
-### List All Contexts
-
-```sh
-noteleaf task contexts
-```
-
-### View Tasks in Context
-
-```sh
-noteleaf task list --context office
-```
-
-## Advanced Workflows
-
-### Daily Planning
-
-View today's tasks:
-
-```sh
-noteleaf task list --due today
-```
-
-View overdue tasks:
-
-```sh
-noteleaf task list --due overdue
-```
-
-### Weekly Review
-
-View completed tasks this week:
-
-```sh
-noteleaf task list --status completed --from monday
-```
-
-View pending high-priority tasks:
-
-```sh
-noteleaf task list --status pending --priority high
-```
-
-### Project Focus
-
-List all tasks for a project, sorted by priority:
-
-```sh
-noteleaf task list --project website --sort priority
-```
-
-### Bulk Operations
-
-Mark multiple tasks as done:
-
-```sh
-noteleaf task done 1 2 3 4
-```
-
-Delete multiple tasks:
-
-```sh
-noteleaf task delete 5 6 7
-```
-
-## Task Deletion
-
-### Delete a Task
-
-```sh
-noteleaf task delete 1
-```
-
-### Delete with Confirmation
-
-```sh
-noteleaf task delete 1 --confirm
-```

website/docs/intro.md

···
----
-sidebar_position: 1
----
-
-# Tutorial Intro
-
-Let's discover **Docusaurus in less than 5 minutes**.
-
-## Getting Started
-
-Get started by **creating a new site**.
-
-Or **try Docusaurus immediately** with **[docusaurus.new](https://docusaurus.new)**.
-
-### What you'll need
-
-- [Node.js](https://nodejs.org/en/download/) version 20.0 or above:
-  - When installing Node.js, you are recommended to check all checkboxes related to dependencies.
-
-## Generate a new site
-
-Generate a new Docusaurus site using the **classic template**.
-
-The classic template will automatically be added to your project after you run the command:
-
-```bash
-npm init docusaurus@latest my-website classic
-```
-
-You can type this command into Command Prompt, Powershell, Terminal, or any other integrated terminal of your code editor.
-
-The command also installs all necessary dependencies you need to run Docusaurus.
-
-## Start your site
-
-Run the development server:
-
-```bash
-cd my-website
-npm run start
-```
-
-The `cd` command changes the directory you're working with. In order to work with your newly created Docusaurus site, you'll need to navigate the terminal there.
-
-The `npm run start` command builds your website locally and serves it through a development server, ready for you to view at http://localhost:3000/.
-
-Open `docs/intro.md` (this page) and edit some lines: the site **reloads automatically** and displays your changes.

website/docs/leaflet/_category_.json

···
+{
+    "label": "Leaflet Publishing",
+    "position": 5,
+    "link": {
+        "type": "generated-index",
+        "title": "Leaflet Publishing",
+        "description": "Publish and sync documents with leaflet.pub and the AT Protocol."
+    }
+}

website/docs/leaflet/authentication.md

···
+---
+title: Authentication and Identity
+sidebar_label: Auth & Identity
+description: AT Protocol authentication, security, and session handling.
+sidebar_position: 8
+---
+
+# Authentication and Identity
+
+## AT Protocol Authentication
+
+Noteleaf uses AT Protocol's authentication system:
+
+1. **Handle Resolution**: Your handle (e.g., `username.bsky.social`) is resolved to a DID (Decentralized Identifier)
+2. **Session Creation**: Authenticate with your app password to create a session
+3. **Session Token**: Noteleaf stores the session token for future requests
+4. **Token Refresh**: Sessions are refreshed automatically when they expire
+
+## Security Considerations
+
+**Use app passwords**: Never use your main BlueSky password with third-party tools. App passwords can be revoked without affecting your account.
+
+**Token storage**: Session tokens are stored locally in the Noteleaf database. Protect your database file.
+
+**Revocation**: If compromised, revoke the app password at [bsky.app/settings/app-passwords](https://bsky.app/settings/app-passwords).
+
+## Session Management
+
+**Check status**:
+
+```sh
+noteleaf pub status
+```
+
+**Re-authenticate**:
+
+```sh
+noteleaf pub auth
+```
+
+Sessions typically last 2-4 hours before requiring refresh. Noteleaf handles refresh automatically, but if authentication fails, run `pub auth` again.

website/docs/leaflet/examples.md

···
+---
+title: Publishing Examples
+sidebar_label: Examples
+description: End-to-end examples for posting, drafting, and syncing.
+sidebar_position: 6
+---
+
+# Publishing Examples
+
+## Publishing a Blog Post
+
+**Write the post locally**:
+
+```sh
+noteleaf note create "Understanding AT Protocol" --editor
+```
+
+Write in markdown, save, and close editor.
+
+**Preview the conversion**:
+
+```sh
+noteleaf pub post <note-id> --preview
+```
+
+Review the output to ensure formatting is correct.
+
+**Publish**:
+
+```sh
+noteleaf pub post <note-id>
+```
+
+**Update later**:
+
+```sh
+noteleaf note edit <note-id>
+# Make changes
+noteleaf pub patch <note-id>
+```
+
+## Draft Workflow
+
+**Create draft**:
+
+```sh
+noteleaf note create "Work in Progress" --editor
+noteleaf pub post <note-id> --draft
+```
+
+**Iterate locally**:
+
+```sh
+noteleaf note edit <note-id>
+noteleaf pub patch <note-id>  # Updates draft
+```
+
+**Publish when ready**: Use leaflet.pub web interface to change draft to published status (CLI command coming in future versions).
+
+## Syncing Existing Content
+
+**Pull all leaflet documents**:
+
+```sh
+noteleaf pub pull
+```
+
+**List synced documents**:
+
+```sh
+noteleaf pub list
+```
+
+**Read a synced document**:
+
+```sh
+noteleaf pub read <note-id>
+```
+
+**Edit locally and push updates**:
+
+```sh
+noteleaf note edit <note-id>
+noteleaf pub patch <note-id>
+```

website/docs/leaflet/future.md

···
+---
+title: Leaflet Future Features
+sidebar_label: Future
+description: Upcoming enhancements planned for the leaflet integration.
+sidebar_position: 10
+---
+
+# Leaflet Future Features
+
+Planned improvements to leaflet.pub integration:
+
+**Multiple Publications**: Create and manage separate publications for different topics
+
+**Image Upload**: Automatically upload images to blob storage and embed in documents
+
+**Status Management**: Publish drafts and unpublish documents from CLI
+
+**Metadata Editing**: Update document titles, summaries, and tags
+
+**Backlink Support**: Parse and resolve cross-references between documents
+
+**Collaborative Editing**: Pull and merge changes from multiple devices
+
+**Offline Mode**: Queue posts and patches for later upload
+
+For the latest roadmap, check the [GitHub repository](https://github.com/stormlightlabs/noteleaf).

website/docs/leaflet/getting-started.md

···
+---
+title: Getting Started with Leaflet
+sidebar_label: Getting Started
+description: Prerequisites, app passwords, and authentication commands.
+sidebar_position: 2
+---
+
+# Getting Started with Leaflet
+
+## Prerequisites
+
+- Noteleaf installed and configured
+- A BlueSky & [Leaflet](https://leaflet.pub) account (create at [bsky.app](https://bsky.app))
+- App password for authentication
+
+## Creating an App Password
+
+For security, Noteleaf uses app passwords instead of your main BlueSky password:
+
+1. Go to [bsky.app/settings/app-passwords](https://bsky.app/settings/app-passwords)
+2. Click "Add App Password"
+3. Name it "noteleaf" or similar
+4. Copy the generated password (you won't see it again)
+
+### Authentication
+
+Authenticate with your BlueSky handle and app password:
+
+```sh
+noteleaf pub auth username.bsky.social
+```
+
+You'll be prompted for the app password. Alternatively, provide it via flag:
+
+```sh
+noteleaf pub auth username.bsky.social --password <app-password>
+```
+
+**Re-authentication**: If your session expires, run `pub auth` again. Noteleaf remembers your last authenticated handle, so you can just run:
+
+```sh
+noteleaf pub auth
+```
+
+### Check Authentication Status
+
+Verify you're authenticated:
+
+```sh
+noteleaf pub status
+```
+
+Shows your handle and session state.

website/docs/leaflet/intro.md

···
+---
+title: Leaflet.pub Introduction
+sidebar_label: Introduction
+description: Understand leaflet.pub and how Noteleaf integrates with it.
+sidebar_position: 1
+---
+
+# Leaflet.pub Introduction
+
+## What is Leaflet.pub?
+
+[Leaflet.pub](https://leaflet.pub) is a decentralized publishing platform built on the AT Protocol (the same protocol that powers BlueSky). It allows you to publish long-form content as structured documents while maintaining ownership and control of your data through decentralized identity.
+
+## AT Protocol and Decentralized Publishing
+
+AT Protocol provides:
+
+**Portable Identity**: Your identity (DID) is separate from any single service. You own your content and can move it between providers.
+
+**Verifiable Data**: All documents are content-addressed and cryptographically signed, ensuring authenticity and preventing tampering.
+
+**Interoperability**: Content published to leaflet.pub can be discovered and consumed by any AT Protocol-compatible client.
+
+**Decentralized Storage**: Data is stored in personal data repositories (PDSs) under your control, not locked in a proprietary platform.
+
+## How Noteleaf Integrates with Leaflet
+
+Noteleaf can act as a leaflet.pub client, allowing you to:
+
+1. **Authenticate** with your BlueSky/AT Protocol identity
+2. **Pull** existing documents from leaflet.pub into local notes
+3. **Publish** local notes as new leaflet documents
+4. **Update** previously published documents with changes
+5. **Manage** drafts and published content from the command line
+
+This integration lets you write locally in markdown, manage content alongside tasks and research notes, and publish to a decentralized platform when ready.

website/docs/leaflet/listing.md

···
+---
+title: Listing and Reading Publications
+sidebar_label: Listing & Reading
+description: Browse leaflet-backed notes and read content locally.
+sidebar_position: 7
+---
+
+# Listing and Reading Publications
+
+## List Published Documents
+
+**All leaflet-synced notes**:
+
+```sh
+noteleaf pub list
+```
+
+**Only published documents**:
+
+```sh
+noteleaf pub list --published
+```
+
+**Only drafts**:
+
+```sh
+noteleaf pub list --draft
+```
+
+**Interactive browser**:
+
+```sh
+noteleaf pub list --interactive
+```
+
+Navigate with arrow keys, press Enter to read, `q` to quit.
+
+## Reading a Publication
+
+**Read specific document**:
+
+```sh
+noteleaf pub read 123
+```
+
+The identifier can be:
+
+- Note ID (e.g., `123`)
+- Leaflet record key (rkey, e.g., `3jxx...`)
+
+**Read newest publication**:
+
+```sh
+noteleaf pub read
+```
+
+Omitting the identifier shows the most recently published document.

website/docs/leaflet/publications.md

···
+---
+title: Leaflet Publications
+sidebar_label: Publications
+description: How publications work and how Noteleaf interacts with them.
+sidebar_position: 3
+---
+
+# Leaflet Publications
+
+## What is a Publication?
+
+In leaflet.pub, a publication is a collection of documents. While Noteleaf doesn't support management commands, documents you create are associated with your default publication.
+
+Future versions may support:
+
+- Switching between publications

website/docs/leaflet/rich-text.md

···
+---
+title: Leaflet Rich Text and Blocks
+sidebar_label: Rich Text
+description: How markdown maps to leaflet blocks and formatting.
+sidebar_position: 5
+---
+
+# Leaflet Rich Text and Blocks
+
+## Document Structure
+
+Leaflet documents consist of blocks—discrete content units:
+
+**Text Blocks**: Paragraphs of formatted text
+**Header Blocks**: Section titles (level 1-6)
+**Code Blocks**: Syntax-highlighted code with language annotation
+**Quote Blocks**: Blockquotes for citations
+**List Blocks**: Ordered or unordered lists
+**Rule Blocks**: Horizontal rules for visual separation
+
+## Text Formatting
+
+Text within blocks can have inline formatting called facets:
+
+**Bold**: `**bold text**` → Bold facet
+**Italic**: `*italic text*` → Italic facet
+**Code**: `` `inline code` `` → Code facet
+**Links**: `[text](url)` → Link facet with URL
+**Strikethrough**: `~~struck~~` → Strikethrough facet
+
+Multiple formats can be combined:
+
+```markdown
+**bold and *italic* text with [a link](https://example.com)**
+```
+
+## Code Blocks
+
+Code blocks preserve language information for syntax highlighting:
+
+````markdown
+```python
+def hello():
+    print("Hello, leaflet!")
+```
+````
+
+Converts to a code block with language="python".
+
+Supported languages: Any language identifier is preserved, but rendering depends on leaflet.pub's syntax highlighter support.
+
+## Blockquotes
+
+Markdown blockquotes become quote blocks:
+
+```markdown
+> This is a quote from another source.
+> It can span multiple lines.
+```
+
+Nested blockquotes are flattened (leaflet doesn't support nesting).
+
+## Lists
+
+Both ordered and unordered lists are supported:
+
+```markdown
+- Unordered item 1
+- Unordered item 2
+  - Nested item
+
+1. Ordered item 1
+2. Ordered item 2
+   1. Nested ordered item
+```
+
+Nesting is preserved up to leaflet's limits.
+
+## Horizontal Rules
+
+Markdown horizontal rules become rule blocks:
+
+```markdown
+---
+```
+
+Use for section breaks.
+
+## Images and Media
+
+**Current status**: Image support is not yet implemented in the Noteleaf-to-leaflet converter.
+
+**Future plans**: Images will be uploaded to blob storage and embedded in documents with image blocks.
+
+**Workaround**: For now, images in markdown are either skipped or converted to links.

website/docs/leaflet/workflow.md

···
+---
+title: Publishing Workflow
+sidebar_label: Workflow
+description: Post, patch, drafts, pulling, and syncing documents.
+sidebar_position: 4
+---
+
+# Publishing Workflow
+
+## Converting Notes to Leaflet Documents
+
+Noteleaf converts markdown notes to leaflet's rich text block format:
+
+**Supported Markdown Features**:
+
+- Headers (`#`, `##`, `###`, etc.)
+- Paragraphs
+- Bold (`**bold**`)
+- Italic (`*italic*`)
+- Code (`inline code`)
+- Strikethrough (`~~text~~`)
+- Links (`[text](url)`)
+- Code blocks (` ```language ... ``` `)
+- Blockquotes (`> quote`)
+- Lists (ordered and unordered)
+- Horizontal rules (`---`)
+
+**Conversion Process**:
+
+1. Parse markdown into AST (abstract syntax tree)
+2. Convert AST nodes to leaflet block records
+3. Process text formatting into facets
+4. Validate document structure
+5. Upload to leaflet.pub via AT Protocol
+
+## Creating a New Document
+
+Publish a local note as a new leaflet document:
+
+```sh
+noteleaf pub post 123
+```
+
+This:
+
+1. Converts the note to leaflet format
+2. Creates a new document on leaflet.pub
+3. Links the note to the document (stores the rkey)
+4. Marks the note as published
+
+**Create as draft**:
+
+```sh
+noteleaf pub post 123 --draft
+```
+
+Drafts are saved to leaflet but not publicly visible until you publish them.
+
+**Preview before posting**:
+
+```sh
+noteleaf pub post 123 --preview
+```
+
+Shows what the document will look like without actually posting.
+
+**Validate conversion**:
+
+```sh
+noteleaf pub post 123 --validate
+```
+
+Checks if the markdown converts correctly to leaflet format without posting.
+
+**Save to file**:
+
+```sh
+noteleaf pub post 123 --preview --output document.json
+noteleaf pub post 123 --preview --output document.txt --plaintext
+```
+
+## Updating Published Documents
+
+Update an existing leaflet document from a local note:
+
+```sh
+noteleaf pub patch 123
+```
+
+Requirements:
+
+- Note must have been previously posted or pulled from leaflet
+- Note must have a leaflet record key (rkey) in the database
+
+**Preserve draft/published status**: The `patch` command maintains the document's current status. If it's published, it stays published. If it's a draft, it stays a draft.
+
+**Preview changes**:
+
+```sh
+noteleaf pub patch 123 --preview
+```
+
+**Validate before patching**:
+
+```sh
+noteleaf pub patch 123 --validate
+```
+
+## Managing Drafts
+
+**Create as draft**:
+
+```sh
+noteleaf pub post 123 --draft
+```
+
+**Update draft**:
+
+```sh
+noteleaf pub patch 123
+```
+
+**List drafts**:
+
+```sh
+noteleaf pub list --draft
+```
+
+**Publish a draft**: Edit the draft on leaflet.pub or use the API to change status (command support coming in future versions).
+
+## Pulling Documents from Leaflet
+
+Sync leaflet documents to local notes:
+
+```sh
+noteleaf pub pull
+```
+
+This:
+
+1. Authenticates with leaflet.pub
+2. Fetches all documents in your repository
+3. Creates new notes for documents not yet synced
+4. Updates existing notes that have changed
+
+**Matching logic**: Notes are matched to leaflet documents by their record key (rkey) stored in the database.
+If a document doesn't have a corresponding note, a new one is created. If it does, the note is updated only if the content has changed (using CID for change detection).

website/docs/manual/_category_.json

···
-{
-    "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
-

website/docs/media/_category_.json

···
+{
+    "label": "Media",
+    "position": 5,
+    "link": {
+        "type": "generated-index",
+        "title": "Media Tracking",
+        "description": "Track books, movies, and TV shows without leaving the terminal."
+    }
+}

website/docs/media/books.md

···
+---
+title: Books
+sidebar_label: Books
+description: Build and maintain your reading list with Open Library metadata.
+sidebar_position: 2
+---
+
+# Books
+
+The book workflow revolves around Open Library search results. Each command lives under `noteleaf media book`.
+
+## Add Books
+
+Search Open Library and pick a result:
+
+```sh
+noteleaf media book add "Project Hail Mary"
+```
+
+Flags:
+
+- `-i, --interactive`: open the TUI browser (currently shows your local list—useful for triage).
+- Plain mode prints the top five matches inline and prompts for a numeric selection.
+
+Behind the scenes Noteleaf records the title, authors, edition details, and any subjects returned by the API. New entries start in the `queued` status.
+
+## Manage the Reading List
+
+List and filter:
+
+```sh
+# Everything
+noteleaf media book list --all
+
+# Only active reads
+noteleaf media book list --reading
+
+# Completed books
+noteleaf media book list --finished
+```
+
+Each line shows the ID, title, author, status, progress percentage, and any captured metadata (publishers, edition counts, etc.).
+
+Remove items you no longer care about:
+
+```sh
+noteleaf media book remove 42
+```
+
+## Track Progress
+
+You can explicitly set the status:
+
+```sh
+noteleaf media book reading 7
+noteleaf media book finished 7
+noteleaf media book update 7 queued
+```
+
+But the fastest way is to update the percentage:
+
+```sh
+noteleaf media book progress 7 45   # Moves status to reading and records start time
+noteleaf media book progress 7 100  # Marks finished and records completion time
+```
+
+Logic applied automatically:
+
+- `0%` → resets to `queued` and clears the “started” timestamp.
+- `1‑99%` → flips to `reading` (start time captured).
+- `100%` → marks `finished`, sets end time, and locks progress at 100%.
+
+## Reading Lists and Search
+
+Common workflows:
+
+- **Focus view**: `noteleaf media book list --reading | fzf` to pick the next session book.
+- **Backlog grooming**: `noteleaf media book list --queued` to prune items before they go stale.
+- **Author sprint**: pipe the list to `rg` to filter by author (`noteleaf media book list --all | rg "Le Guin"`).
+
+The TUI (`noteleaf media book add -i` or `noteleaf media book list` with the `--interactive` switch) supports `/` to search titles/authors/notes live and `v` for a detailed preview with timestamps.
+
+## Metadata and Notes
+
+Each record stores:
+
+- Title & authors (comma separated when multiple).
+- Edition count, publishers, subject tags, or cover IDs exposed as inline notes.
+- Added/started/finished timestamps.
+- Optional page count (if Open Library exposes it).
+
+Use those IDs anywhere else (tasks or notes). Example note snippet:
+
+```markdown
+## Reading Log
+- 2024-02-01 → Started book #7 ("Project Hail Mary")
+- 2024-02-05 → Captured ideas in note #128 linked back to the book.
+```
+
+Because media lives in the same database as tasks and notes, full-text search will surface those references instantly.

website/docs/media/movies.md

···
+---
+title: Movies
+sidebar_label: Movies
+description: Keep track of your movie queue with Rotten Tomatoes metadata.
+sidebar_position: 3
+---
+
+# Movies
+
+Movie commands hang off `noteleaf media movie`. Results use Rotten Tomatoes search so you get consistent titles plus critic scores.
+
+## Add Movies
+
+```sh
+noteleaf media movie add "The Matrix"
+```
+
+What happens:
+
+1. The CLI fetches the first five Rotten Tomatoes matches.
+2. You select the right one by number.
+3. The chosen movie is inserted into the local queue with status `queued`.
+
+The `-i/--interactive` flag is reserved for a future selector; currently the inline prompt is the quickest path.
+
+## List and Filter
+
+```sh
+# Default: queued items only
+noteleaf media movie list
+
+# Include everything
+noteleaf media movie list --all
+
+# Review history
+noteleaf media movie list --watched
+```
+
+Each entry shows:
+
+- `ID` and title.
+- Release year (if Rotten Tomatoes provided one).
+- Status (`queued` or `watched`).
+- Critic score snippet (stored inside the Notes column).
+- Watched timestamp for completed items.
+
+## Mark Movies as Watched
+
+```sh
+noteleaf media movie watched 12
+```
+
+The command sets the status to `watched` and records `watched_at` using the current timestamp. Removing an item uses the same ID:
+
+```sh
+noteleaf media movie remove 12
+```
+
+Use removal for titles you abandoned or added by mistake—the CLI deletes the database entry so your queue stays focused.
+
+## Metadata Cheat Sheet
+
+- **Notes field**: includes critic score, whether Rotten Tomatoes marked it “Certified Fresh,” and the canonical URL.
+- **Rating column**: reserved for future personal ratings; right now it mirrors the upstream critic context.
+- **Timestamps**: `added` when you saved it, `watched` when you complete it.
+
+To keep a running diary, drop the IDs into a note:
+
+```markdown
+### Queue Ideas
+- Movie #31 → Watch before sequel comes out
+- Movie #12 → Pair with article #5 for cyberpunk research
+```
+
+This keeps everything searchable without having to leave the terminal.

website/docs/media/organization.md

···
+---
+title: Media Organization
+sidebar_label: Organization
+description: Keep queues manageable with filters, reviews, and note links.
+sidebar_position: 5
+---
+
+# Media Organization
+
+Media entries share the same database as tasks and notes, so you can cross-reference everything. This page outlines the practical workflows for keeping large queues in check.
+
+## Tags and Categories
+
+Dedicated media tags have not shipped yet. Until they do:
+
+- Use the free-form `Notes` column (populated automatically from Open Library or Rotten Tomatoes) to stash keywords such as “Hugo shortlist” or “Documentary”.
+- When you need stricter structure, create a note that tracks an ad-hoc category and reference media IDs inside it:
+
+```markdown
+## Cozy backlog
+- Book #11 – comfort reread
+- Movie #25 – rainy-day pick
+```
+
+Full-text search (`noteleaf note list` → `/` and search) will surface the note instantly, and the numeric IDs jump you right back into the media commands.
+
+## Custom Lists
+
+You already get status-based filters out of the box:
+
+```sh
+noteleaf media book list --reading
+noteleaf media movie list --watched
+noteleaf media tv list --all | rg "FX"   # filter with ripgrep
+```
+
+For more bespoke dashboards:
+
+1. Use `noteleaf status` to grab the SQLite path.
+2. Query it with tools like `sqlite-utils` or `datasette` to build spreadsheets or dashboards.
+3. Export subsets via `sqlite3 noteleaf.db "SELECT * FROM books WHERE status='reading'" > reading.csv`.
+
+That approach keeps the CLI fast while still letting you slice the data any way you need.
+
+## Ratings and Reviews
+
+The database schema already includes a `rating` column for every media type. Rotten Tomatoes/Open Library populate it with critic hints for now; personal star ratings will become editable in a future release.
+
+Until then, keep reviews as regular notes:
+
+```sh
+noteleaf note create "Thoughts on Book #7"
+```
+
+Inside the note, link back to the record (`Book #7`, `Movie #18`, etc.) so searches tie everything together. Because notes live on disk you can also version-control your reviews.
+
+## Linking Media to Notes
+
+There is no special “link” command yet, but the following pattern works well:
+
+1. Create a dedicated note per book/movie/show (or per collection).
+2. Add a heading with the media ID and paste the generated markdown path from `noteleaf article view` or the queue list.
+3. Optionally embed checklists or quotes gathered while reading/watching.
+
+Example snippet:
+
+```markdown
+### Book #7 — Project Hail Mary
+- Status: reading (45%)
+- Tasks: todo #128 covers the experiment described in chapter 12
+- Next action: finish Part II before Friday
+```
+
+Because tasks, notes, and media share the same SQLite file, future automation can join across them without migrations. When official linking lands it will reuse these IDs, so the prep work you do now keeps paying off.

website/docs/media/overview.md

···
+---
+title: Media Overview
+sidebar_label: Overview
+description: Manage reading lists and watch queues from the CLI.
+sidebar_position: 1
+---
+
+# Media Tracking Overview
+
+Noteleaf keeps book, movie, and TV data next to your tasks and notes so you do not need a separate “watch list” app.
+All media commands hang off a single entry point:
+
+```sh
+noteleaf media <book|movie|tv> <subcommand>
+```
+
+- **Books** pull metadata from the Open Library API.
+- **Movies/TV** scrape Rotten Tomatoes search results to capture critic scores and canonical titles.
+- Everything is stored in the local SQLite database located in your data directory (`~/.local/share/noteleaf` on Linux, `~/Library/Application Support/noteleaf` on macOS, `%LOCALAPPDATA%\noteleaf` on Windows).
+
+## Lifecycle Statuses
+
+| Type   | Statuses                                   | Notes                                                                                             |
+| ------ | ------------------------------------------ | ------------------------------------------------------------------------------------------------- |
+| Books  | `queued`, `reading`, `finished`, `removed` | Progress updates automatically bump status (0% → `queued`, 1-99% → `reading`, 100% → `finished`). |
+| Movies | `queued`, `watched`, `removed`             | Marking as watched stores the completion timestamp.                                               |
+| TV     | `queued`, `watching`, `watched`, `removed` | Watching/watched commands also record the last watched time.                                      |
+
+Statuses control list filtering and show up beside each item in the TUI.
+
+## Metadata That Gets Saved
+
+- **Books**: title, authors, Open Library notes (editions, publishers, subjects), started/finished timestamps, progress percentage.
+- **Movies**: release year when available, Rotten Tomatoes critic score details inside the notes field, watched timestamp.
+- **TV**: show title plus critic score details, optional season/episode numbers, last watched timestamp.
+
+You can safely edit the generated markdown/notes in your favorite editor—the records keep pointing to the updated files.
+
+## Interactive vs Static Workflows
+
+All `list` commands default to a simple textual table. For books you can pass `-i/--interactive` to open the Bubble Tea list browser (TV and movie interactive selectors are planned). Inside the list view:
+
+- `j/k` or arrow keys move between entries.
+- `/` starts search across titles, authors, and metadata.
+- `v` opens a focused preview.
+- `?` shows all shortcuts.
+
+If you prefer scripts, combine the static lists with tools like `rg` or `jq`.
+
+## Storage Layout
+
+Media records live in the SQLite database (`noteleaf.db`). Binary assets are not downloaded; the metadata stores canonical URLs so you can jump back to the source at any time.
+Use `noteleaf status` to see the exact paths for your database, data directory, and configuration file.

website/docs/media/tv.md

···
+---
+title: TV Shows
+sidebar_label: TV Shows
+description: Track long-form series with simple queue management.
+sidebar_position: 4
+---
+
+# TV Shows
+
+TV commands live under `noteleaf media tv`. Like movies, they use Rotten Tomatoes search so you can trust the spelling and canonical links.
+
+## Add Shows
+
+```sh
+noteleaf media tv add "Breaking Bad"
+```
+
+- Inline mode shows up to five matches and asks you to choose.
+- `-i/--interactive` is wired up for the future list selector.
+
+Every new show starts as `queued`.
+
+## List the Queue
+
+```sh
+noteleaf media tv list                 # queued shows
+noteleaf media tv list --watching      # in-progress series
+noteleaf media tv list --watched       # finished shows
+noteleaf media tv list --all           # everything
+```
+
+Output includes the ID, title, optional season/episode numbers (once those fields are set), status, critic-score snippet, and timestamps.
+
+## Update Status
+
+Use semantic verbs instead of editing the status manually:
+
+```sh
+noteleaf media tv watching 8   # Moved to “currently watching”
+noteleaf media tv watched 8    # Mark completed
+noteleaf media tv remove 8     # Drop from the queue entirely
+```
+
+Each transition records `last_watched` so you know when you left off. Future releases will expose explicit season/episode commands; until then store quick reminders in a linked note:
+
+```markdown
+### TV checklist
+- TV #8 — resume Season 3 Episode 5
+- TV #15 — waiting for new season announcement
+```
+
+## Organization Tips
+
+- Use `noteleaf media tv list --watching | fzf` to pick tonight’s episode.
+- Pipe `--all` into `rg "HBO"` to filter on the metadata snippet that contains the network/URL.
+- Include `TV #ID` references in your weekly review note so you can jump back with a single ID lookup.
+
+## What Gets Stored
+
+- Rotten Tomatoes critic info plus canonical URL (inside the Notes column).
+- Optional season/episode integers for future episode tracking (already part of the schema).
+- Added timestamps and “last watched” timestamps.
+
+Because shows can last months, keeping the queue short (just what you plan to watch soon) makes the `list` output far easier to scan.

website/docs/notes/_category_.json

···
+{
+    "label": "Notes",
+    "position": 4,
+    "link": {
+        "type": "generated-index",
+        "title": "Notes",
+        "description": "Everything about Noteleaf's markdown knowledge base."
+    }
+}

website/docs/notes/advanced.md

···
+---
+title: Advanced Note Features
+sidebar_label: Advanced
+description: Search, exports, backlinks, and automation tips.
+sidebar_position: 5
+---
+
+# Advanced Note Features
+
+## Full-Text Search
+
+While not exposed as a dedicated command, you can search note content using the database:
+
+**Search with grep** (searches file content):
+
+```sh
+grep -r "search term" ~/.local/share/noteleaf/notes/
+```
+
+**Search titles and metadata**:
+
+```sh
+noteleaf note list --static | grep "keyword"
+```
+
+Future versions may include built-in full-text search with relevance ranking.
+
+## Note Exports
+
+Export notes to different formats using standard markdown tools:
+
+**Convert to HTML with pandoc**:
+
+```sh
+noteleaf note view 1 --format=raw | pandoc -o output.html
+```
+
+**Convert to PDF**:
+
+```sh
+noteleaf note view 1 --format=raw | pandoc -o output.pdf
+```
+
+**Batch export all notes**:
+
+```sh
+for note in ~/.local/share/noteleaf/notes/*.md; do
+  pandoc "$note" -o "${note%.md}.html"
+done
+```
+
+## Backlinks and References
+
+Manually create backlinks between notes using markdown links:
+
+```markdown
+See also: [[Research on Authentication]] for background
+Related: [[API Design Principles]]
+```
+
+While Noteleaf doesn't automatically parse or display backlinks yet, this syntax prepares notes for future backlink support and works with tools like Obsidian if you point it at the notes directory.

website/docs/notes/basics.md

···
+---
+title: Note Basics
+sidebar_label: Basics
+description: Creating notes, metadata, and storage model.
+sidebar_position: 2
+---
+
+# Note Basics
+
+## Creation
+
+**Quick note from command line**:
+
+```sh
+noteleaf note create "Meeting Notes" "Discussed Q4 roadmap and hiring plans"
+```
+
+**Interactive creation** (opens editor):
+
+```sh
+noteleaf note create --interactive
+```
+
+**From existing file**:
+
+```sh
+noteleaf note create --file ~/Documents/draft.md
+```
+
+**Create and immediately edit**:
+
+```sh
+noteleaf note create "Research Notes" --editor
+```
+
+## Structure
+
+Notes consist of:
+
+**Title**: Short descriptor shown in lists and searches. Can be updated later.
+
+**Content**: Full markdown text. Supports all standard markdown features including code blocks, lists, tables, and links.
+
+**Tags**: Categorization labels for organizing and filtering notes. Multiple tags per note.
+
+**Dates**: Creation and modification timestamps tracked automatically.
+
+**File Path**: Location of the markdown file on disk, managed by Noteleaf.
+
+## Storage
+
+**File Location**: Notes are stored as individual `.md` files in your notes directory (typically `~/.local/share/noteleaf/notes` or `~/Library/Application Support/noteleaf/notes`).
+
+**Naming**: Files are named with a UUID to ensure uniqueness. The title is stored in the database, not the filename.
+
+**Portability**: Since notes are plain markdown, you can read them with any text editor or markdown viewer.
+The database provides additional functionality like tagging and search, but the files remain standalone.

website/docs/notes/best-practices.md

···
+---
+title: Note Tips and Best Practices
+sidebar_label: Best Practices
+description: Guidelines for keeping notes useful over time.
+sidebar_position: 8
+---
+
+# Note Tips and Best Practices
+
+**Write in plain language**: Notes are for your future self. Avoid jargon you might forget.
+
+**Tag consistently**: Establish a tagging taxonomy early and stick to it. Review tags periodically with `noteleaf note tags`.
+
+**Link liberally**: Reference related notes, tasks, and articles. Future features will leverage these connections.
+
+**Short, focused notes**: Better to have many small notes than few giant ones. Easier to link and reuse.
+
+**Regular review**: Schedule time to review notes, add tags, create links, and archive outdated content.
+
+**Edit immediately**: If you notice incomplete or unclear notes, edit them now. Stale notes lose value.
+
+**Use your editor**: Configure your favorite editor with markdown plugins for better syntax highlighting and live preview.
+
+**Backup regularly**: While notes are files, backup both the notes directory and the database to preserve metadata.
+
+**Experiment with formats**: Try different note structures (journal, zettelkasten, topic-based) to find what works for you.
+
+For CLI command reference, run `noteleaf note --help` or open the contextual help inside the TUI.

website/docs/notes/markdown.md

···
+---
+title: Markdown Support
+sidebar_label: Markdown
+description: Reference for GitHub-Flavored Markdown features.
+sidebar_position: 6
+---
+
+# Markdown Support
+
+Noteleaf notes support full GitHub-Flavored Markdown:
+
+## Headers
+
+```markdown
+# Level 1
+## Level 2
+### Level 3
+```
+
+## Text Formatting
+
+```markdown
+**bold**
+*italic*
+***bold and italic***
+~~strikethrough~~
+`inline code`
+```
+
+## Lists
+
+```markdown
+- Unordered item
+- Another item
+  - Nested item
+
+1. Ordered item
+2. Second item
+   1. Nested ordered
+```
+
+## Task Lists
+
+```markdown
+- [x] Completed task
+- [ ] Pending task
+- [ ] Another pending
+```
+
+## Links
+
+```markdown
+[Link text](https://example.com)
+[Reference link][ref]
+
+[ref]: https://example.com
+```
+
+## Images
+
+```markdown
+![Alt text](path/to/image.png)
+![Remote image](https://example.com/image.png)
+```
+
+## Code Blocks
+
+````markdown
+```python
+def hello():
+    print("Hello, world!")
+```
+
+```javascript
+const greet = () => console.log("Hello!");
+```
+````
+
+## Tables
+
+```markdown
+| Header 1 | Header 2 |
+|----------|----------|
+| Cell 1   | Cell 2   |
+| Cell 3   | Cell 4   |
+```
+
+## Blockquotes
+
+```markdown
+> This is a quote
+> spanning multiple lines
+>
+> With multiple paragraphs
+```
+
+## Horizontal Rules
+
+```markdown
+---
+***
+___
+```

website/docs/notes/operations.md

···
+---
+title: Note Operations
+sidebar_label: Operations
+description: List, read, edit, and delete notes from the CLI.
+sidebar_position: 3
+---
+
+# Note Operations
+
+### Listing Notes
+
+**Interactive TUI** (default):
+```sh
+noteleaf note list
+```
+
+Navigate with arrow keys, press Enter to read, `e` to edit, `q` to quit.
+
+**Static list**:
+```sh
+noteleaf note list --static
+```
+
+**Filter by tags**:
+```sh
+noteleaf note list --tags research,technical
+```
+
+**Show archived notes**:
+```sh
+noteleaf note list --archived
+```
+
+### Reading Notes
+
+View note content with formatted rendering:
+
+```sh
+noteleaf note read 1
+```
+
+Aliases: `noteleaf note view 1`
+
+The viewer renders markdown with syntax highlighting for code blocks, proper formatting for headers and lists, and displays metadata (title, tags, dates).
+
+### Editing Notes
+
+Open note in your configured editor:
+
+```sh
+noteleaf note edit 1
+```
+
+Noteleaf uses the editor specified in your configuration or the `$EDITOR` environment variable. Common choices: `vim`, `nvim`, `nano`, `code`, `emacs`.
+
+**Configure editor**:
+```sh
+noteleaf config set editor nvim
+```
+
+Changes are saved automatically when you close the editor. The modification timestamp updates to track when notes were last changed.
+
+### Deleting Notes
+
+Remove a note permanently:
+
+```sh
+noteleaf note remove 1
+```
+
+Aliases: `rm`, `delete`, `del`
+
+This deletes both the markdown file and database metadata. You'll be prompted for confirmation. This operation cannot be undone, so consider archiving instead if you might need the note later.

website/docs/notes/organization.md

···
+---
+title: Note Organization
+sidebar_label: Organization
+description: Tagging, linking, and template workflows for notes.
+sidebar_position: 4
+---
+
+# Note Organization
+
+## Tagging
+
+Tags provide flexible categorization without hierarchical constraints.
+
+**Add tags during creation**:
+
+```sh
+noteleaf note create "API Design" --tags architecture,reference
+```
+
+**Add tags to existing note**:
+
+```sh
+noteleaf note update 1 --add-tag reference
+```
+
+**Remove tags**:
+
+```sh
+noteleaf note update 1 --remove-tag draft
+```
+
+**List all tags**:
+
+```sh
+noteleaf note tags
+```
+
+Shows each tag with the count of notes using it.
+
+**Tag naming conventions**: Use lowercase, hyphens for compound tags. Examples: `research`, `meeting-notes`, `how-to`, `reference`, `technical`, `personal`.
+
+## Linking
+
+While not a first-class feature in the current UI, notes can reference tasks by ID or description:
+
+```markdown
+# Implementation Plan
+
+Related task: #42 (Deploy authentication service)
+
+## Next Steps
+- Complete testing (task #43)
+- Write documentation (task #44)
+```
+
+Future versions may support automatic linking between notes and tasks in the database.
+
+## Templates
+
+Create reusable note structures using shell functions or scripts:
+
+**In ~/.bashrc or ~/.zshrc**:
+
+```sh
+meeting_note() {
+  local title="Meeting: $1"
+  local date=$(date +%Y-%m-%d)
+  local content="# $title
+
+**Date**: $date
+
+## Attendees
+-
+
+## Agenda
+-
+
+## Discussion
+-
+
+## Action Items
+- [ ]
+
+## Next Meeting
+- "
+
+  echo "$content" | noteleaf note create "$title" --tags meeting --editor
+}
+
+daily_note() {
+  local date=$(date +%Y-%m-%d)
+  local title="Daily: $date"
+  local content="# $title
+
+## Completed Today
+-
+
+## In Progress
+-
+
+## Tomorrow's Focus
+-
+
+## Notes
+- "
+
+  echo "$content" | noteleaf note create "$title" --tags daily --editor
+}
+```
+
+Usage:
+
+```sh
+meeting_note "Q4 Planning"
+daily_note
+```

website/docs/notes/overview.md

···
+---
+title: Notes Overview
+sidebar_label: Overview
+description: How Noteleaf manages markdown-based notes.
+sidebar_position: 1
+---
+
+# Notes Overview
+
+Noteleaf provides a markdown-based note-taking system integrated with your tasks, articles, and media tracking.
+Notes are stored as individual markdown files with metadata tracked in the database, giving you both structure and portability.

website/docs/notes/workflows.md

···
+---
+title: Note-Taking Workflows
+sidebar_label: Workflows
+description: Zettelkasten, meeting notes, daily notes, and more.
+sidebar_position: 7
+---
+
+# Note-Taking Workflows
+
+## Zettelkasten
+
+Zettelkasten emphasizes atomic notes with heavy linking:
+
+1. **Create atomic notes**: Each note covers one concept
+2. **Add descriptive tags**: Use tags for categorization
+3. **Link related notes**: Reference other notes by title
+4. **Develop ideas over time**: Expand notes with new insights
+
+Example:
+
+```sh
+noteleaf note create "Dependency Injection" --tags architecture,patterns
+noteleaf note create "Inversion of Control" --tags architecture,patterns
+# In each note, reference the other
+```
+
+### Research
+
+For academic or technical research:
+
+1. **Source note per paper/article**: Create note for each source
+2. **Extract key points**: Summarize in your own words
+3. **Tag by topic**: Use consistent tags across research area
+4. **Link to related work**: Reference other sources
+
+Example:
+
+```sh
+noteleaf note create "Paper: Microservices Patterns" \
+  --tags research,architecture,microservices
+```
+
+### Meeting
+
+Capture discussions and action items:
+
+1. **Template-based**: Use meeting_note function from earlier
+2. **Consistent structure**: Attendees, agenda, discussion, actions
+3. **Action items**: Extract as tasks for follow-up
+4. **Link to projects**: Tag with project name
+
+Example:
+
+```sh
+meeting_note "Sprint Planning"
+# Then extract action items as tasks
+noteleaf task add "Implement auth endpoint" --project web-service
+```
+
+### Daily
+
+Journal-style daily entries:
+
+1. **Daily template**: Use daily_note function
+2. **Reflect on work**: What was accomplished, what's next
+3. **Capture ideas**: Random thoughts for later processing
+4. **Review weekly**: Scan week's notes for patterns
+
+Example:
+
+```sh
+daily_note
+# Creates note tagged with 'daily' and today's date
+```
+
+### Personal Knowledge Base
+
+Build a reference library:
+
+1. **How-to guides**: Document procedures and commands
+2. **Troubleshooting notes**: Solutions to problems encountered
+3. **Concept explanations**: Notes on topics you're learning
+4. **Snippets**: Code examples and configurations
+
+Use tags like: `how-to`, `troubleshooting`, `reference`, `snippet`

website/docs/tasks/_category_.json

···
+{
+    "label": "Tasks",
+    "position": 3,
+    "link": {
+        "type": "generated-index",
+        "title": "Task Management",
+        "description": "Deep dives into scheduling, tracking, and organizing work."
+    }
+}

website/docs/tasks/advanced.md

···
+---
+title: Advanced Task Features
+sidebar_label: Advanced
+description: Recurring tasks, dependencies, hierarchies, and custom fields.
+sidebar_position: 6
+---
+
+# Advanced Task Features
+
+## Recurrence
+
+Create tasks that repeat on a schedule using iCalendar recurrence rules.
+
+**Daily task**:
+
+```sh
+noteleaf task add "Daily standup" --recur "FREQ=DAILY"
+```
+
+**Weekly task on specific days**:
+
+```sh
+noteleaf task add "Team meeting" --recur "FREQ=WEEKLY;BYDAY=MO,WE"
+```
+
+**Monthly task**:
+
+```sh
+noteleaf task add "Invoice review" --recur "FREQ=MONTHLY;BYMONTHDAY=1"
+```
+
+**With end date**:
+
+```sh
+noteleaf task add "Q1 review" \
+  --recur "FREQ=WEEKLY" \
+  --until 2025-03-31
+```
+
+**Manage recurrence**:
+
+Set recurrence on existing task:
+
+```sh
+noteleaf task recur set 1 --rule "FREQ=DAILY"
+```
+
+View recurrence info:
+
+```sh
+noteleaf task recur show 1
+```
+
+Remove recurrence:
+
+```sh
+noteleaf task recur clear 1
+```
+
+When you complete a recurring task, Noteleaf automatically generates the next instance based on the recurrence rule.
+
+## Dependencies
+
+Create relationships where tasks must be completed in order.
+
+**Add dependency** (task 1 depends on task 2):
+
+```sh
+noteleaf task depend add 1 <uuid-of-task-2>
+```
+
+**List dependencies** (what must be done first):
+
+```sh
+noteleaf task depend list 1
+```
+
+**List blocked tasks** (what's waiting on this task):
+
+```sh
+noteleaf task depend blocked-by 1
+```
+
+**Remove dependency**:
+
+```sh
+noteleaf task depend remove 1 <uuid-of-task-2>
+```
+
+Dependencies use task UUIDs (shown in `task view`) rather than IDs for stability across database changes.
+
+## Hierarchical Tasks
+
+Create parent-child relationships for breaking down large tasks.
+
+**Create child task**:
+
+```sh
+noteleaf task add "Write API documentation" --parent <parent-uuid>
+```
+
+Parent tasks can have multiple children, creating a tree structure for complex projects.
+
+## Custom Attributes
+
+While not exposed through specific flags, the database schema supports extending tasks with custom attributes for advanced use cases or scripting.

website/docs/tasks/basics.md

···
+---
+title: Task Basics
+sidebar_label: Basics
+description: Create tasks and understand their core attributes.
+sidebar_position: 2
+---
+
+# Task Basics
+
+## Creation
+
+Create a simple task:
+
+```sh
+noteleaf task add "Write documentation"
+```
+
+Create a task with attributes:
+
+```sh
+noteleaf task add "Review pull requests" \
+  --priority high \
+  --project work \
+  --tags urgent,code-review \
+  --due 2025-01-15
+```
+
+## Properties
+
+**Description**: What needs to be done. Can be updated later with `task update`.
+
+**Status**: Task lifecycle state:
+
+- `pending`: Not yet started (default for new tasks)
+- `active`: Currently being worked on
+- `completed`: Finished successfully
+- `deleted`: Removed but preserved for history
+- `waiting`: Blocked or postponed
+
+**Priority**: Importance level affects sorting and display:
+
+- `low`: Nice to have, defer if busy
+- `medium`: Standard priority (default)
+- `high`: Important, should be done soon
+- `urgent`: Critical, top of the list
+
+**Project**: Group related tasks together. Examples: `work`, `home`, `side-project`. Projects create organizational boundaries and enable filtering.
+
+**Context**: Location or mode where task can be done. Examples: `@home`, `@office`, `@phone`, `@computer`. Contexts help filter tasks based on current situation.
+
+**Tags**: Flexible categorization orthogonal to projects. Examples: `urgent`, `quick-win`, `research`, `bug`. Multiple tags per task.
+
+**Due Date**: When the task should be completed. Format: `YYYY-MM-DD` or relative (`tomorrow`, `next week`).
+
+### Lifecycle
+
+Tasks move through statuses as work progresses:
+
+```
+pending -> active -> completed
+           |
+           v
+        waiting
+           |
+           v
+        deleted
+```
+
+**Mark task as active**:
+
+```sh
+noteleaf task update 1 --status active
+```
+
+**Complete a task**:
+
+```sh
+noteleaf task done 1
+```
+
+**Delete a task**:
+
+```sh
+noteleaf task delete 1
+```

website/docs/tasks/batch-operations.md

···
+---
+title: Batch Operations
+sidebar_label: Batch Ops
+description: Use shell scripting patterns for mass task edits.
+sidebar_position: 8
+---
+
+# Batch Operations
+
+While Noteleaf doesn't have built-in bulk update commands, you can use shell scripting for batch operations:
+
+**Complete all tasks in a project**:
+
+```sh
+noteleaf task list --project old-project --static | \
+  awk '{print $1}' | \
+  xargs -I {} noteleaf task done {}
+```
+
+**Add tag to multiple tasks**:
+
+```sh
+for id in 1 2 3 4 5; do
+  noteleaf task update $id --add-tag urgent
+done
+```

website/docs/tasks/best-practices.md

···
+---
+title: Task Tips and Best Practices
+sidebar_label: Best Practices
+description: Practical guidance for staying productive with tasks.
+sidebar_position: 10
+---
+
+# Task Tips and Best Practices
+
+**Start with simple workflows**: Don't over-organize initially. Use basic priorities and projects before adding contexts, tags, and dependencies.
+
+**Review regularly**: Use `task list` daily to check pending work. Weekly reviews help catch stale tasks.
+
+**Use contexts for GTD**: If following Getting Things Done, contexts help filter tasks by what you can do right now.
+
+**Project-based work**: For complex initiatives, use projects to group tasks and dependencies to order work.
+
+**Time tracking for accountability**: Even rough time tracking reveals where hours go and helps with estimates.
+
+**Recurrence for habits**: Use recurring tasks for daily/weekly habits, but keep the list short to avoid clutter.
+
+**Tags for cross-cutting concerns**: Use tags for themes that span projects: `urgent`, `blocked`, `waiting-on-feedback`, `quick-win`.
+
+**JSON output for scripts**: Use `--json` flag with scripting to build custom reports and integrations.
+
+For CLI command reference, run `noteleaf task --help` or explore the inline help on each subcommand.

website/docs/tasks/operations.md

···
+---
+title: Task Operations
+sidebar_label: Operations
+description: List, view, and update tasks from the CLI and TUI.
+sidebar_position: 3
+---
+
+# Task Operations
+
+## Listing and Filtering
+
+**Interactive list** (default):
+
+```sh
+noteleaf task list
+```
+
+Navigate with arrow keys, press Enter to view details, `q` to quit.
+
+**Static list** (for scripting):
+
+```sh
+noteleaf task list --static
+```
+
+**Filter by status**:
+
+```sh
+noteleaf task list --status pending
+noteleaf task list --status completed
+```
+
+**Filter by project**:
+
+```sh
+noteleaf task list --project work
+```
+
+**Filter by priority**:
+
+```sh
+noteleaf task list --priority high
+```
+
+**Filter by context**:
+
+```sh
+noteleaf task list --context @office
+```
+
+**Show all tasks** (including completed):
+
+```sh
+noteleaf task list --all
+```
+
+## Viewing Task Details
+
+View complete task information:
+
+```sh
+noteleaf task view 1
+```
+
+JSON output for scripts:
+
+```sh
+noteleaf task view 1 --json
+```
+
+Brief format without metadata:
+
+```sh
+noteleaf task view 1 --format brief
+```
+
+## Updating Tasks
+
+Update single attribute:
+
+```sh
+noteleaf task update 1 --priority urgent
+```
+
+Update multiple attributes:
+
+```sh
+noteleaf task update 1 \
+  --priority urgent \
+  --due tomorrow \
+  --add-tag critical
+```
+
+Change description:
+
+```sh
+noteleaf task update 1 --description "New task description"
+```
+
+Add and remove tags:
+
+```sh
+noteleaf task update 1 --add-tag urgent --remove-tag later
+```
+
+## Interactive Editing
+
+Open interactive editor for complex changes:
+
+```sh
+noteleaf task edit 1
+```
+
+This provides a TUI with visual pickers for status and priority, making updates faster than command flags.

website/docs/tasks/organization.md

···
+---
+title: Task Organization
+sidebar_label: Organization
+description: Use projects, contexts, and tags to structure work.
+sidebar_position: 5
+---
+
+# Task Organization
+
+## Projects
+
+Projects group related tasks. Useful for separating work contexts or major initiatives.
+
+**List all projects**:
+
+```sh
+noteleaf task projects
+```
+
+Shows each project with task count.
+
+**Filter tasks by project**:
+
+```sh
+noteleaf task list --project work
+```
+
+**Project naming**: Use lowercase, hyphens for spaces. Examples: `work`, `side-project`, `home-improvement`.
+
+## Contexts
+
+Contexts represent where or how a task can be done. Helps with GTD-style workflow.
+
+**List all contexts**:
+
+```sh
+noteleaf task contexts
+```
+
+**Filter by context**:
+
+```sh
+noteleaf task list --context @home
+```
+
+**Context naming**: Prefix with `@` following GTD convention. Examples: `@home`, `@office`, `@phone`, `@errands`.
+
+## Tags
+
+Tags provide flexible categorization. Unlike projects and contexts, tasks can have multiple tags.
+
+**List all tags**:
+
+```sh
+noteleaf task tags
+```
+
+**Filter by tags** (tasks must have all specified tags):
+
+```sh
+noteleaf task list --tags urgent,bug
+```
+
+**Tag naming**: Use lowercase, hyphens for compound tags. Examples: `urgent`, `quick-win`, `code-review`, `waiting-on-feedback`.

website/docs/tasks/overview.md

···
+---
+title: Task Management Overview
+sidebar_label: Overview
+description: High-level summary of Noteleaf's task workflow.
+sidebar_position: 1
+---
+
+# Task Management Overview
+
+Noteleaf provides TaskWarrior-inspired task management with priorities, projects, contexts, tags, dependencies, and time tracking.
+Whether you're managing personal todos or complex projects, Noteleaf helps you organize work and track progress.

website/docs/tasks/queries.md

···
+---
+title: Task Queries and Filtering
+sidebar_label: Queries
+description: Compose filters for precise task lists and reports.
+sidebar_position: 7
+---
+
+# Task Queries and Filtering
+
+Combine filters for precise task lists:
+
+**High priority work tasks due this week**:
+
+```sh
+noteleaf task list \
+  --project work \
+  --priority high \
+  --status pending
+```
+
+**All completed tasks from specific project**:
+
+```sh
+noteleaf task list \
+  --project side-project \
+  --status completed
+```
+
+**Quick wins** (tasks tagged as quick):
+
+```sh
+noteleaf task list --tags quick-win
+```

website/docs/tasks/templates.md

···
+---
+title: Task Templates
+sidebar_label: Templates
+description: Shell helpers for creating consistent task structures.
+sidebar_position: 9
+---
+
+# Task Templates
+
+While templates aren't built-in, you can create shell functions for common task patterns:
+
+```sh
+# In your ~/.bashrc or ~/.zshrc
+bug() {
+  noteleaf task add "$1" \
+    --project $(git rev-parse --show-toplevel | xargs basename) \
+    --tags bug \
+    --priority high
+}
+
+meeting() {
+  noteleaf task add "$1" \
+    --project work \
+    --context @office \
+    --recur "FREQ=WEEKLY;BYDAY=$2"
+}
+```
+
+Usage:
+
+```sh
+bug "Fix login redirect"
+meeting "Sprint planning" "MO"
+```

website/docs/tasks/time-tracking.md

···
+---
+title: Time Tracking
+sidebar_label: Time Tracking
+description: Track work, review sessions, and generate timesheets.
+sidebar_position: 4
+---
+
+# Time Tracking
+
+Track hours spent on tasks for billing, reporting, or personal analytics.
+
+## Starting and Stopping
+
+**Start tracking**:
+
+```sh
+noteleaf task start 1
+```
+
+With a note about what you're doing:
+
+```sh
+noteleaf task start 1 --note "Implementing authentication"
+```
+
+**Stop tracking**:
+
+```sh
+noteleaf task stop 1
+```
+
+Only one task can be actively tracked at a time.
+
+## Viewing Timesheets
+
+**Last 7 days** (default):
+
+```sh
+noteleaf task timesheet
+```
+
+**Specific time range**:
+
+```sh
+noteleaf task timesheet --days 30
+```
+
+**For specific task**:
+
+```sh
+noteleaf task timesheet --task 1
+```
+
+Timesheet shows:
+
+- Date and time range for each session
+- Duration
+- Notes attached to the session
+- Total time per task
+- Total time across all tasks

website/docusaurus.config.ts

···
 import { themes as prismThemes } from "prism-react-renderer";
 import type { Config } from "@docusaurus/types";
 import type * as Preset from "@docusaurus/preset-classic";
+import type { SidebarsConfig } from "@docusaurus/plugin-content-docs";
 
 const ghURL = "https://github.com/stormlightlabs/noteleaf";
 // This runs in Node.js - Don't use client-side code here (browser APIs, JSX...)
+const pragmaticSidebar: SidebarsConfig[string] = [
+    { type: "doc", id: "quickstart" },
+    {
+        type: "category",
+        label: "Concepts",
+        items: [{ type: "autogenerated", dirName: "concepts" }],
+    },
+    {
+        type: "category",
+        label: "Tasks",
+        items: [{ type: "autogenerated", dirName: "tasks" }],
+    },
+    {
+        type: "category",
+        label: "Notes",
+        items: [{ type: "autogenerated", dirName: "notes" }],
+    },
+    {
+        type: "category",
+        label: "Media",
+        items: [{ type: "autogenerated", dirName: "media" }],
+    },
+    {
+        type: "category",
+        label: "Articles",
+        items: [{ type: "autogenerated", dirName: "articles" }],
+    },
+    {
+        type: "category",
+        label: "Leaflet Publishing",
+        items: [{ type: "autogenerated", dirName: "leaflet" }],
+    },
+    { type: "doc", id: "configuration" },
+];
+
 const config: Config = {
-    title: "My Site",
-    tagline: "Dinosaurs are cool",
+    title: "Noteleaf",
+    tagline:
+        "Terminal-based personal information manager for tasks, notes, and media",
     favicon: "img/favicon.ico",
     // Improve compatibility with the upcoming Docusaurus v4
     future: { v4: true },
···
     projectName: "noteleaf",
     onBrokenLinks: "throw",
     i18n: { defaultLocale: "en", locales: ["en"] },
+    customFields: { pragmaticSidebar },
     presets: [
         [
             "classic",
···
         image: "img/social-card.png",
         colorMode: { respectPrefersColorScheme: true },
         navbar: {
-            title: "My Site",
-            logo: { alt: "My Site Logo", src: "img/logo.svg" },
+            title: "Noteleaf",
+            logo: { alt: "Noteleaf Logo", src: "img/logo.svg" },
             items: [
                 {
                     type: "docSidebar",
···
                     title: "Docs",
                     items: [
                         {
-                            label: "Tutorial",
-                            to: "/docs/intro",
+                            label: "Quickstart",
+                            to: "/docs/quickstart",
                         },
                     ],
                 },

website/package.json

···
 {
-  "name": "noteleaf-website",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "docusaurus": "docusaurus",
-    "start": "docusaurus start",
-    "build": "docusaurus build",
-    "swizzle": "docusaurus swizzle",
-    "deploy": "docusaurus deploy",
-    "clear": "docusaurus clear",
-    "serve": "docusaurus serve",
-    "write-translations": "docusaurus write-translations",
-    "write-heading-ids": "docusaurus write-heading-ids",
-    "typecheck": "tsc",
-    "generate-social-card": "node generate-social-card.mjs"
-  },
-  "dependencies": {
-    "@docusaurus/core": "3.9.1",
-    "@docusaurus/preset-classic": "3.9.1",
-    "@fontsource/lato": "^5.1.0",
-    "@mdx-js/react": "^3.0.0",
-    "clsx": "^2.0.0",
-    "prism-react-renderer": "^2.3.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "satori": "^0.14.1",
-    "satori-html": "^0.3.2",
-    "sharp": "^0.33.5"
-  },
-  "devDependencies": {
-    "@docusaurus/module-type-aliases": "3.9.1",
-    "@docusaurus/tsconfig": "3.9.1",
-    "@docusaurus/types": "3.9.1",
-    "typescript": "~5.6.2"
-  },
-  "browserslist": {
-    "production": [
-      ">0.5%",
-      "not dead",
-      "not op_mini all"
-    ],
-    "development": [
-      "last 3 chrome version",
-      "last 3 firefox version",
-      "last 5 safari version"
-    ]
-  },
-  "engines": {
-    "node": ">=20.0"
-  }
+    "name": "noteleaf-website",
+    "version": "0.0.0",
+    "private": true,
+    "scripts": {
+        "docusaurus": "docusaurus",
+        "start": "docusaurus start",
+        "build": "docusaurus build",
+        "swizzle": "docusaurus swizzle",
+        "deploy": "docusaurus deploy",
+        "clear": "docusaurus clear",
+        "serve": "docusaurus serve",
+        "write-translations": "docusaurus write-translations",
+        "write-heading-ids": "docusaurus write-heading-ids",
+        "typecheck": "tsc",
+        "generate-social-card": "node generate-social-card.mjs"
+    },
+    "dependencies": {
+        "@docusaurus/core": "3.9.1",
+        "@docusaurus/preset-classic": "3.9.1",
+        "@mdx-js/react": "^3.0.0",
+        "clsx": "^2.0.0",
+        "prism-react-renderer": "^2.3.0",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0",
+        "satori": "^0.14.1",
+        "satori-html": "^0.3.2",
+        "sharp": "^0.33.5"
+    },
+    "devDependencies": {
+        "@docusaurus/module-type-aliases": "3.9.1",
+        "@docusaurus/tsconfig": "3.9.1",
+        "@docusaurus/types": "3.9.1",
+        "typescript": "~5.6.2"
+    },
+    "browserslist": {
+        "production": [
+            ">0.5%",
+            "not dead",
+            "not op_mini all"
+        ],
+        "development": [
+            "last 3 chrome version",
+            "last 3 firefox version",
+            "last 5 safari version"
+        ]
+    },
+    "engines": {
+        "node": ">=20.0"
+    }
 }

website/sidebars.ts

···
 import type { SidebarsConfig } from "@docusaurus/plugin-content-docs";
+import config from "./docusaurus.config";
 
 // This runs in Node.js - Don't use client-side code here (browser APIs, JSX...)
 const sidebars: SidebarsConfig = {
-    manualSidebar: [{ type: "autogenerated", dirName: "." }],
+    manualSidebar:
+        (config.customFields?.pragmaticSidebar as SidebarsConfig[string]) ?? [],
 };
 
 export default sidebars;

website/src/css/custom.css

···
-/**
- * Noteleaf Documentation Site Styles
- * Using color palette from internal/ui/palette.go
- * Font: Lato
- */
 
-@import '@fontsource/lato/300.css';
-@import '@fontsource/lato/400.css';
-@import '@fontsource/lato/700.css';
-@import '@fontsource/lato/900.css';
 
 :root {
   /* Noteleaf Color Palette - Light Mode */
···
   /* Code blocks */
   --ifm-code-background: #F1EFEF; /* Salt */
   --ifm-code-font-size: 95%;
-
-  /* Font family */
-  --ifm-font-family-base: 'Lato', sans-serif;
 
   --docusaurus-highlighted-code-line-bg: rgba(0, 164, 255, 0.1);
 }

website/src/pages/index.tsx

···
-import type {ReactNode} from 'react';
-import clsx from 'clsx';
-import Link from '@docusaurus/Link';
-import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
-import Layout from '@theme/Layout';
-import HomepageFeatures from '@site/src/components/HomepageFeatures';
-import Heading from '@theme/Heading';
+import type { ReactNode } from "react";
+import clsx from "clsx";
+import Link from "@docusaurus/Link";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+import Layout from "@theme/Layout";
+import HomepageFeatures from "@site/src/components/HomepageFeatures";
+import Heading from "@theme/Heading";
 
-import styles from './index.module.css';
+import styles from "./index.module.css";
 
 function HomepageHeader() {
-  const {siteConfig} = useDocusaurusContext();
-  return (
-    <header className={clsx('hero hero--primary', styles.heroBanner)}>
-      <div className="container">
-        <Heading as="h1" className="hero__title">
-          {siteConfig.title}
-        </Heading>
-        <p className="hero__subtitle">{siteConfig.tagline}</p>
-        <div className={styles.buttons}>
-          <Link
-            className="button button--secondary button--lg"
-            to="/docs/intro">
-            Docusaurus Tutorial - 5min ⏱️
-          </Link>
-        </div>
-      </div>
-    </header>
-  );
+    const { siteConfig } = useDocusaurusContext();
+    return (
+        <header className={clsx("hero hero--primary", styles.heroBanner)}>
+            <div className="container">
+                <Heading as="h1" className="hero__title">
+                    {siteConfig.title}
+                </Heading>
+                <p className="hero__subtitle">{siteConfig.tagline}</p>
+                <div className={styles.buttons}>
+                    <Link
+                        className="button button--secondary button--lg"
+                        to="/docs/quickstart"
+                    >
+                        Get Started
+                    </Link>
+                </div>
+            </div>
+        </header>
+    );
 }
 
 export default function Home(): ReactNode {
-  const {siteConfig} = useDocusaurusContext();
-  return (
-    <Layout
-      title={`Hello from ${siteConfig.title}`}
-      description="Description will go into a meta tag in <head />">
-      <HomepageHeader />
-      <main>
-        <HomepageFeatures />
-      </main>
-    </Layout>
-  );
+    const { siteConfig } = useDocusaurusContext();
+    return (
+        <Layout
+            title="Terminal-based Personal Information Manager"
+            description="Manage tasks, notes, articles, and media from your terminal with Noteleaf"
+        >
+            <HomepageHeader />
+            <main>
+                <HomepageFeatures />
+            </main>
+        </Layout>
+    );
 }

website/src/pages/markdown-page.md

···
----
-title: Markdown page example
----
-
-# Markdown page example
-
-You don't need React to write simple standalone pages.