feat: cover more xpath rules

* refactor (wip) color palettes with wrappers

codecov.yml

···
   - "internal/**/test_utilities.go"
   - "internal/handlers/handler_test_suite.go"
   - "internal/tools/docgen.go"
+  - "internal/ui/common.go"
+  - "internal/ui/palette.go"
+  - "internal/ui/logo.go"
+

go.mod

···
 	github.com/muesli/reflow v0.3.0 // indirect
 	github.com/yuin/goldmark v1.7.8 // indirect
 	github.com/yuin/goldmark-emoji v1.0.5 // indirect
-	golang.org/x/net v0.44.0 // indirect
+	golang.org/x/net v0.46.0
 	golang.org/x/sync v0.17.0 // indirect
-	golang.org/x/term v0.35.0 // indirect
+	golang.org/x/term v0.36.0 // indirect
 )
 
 require (
···
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
-	golang.org/x/sys v0.36.0 // indirect
-	golang.org/x/text v0.29.0
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/text v0.30.0
 )

go.sum

···
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
 golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
+golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
···
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
-golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
···
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
-golang.org/x/term v0.35.0 h1:bZBVKBudEyhRcajGcNc3jIfWPqV4y/Kt2XcoigOWtDQ=
-golang.org/x/term v0.35.0/go.mod h1:TPGtkTLesOwf2DE8CgVYiZinHAOuy5AYUYT1lENIZnA=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
···
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
-golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
+golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
 golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
 golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

internal/articles/parser.go

···
 	"github.com/gomarkdown/markdown/html"
 	"github.com/gomarkdown/markdown/parser"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	exhtml "golang.org/x/net/html"
 )
 
 //go:embed rules/*.txt
···
 
 // ParsingRule represents XPath rules for extracting content from a specific domain
 type ParsingRule struct {
-	Domain   string
-	Title    string
-	Author   string
-	Date     string
-	Body     string
-	Strip    []string // XPath selectors for elements to remove
-	TestURLs []string
+	Domain            string
+	Title             string
+	Author            string
+	Date              string
+	Body              string
+	Strip             []string // XPath selectors for elements to remove
+	StripIDsOrClasses []string
+	TestURLs          []string
+	Headers           map[string]string
+	Prune             bool
+	Tidy              bool
 }
 
 // Parser interface defines methods for parsing articles from URLs
···
 			rule.Body = value
 		case "strip":
 			rule.Strip = append(rule.Strip, value)
+		case "strip_id_or_class":
+			rule.StripIDsOrClasses = append(rule.StripIDsOrClasses, value)
+		case "prune":
+			rule.Prune = parseBool(value)
+		case "tidy":
+			rule.Tidy = parseBool(value)
 		case "test_url":
 			rule.TestURLs = append(rule.TestURLs, value)
+		default:
+			if strings.HasPrefix(key, "http_header(") && strings.HasSuffix(key, ")") {
+				headerName := strings.TrimSuffix(strings.TrimPrefix(key, "http_header("), ")")
+				if headerName != "" {
+					if rule.Headers == nil {
+						rule.Headers = make(map[string]string)
+					}
+					rule.Headers[http.CanonicalHeaderKey(headerName)] = value
+				}
+			}
 		}
 	}
 
···
 	return rule, nil
 }
 
+func parseBool(value string) bool {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "1", "true", "yes", "on":
+		return true
+	default:
+		return false
+	}
+}
+
+func (p *ArticleParser) findRule(domain string) *ParsingRule {
+	for ruleDomain, rule := range p.rules {
+		if domain == ruleDomain || strings.HasSuffix(domain, ruleDomain) {
+			return rule
+		}
+	}
+	return nil
+}
+
 // ParseURL extracts article content from a given URL
 func (p *ArticleParser) ParseURL(s string) (*ParsedContent, error) {
 	parsedURL, err := url.Parse(s)
···
 
 	domain := parsedURL.Hostname()
 
-	resp, err := p.client.Get(s)
+	rule := p.findRule(domain)
+
+	req, err := http.NewRequest(http.MethodGet, s, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	if rule != nil {
+		for header, value := range rule.Headers {
+			if value == "" {
+				continue
+			}
+			if req.Header.Get(header) == "" {
+				req.Header.Set(header, value)
+			}
+		}
+	}
+
+	resp, err := p.client.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch URL: %w", err)
 	}
···
 
 // ParseHTML extracts article content from HTML string using domain-specific rules
 func (p *ArticleParser) Parse(htmlContent, domain, sourceURL string) (*ParsedContent, error) {
-	var rule *ParsingRule
-	for ruleDomain, r := range p.rules {
-		if strings.Contains(domain, ruleDomain) {
-			rule = r
-			break
-		}
-	}
+	rule := p.findRule(domain)
 
 	if rule == nil {
 		return nil, fmt.Errorf("no parsing rule found for domain: %s", domain)
···
 	}
 
 	if rule.Body != "" {
-		if bodyNode := htmlquery.FindOne(doc, rule.Body); bodyNode != nil {
-			for _, stripXPath := range rule.Strip {
-				stripNodes := htmlquery.Find(bodyNode, stripXPath)
-				for _, node := range stripNodes {
-					node.Parent.RemoveChild(node)
-				}
-			}
+		bodyNode := htmlquery.FindOne(doc, rule.Body)
+		if bodyNode == nil {
+			return nil, fmt.Errorf("could not extract body content from HTML")
+		}
 
-			content.Content = strings.TrimSpace(htmlquery.InnerText(bodyNode))
+		for _, stripXPath := range rule.Strip {
+			removeNodesByXPath(bodyNode, stripXPath)
 		}
+
+		for _, identifier := range rule.StripIDsOrClasses {
+			removeNodesByIdentifier(bodyNode, identifier)
+		}
+
+		removeDefaultNonContentNodes(bodyNode)
+
+		content.Content = normalizeWhitespace(htmlquery.InnerText(bodyNode))
 	}
 
 	if content.Title == "" {
···
 	return content, nil
 }
 
+func removeNodesByXPath(root *exhtml.Node, xpath string) {
+	if root == nil {
+		return
+	}
+
+	xpath = strings.TrimSpace(xpath)
+	if xpath == "" {
+		return
+	}
+
+	nodes := htmlquery.Find(root, xpath)
+	for _, node := range nodes {
+		if node != nil && node.Parent != nil {
+			node.Parent.RemoveChild(node)
+		}
+	}
+}
+
+func removeNodesByIdentifier(root *exhtml.Node, identifier string) {
+	identifier = strings.TrimSpace(identifier)
+	if root == nil || identifier == "" {
+		return
+	}
+
+	idLiteral := buildXPathLiteral(identifier)
+	removeNodesByXPath(root, fmt.Sprintf(".//*[@id=%s]", idLiteral))
+
+	classLiteral := buildXPathLiteral(" " + identifier + " ")
+	removeNodesByXPath(root, fmt.Sprintf(".//*[contains(concat(' ', normalize-space(@class), ' '), %s)]", classLiteral))
+}
+
+func removeDefaultNonContentNodes(root *exhtml.Node) {
+	for _, xp := range []string{
+		".//script",
+		".//style",
+		".//noscript",
+	} {
+		removeNodesByXPath(root, xp)
+	}
+}
+
+func normalizeWhitespace(value string) string {
+	value = strings.ReplaceAll(value, "\u00a0", " ")
+	return strings.TrimSpace(value)
+}
+
+func buildXPathLiteral(value string) string {
+	if !strings.Contains(value, "'") {
+		return "'" + value + "'"
+	}
+
+	if !strings.Contains(value, "\"") {
+		return `"` + value + `"`
+	}
+
+	segments := strings.Split(value, "'")
+	var builder strings.Builder
+	builder.WriteString("concat(")
+
+	for i, segment := range segments {
+		if i > 0 {
+			builder.WriteString(", \"'\", ")
+		}
+		if segment == "" {
+			builder.WriteString("''")
+			continue
+		}
+		builder.WriteString("'")
+		builder.WriteString(segment)
+		builder.WriteString("'")
+	}
+
+	builder.WriteString(")")
+	return builder.String()
+}
+
 // Convert HTML content directly to markdown using domain-specific rules
 func (p *ArticleParser) Convert(htmlContent, domain, sourceURL string) (string, error) {
 	content, err := p.Parse(htmlContent, domain, sourceURL)
···
 
 	baseMarkdownPath := filepath.Join(dir, slug+".md")
 	baseHTMLPath := filepath.Join(dir, slug+".html")
-
 	markdownPath = baseMarkdownPath
 	htmlPath = baseHTMLPath
 

internal/articles/parser_test.go

···
 			if err == nil {
 				t.Error("Expected error when no title can be extracted")
 			}
-			if !strings.Contains(err.Error(), "could not extract title") {
-				t.Errorf("Expected 'could not extract title' error, got %v", err)
+			if !strings.Contains(err.Error(), "could not extract title") &&
+				!strings.Contains(err.Error(), "could not extract body content") {
+				t.Errorf("Expected title or body extraction error, got %v", err)
 			}
 		})
 
···
 			<body>
 				<h1 id="firstHeading">Test Article Title</h1>
 				<div id="bodyContent">
+					<style>.mw-parser-output .hatnote{font-style:italic;}</style>
 					<p>This is the main content of the article.</p>
 					<div class="noprint">This should be stripped</div>
+					<div class="editsection">Edit this section</div>
 					<p>More content here.</p>
 				</div>
 			</body>
···
 			if strings.Contains(markdown, "This should be stripped") {
 				t.Error("Expected stripped content to be removed from markdown")
 			}
+			if strings.Contains(markdown, ".mw-parser-output") {
+				t.Error("Expected style content to be removed from markdown")
+			}
+			if strings.Contains(markdown, "Edit this section") {
+				t.Error("Expected edit section markers to be removed from markdown")
+			}
 		})
 	})
 
···
 				w.WriteHeader(http.StatusOK)
 				w.Write([]byte("<html><head><title>Test</title></head><body><p>Content</p></body></html>"))
 			default:
-				// Return Wikipedia-like structure for localhost rule
 				w.WriteHeader(http.StatusOK)
 				w.Write([]byte(`<html>
 					<head><title>Test Article</title></head>
···
 		}
 	})
 
-	t.Run("fails with invalid directory", func(t *testing.T) {
-		// Skip this test as it would require network access to test with real URLs
-		t.Skip("Skipping invalid directory test - requires network access")
-	})
-
 	t.Run("fails with malformed HTML", func(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
···
 		if err == nil {
 			t.Error("Expected error for malformed HTML")
 		}
-		if !strings.Contains(err.Error(), "failed to parse HTML") && !strings.Contains(err.Error(), "could not extract title") {
-			t.Errorf("Expected HTML parsing or title extraction error, got %v", err)
+		if !strings.Contains(err.Error(), "failed to parse HTML") &&
+			!strings.Contains(err.Error(), "could not extract title") &&
+			!strings.Contains(err.Error(), "could not extract body content") {
+			t.Errorf("Expected HTML parsing or extraction error, got %v", err)
 		}
 	})
 
···
 						<p>Content without proper title</p>
 					</div>
 				</body>
-			</html>`)) // No h1 with id="firstHeading"
+			</html>`))
 		}))
 		defer server.Close()
 
···
 			t.Fatalf("Failed to save article: %v", err)
 		}
 
-		// Test that it creates a proper models.Article structure (simulating CreateArticleFromURL)
 		article := &models.Article{
 			URL:          server.URL,
 			Title:        content.Title,
···
 			t.Fatalf("Failed to save article: %v", err)
 		}
 
-		// Verify markdown contains all metadata
 		mdContent, err := os.ReadFile(mdPath)
 		if err != nil {
 			t.Fatalf("Failed to read markdown file: %v", err)

internal/handlers/articles.go

···
 	"github.com/stormlightlabs/noteleaf/internal/repo"
 	"github.com/stormlightlabs/noteleaf/internal/store"
 	"github.com/stormlightlabs/noteleaf/internal/ui"
-	"github.com/stormlightlabs/noteleaf/internal/utils"
 )
 
+const (
+	articleUserAgent    = "curl/8.4.0"
+	articleAcceptHeader = "*/*"
+	articleLangHeader   = "en-US,en;q=0.8"
+)
+
+type headerRoundTripper struct {
+	rt http.RoundTripper
+}
+
 // ArticleHandler handles all article-related commands
 type ArticleHandler struct {
 	db     *store.Database
···
 	}
 
 	repos := repo.NewRepositories(db.DB)
-
-	parser, err := articles.NewArticleParser(http.DefaultClient)
+	parser, err := articles.NewArticleParser(newArticleHTTPClient())
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize article parser: %w", err)
 	}
···
 	}, nil
 }
 
+func newArticleHTTPClient() *http.Client {
+	baseTransport := http.DefaultTransport
+
+	if transport, ok := http.DefaultTransport.(*http.Transport); ok {
+		baseTransport = transport.Clone()
+	}
+
+	return &http.Client{
+		Timeout:   30 * time.Second,
+		Transport: &headerRoundTripper{rt: baseTransport},
+	}
+}
+
+func (h *headerRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	if h.rt == nil {
+		h.rt = http.DefaultTransport
+	}
+
+	clone := req.Clone(req.Context())
+	clone.Header = req.Header.Clone()
+
+	if clone.Header.Get("User-Agent") == "" {
+		clone.Header.Set("User-Agent", articleUserAgent)
+	}
+
+	if clone.Header.Get("Accept") == "" {
+		clone.Header.Set("Accept", articleAcceptHeader)
+	}
+
+	if clone.Header.Get("Accept-Language") == "" {
+		clone.Header.Set("Accept-Language", articleLangHeader)
+	}
+
+	if clone.Header.Get("Connection") == "" {
+		clone.Header.Set("Connection", "keep-alive")
+	}
+
+	return h.rt.RoundTrip(clone)
+}
+
 // Close cleans up resources
 func (h *ArticleHandler) Close() error {
 	if h.db != nil {
···
 
 // Add handles adding an article from a URL
 func (h *ArticleHandler) Add(ctx context.Context, url string) error {
-	logger := utils.GetLogger()
-
 	existing, err := h.repos.Articles.GetByURL(ctx, url)
 	if err == nil {
-		fmt.Printf("Article already exists: %s (ID: %d)\n", ui.TitleColorStyle.Render(existing.Title), existing.ID)
+		ui.Warningln("Article already exists: %s (ID: %d)", ui.TitleColorStyle.Render(existing.Title), existing.ID)
 		return nil
 	}
 
-	logger.Info("Parsing article", "url", url)
-	fmt.Printf("Parsing article from: %s\n", url)
+	ui.Infoln("Parsing article from: %s", url)
 
 	dir, err := h.getStorageDirectory()
 	if err != nil {
···
 		return fmt.Errorf("failed to save article to database: %w", err)
 	}
 
-	fmt.Printf("Article saved successfully!\n")
-	fmt.Printf("ID: %d\n", id)
-	fmt.Printf("Title: %s\n", ui.TitleColorStyle.Render(article.Title))
+	ui.Infoln("Article saved successfully!")
+	ui.Infoln("ID: %d", id)
+	ui.Infoln("Title: %s", ui.TitleColorStyle.Render(article.Title))
 	if article.Author != "" {
-		fmt.Printf("Author: %s\n", ui.HeaderColorStyle.Render(article.Author))
+		ui.Infoln("Author: %s", ui.HeaderColorStyle.Render(article.Author))
 	}
 	if article.Date != "" {
-		fmt.Printf("Date: %s\n", article.Date)
+		ui.Infoln("Date: %s", article.Date)
 	}
-	fmt.Printf("Markdown: %s\n", article.MarkdownPath)
-	fmt.Printf("HTML: %s\n", article.HTMLPath)
-
-	logger.Info("Article saved", "id", id, "title", article.Title)
+	ui.Infoln("Markdown: %s", article.MarkdownPath)
+	ui.Infoln("HTML: %s", article.HTMLPath)
 
 	return nil
 }
···
 	}
 
 	if len(articles) == 0 {
-		fmt.Println("No articles found.")
+		ui.Warningln("No articles found.")
 		return nil
 	}
 
-	fmt.Printf("Found %d article(s):\n\n", len(articles))
-
+	ui.Infoln("Found %d article(s):\n", len(articles))
 	for _, article := range articles {
-		fmt.Printf("ID: %d\n", article.ID)
-		fmt.Printf("Title: %s\n", ui.TitleColorStyle.Render(article.Title))
+		ui.Infoln("ID: %d", article.ID)
+		ui.Infoln("Title: %s", ui.TitleColorStyle.Render(article.Title))
 		if article.Author != "" {
-			fmt.Printf("Author: %s\n", ui.HeaderColorStyle.Render(article.Author))
+			ui.Infoln("Author: %s", ui.HeaderColorStyle.Render(article.Author))
 		}
 		if article.Date != "" {
-			fmt.Printf("Date: %s\n", article.Date)
+			ui.Infoln("Date: %s", article.Date)
 		}
-		fmt.Printf("URL: %s\n", article.URL)
-		fmt.Printf("Added: %s\n", article.Created.Format("2006-01-02 15:04:05"))
-		fmt.Println("---")
+		ui.Infoln("URL: %s", article.URL)
+		ui.Infoln("Added: %s", article.Created.Format("2006-01-02 15:04:05"))
+		ui.Plainln("---")
 	}
-
 	return nil
 }
 
 // View handles viewing an article by ID
 func (h *ArticleHandler) View(ctx context.Context, id int64) error {
-
 	article, err := h.repos.Articles.Get(ctx, id)
 	if err != nil {
 		return fmt.Errorf("failed to get article: %w", err)
 	}
 
-	fmt.Printf("Title: %s\n", ui.TitleColorStyle.Render(article.Title))
+	ui.Infoln("Title: %s", ui.TitleColorStyle.Render(article.Title))
 	if article.Author != "" {
-		fmt.Printf("Author: %s\n", ui.HeaderColorStyle.Render(article.Author))
+		ui.Infoln("Author: %s", ui.HeaderColorStyle.Render(article.Author))
 	}
 	if article.Date != "" {
-		fmt.Printf("Date: %s\n", article.Date)
+		ui.Infoln("Date: %s", article.Date)
 	}
-	fmt.Printf("URL: %s\n", article.URL)
-	fmt.Printf("Added: %s\n", article.Created.Format("2006-01-02 15:04:05"))
-	fmt.Printf("Modified: %s\n", article.Modified.Format("2006-01-02 15:04:05"))
-	fmt.Println()
+	ui.Infoln("URL: %s", article.URL)
+	ui.Infoln("Added: %s", article.Created.Format("2006-01-02 15:04:05"))
+	ui.Infoln("Modified: %s", article.Modified.Format("2006-01-02 15:04:05"))
+	ui.Newline()
 
-	fmt.Printf("Markdown file: %s", article.MarkdownPath)
+	ui.Info("Markdown file: %s", article.MarkdownPath)
 	if _, err := os.Stat(article.MarkdownPath); os.IsNotExist(err) {
-		fmt.Printf(" (file not found)")
+		ui.Warning(" (file not found)")
 	}
-	fmt.Println()
+
+	ui.Newline()
 
-	fmt.Printf("HTML file: %s", article.HTMLPath)
+	ui.Info("HTML file: %s", article.HTMLPath)
 	if _, err := os.Stat(article.HTMLPath); os.IsNotExist(err) {
-		fmt.Printf(" (file not found)")
+		ui.Warning(" (file not found)")
 	}
-	fmt.Println()
+	ui.Newline()
 
 	if _, err := os.Stat(article.MarkdownPath); err == nil {
-		fmt.Printf("\n%s\n", ui.HeaderColorStyle.Render("--- Content Preview ---"))
+		ui.Headerln("--- Content Preview ---")
 		content, err := os.ReadFile(article.MarkdownPath)
 		if err == nil {
 			lines := strings.Split(string(content), "\n")
 			previewLines := min(len(lines), 20)
 
 			for i := range previewLines {
-				fmt.Println(lines[i])
+				ui.Plainln("%v", lines[i])
 			}
 
 			if len(lines) > previewLines {
-				fmt.Printf("\n... (%d more lines)\n", len(lines)-previewLines)
-				fmt.Printf("Read full content: %s\n", article.MarkdownPath)
+				ui.Plainln("\n... (%d more lines)", len(lines)-previewLines)
+				ui.Plainln("Read full content: %s", article.MarkdownPath)
 			}
 		}
 	}
···
 
 	if _, err := os.Stat(article.MarkdownPath); err == nil {
 		if rmErr := os.Remove(article.MarkdownPath); rmErr != nil {
-			fmt.Printf("Warning: failed to remove markdown file: %v\n", rmErr)
+			ui.Warningln("Warning: failed to remove markdown file: %v", rmErr)
 		}
 	}
 
 	if _, err := os.Stat(article.HTMLPath); err == nil {
 		if rmErr := os.Remove(article.HTMLPath); rmErr != nil {
-			fmt.Printf("Warning: failed to remove HTML file: %v\n", rmErr)
+			ui.Warningln("Warning: failed to remove HTML file: %v", rmErr)
 		}
 	}
 
-	fmt.Printf("Article removed: %s (ID: %d)\n", ui.TitleColorStyle.Render(article.Title), id)
-
+	ui.Titleln("Article removed: %s (ID: %d)", article.Title, id)
 	return nil
 }
 
···
 func (h *ArticleHandler) Help() error {
 	domains := h.parser.GetSupportedDomains()
 
-	fmt.Println()
+	ui.Newline()
 
 	if len(domains) > 0 {
-		fmt.Printf("%s\n", ui.HeaderColorStyle.Render(fmt.Sprintf("Supported sites (%d):", len(domains))))
+		ui.Headerln("Supported sites (%d):", len(domains))
 		for _, domain := range domains {
-			fmt.Printf("  - %s\n", domain)
+			ui.Plainln("  - %s", domain)
 		}
 	} else {
-		fmt.Println("No parsing rules loaded.")
+		ui.Plainln("No parsing rules loaded.")
 	}
 
-	fmt.Println()
+	ui.Newline()
 	dir, err := h.getStorageDirectory()
 	if err != nil {
 		return fmt.Errorf("failed to get storage directory: %w", err)
 	}
-	fmt.Printf("%s %s\n", ui.HeaderColorStyle.Render("Storage directory:"), dir)
+	ui.Headerln("%s %s", ui.HeaderColorStyle.Render("Storage directory:"), dir)
 
 	return nil
 }
···
 }
 
 func (h *ArticleHandler) getStorageDirectory() (string, error) {
-	// Check config first
 	if h.config.ArticlesDir != "" {
 		return h.config.ArticlesDir, nil
 	}
 
-	// Fall back to data directory
 	dataDir, err := store.GetDataDir()
 	if err != nil {
 		return "", err
 	}
-
 	return filepath.Join(dataDir, "articles"), nil
 }

internal/handlers/seed.go

···
 
 	fmt.Println("Seeding database with test data...")
 
-	// Seed tasks
 	tasks := []struct {
 		description string
 		project     string
···
 		}
 	}
 
-	// Seed books
 	books := []struct {
 		title    string
 		author   string
···
 	}
 
 	fmt.Printf("Successfully seeded database with %d tasks and %d books\n", len(tasks), len(books))
-	fmt.Printf("\n%s\n", ui.Info.Render("Example commands to try:"))
-	fmt.Printf("  %s\n", ui.Success.Render("noteleaf todo list"))
-	fmt.Printf("  %s\n", ui.Success.Render("noteleaf media book list"))
-	fmt.Printf("  %s\n", ui.Success.Render("noteleaf todo view 1"))
+	fmt.Printf("\n%s\n", ui.InfoStyle.Render("Example commands to try:"))
+	fmt.Printf("  %s\n", ui.SuccessStyle.Render("noteleaf todo list"))
+	fmt.Printf("  %s\n", ui.SuccessStyle.Render("noteleaf media book list"))
+	fmt.Printf("  %s\n", ui.SuccessStyle.Render("noteleaf todo view 1"))
 
 	return nil
 }
···
 }
 
 func (h *SeedHandler) seedTask(description, project, priority, status string) error {
-	// Generate a simple UUID for the task (required field)
 	uuid := h.generateSimpleUUID()
 	query := `INSERT INTO tasks (uuid, description, project, priority, status, entry, modified)
 			  VALUES (?, ?, ?, ?, ?, datetime('now'), datetime('now'))`
···
 // generateSimpleUUID creates a simple UUID for seeding (not cryptographically secure, but sufficient for test data)
 func (h *SeedHandler) generateSimpleUUID() string {
 	now := time.Now()
-	// Add random component to avoid collisions during rapid seeding
 	randomNum := rand.Intn(10000)
 	return fmt.Sprintf("seed-task-%d-%d-%d", now.Unix(), now.UnixNano()%1000000, randomNum)
 }

internal/ui/colors.go

···
 	"image/color"
 	"slices"
 
-	"github.com/charmbracelet/lipgloss"
 	"github.com/lucasb-eyer/go-colorful"
-)
-
-var (
-	TitleColorStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
-	SelectedColorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("0")).Background(lipgloss.Color("212"))
-	HeaderColorStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Bold(true)
 )
 
 var _ color.Color = Key(0)

internal/ui/common.go

···
+// TODO: create variants of colored output without icons
+// TODO: refactor existing (relevant) calls to old styles
+// TODO: k v wrappers
+package ui
+
+import (
+	"fmt"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+func newStyle() lipgloss.Style              { return lipgloss.NewStyle() }
+func newPStyle(v, h int) lipgloss.Style     { return lipgloss.NewStyle().Padding(v, h) }
+func newBoldStyle() lipgloss.Style          { return newStyle().Bold(true) }
+func newPBoldStyle(v, h int) lipgloss.Style { return newPStyle(v, h).Bold(true) }
+func newEmStyle() lipgloss.Style            { return newStyle().Italic(true) }
+
+func success(msg string) string      { return SuccessStyle.Render("✓ " + msg) }
+func errorMsg(msg string) string     { return ErrorStyle.Render("✗ " + msg) }
+func warning(msg string) string      { return WarningStyle.Render("⚠ " + msg) }
+func info(msg string) string         { return InfoStyle.Render("ℹ " + msg) }
+func title(msg string) string        { return TitleStyle.Render(msg) }
+func subtitle(msg string) string     { return SubtitleStyle.Render(msg) }
+func box(content string) string      { return BoxStyle.Render(content) }
+func errorBox(content string) string { return ErrorBoxStyle.Render(content) }
+func text(content string) string     { return TextStyle.Render(content) }
+func header(content string) string   { return HeaderStyle.Render(content) }
+
+// Success prints a formatted success message
+func Success(format string, a ...any) {
+	fmt.Print(success(fmt.Sprintf(format, a...)))
+}
+
+// Successln prints a formatted success message with a newline
+func Successln(format string, a ...any) {
+	fmt.Println(success(fmt.Sprintf(format, a...)))
+}
+
+// Error prints a formatted error message
+func Error(format string, a ...any) {
+	fmt.Print(errorMsg(fmt.Sprintf(format, a...)))
+}
+
+// Errorln prints a formatted error message with a newline
+func Errorln(format string, a ...any) {
+	fmt.Println(errorMsg(fmt.Sprintf(format, a...)))
+}
+
+// Warning prints a formatted warning message
+func Warning(format string, a ...any) {
+	fmt.Print(warning(fmt.Sprintf(format, a...)))
+}
+
+// Warningln prints a formatted warning message with a newline
+func Warningln(format string, a ...any) {
+	fmt.Println(warning(fmt.Sprintf(format, a...)))
+}
+
+// Info prints a formatted info message
+func Info(format string, a ...any) {
+	fmt.Print(info(fmt.Sprintf(format, a...)))
+}
+
+// Infoln prints a formatted info message with a newline
+func Infoln(format string, a ...any) {
+	fmt.Println(info(fmt.Sprintf(format, a...)))
+}
+
+// Title prints a formatted title
+func Title(format string, a ...any) {
+	fmt.Print(title(fmt.Sprintf(format, a...)))
+}
+
+// Titleln prints a formatted title with a newline
+func Titleln(format string, a ...any) {
+	fmt.Println(title(fmt.Sprintf(format, a...)))
+}
+
+// Subtitle prints a formatted subtitle
+func Subtitle(format string, a ...any) {
+	fmt.Print(subtitle(fmt.Sprintf(format, a...)))
+}
+
+// Subtitleln prints a formatted subtitle with a newline
+func Subtitleln(format string, a ...any) {
+	fmt.Println(subtitle(fmt.Sprintf(format, a...)))
+}
+
+// Box prints content in a styled box
+func Box(format string, a ...any) {
+	fmt.Print(box(fmt.Sprintf(format, a...)))
+}
+
+// Boxln prints content in a styled box with a newline
+func Boxln(format string, a ...any) {
+	fmt.Println(box(fmt.Sprintf(format, a...)))
+}
+
+// ErrorBox prints error content in a styled error box
+func ErrorBox(format string, a ...any) {
+	fmt.Print(errorBox(fmt.Sprintf(format, a...)))
+}
+
+// ErrorBoxln prints error content in a styled error box with a newline
+func ErrorBoxln(format string, a ...any) {
+	fmt.Println(errorBox(fmt.Sprintf(format, a...)))
+}
+
+func Newline()                         { fmt.Println() }
+func Plain(format string, a ...any)    { fmt.Print(text(fmt.Sprintf(format, a...))) }
+func Plainln(format string, a ...any)  { fmt.Println(text(fmt.Sprintf(format, a...))) }
+func Header(format string, a ...any)   { fmt.Print(header(fmt.Sprintf(format, a...))) }
+func Headerln(format string, a ...any) { fmt.Print(header(fmt.Sprintf(format, a...))) }

internal/ui/logo.go

···
 // See https://patorjk.com/software/taag/
+//
+// NOTE: these aren't used anymore but are left in because they're cool
 package ui
 
 import (
···
 }
 
 // Colored returns a colored version of the logo using lipgloss with vertical spiral design
-//
 // Creates a vertical spiral effect by coloring character by character:
 //
 //	Combine line position and character position & use modulo to build wave-like transitions

internal/ui/palette.go

···
 	lipglossv2 "github.com/charmbracelet/lipgloss/v2"
 )
 
-var PrimaryColors []Key = []Key{
-	Guac,
-	Julep,
-	Bok,
-	Pickle,
-	NeueGuac,
-}
-
-var SecondaryColors []Key = []Key{
-	Malibu,
-	Sardine,
-	Lichen,
-}
-
-var TertiaryColors []Key = []Key{
-	Violet,
-	Mauve,
-	Plum,
-	Orchid,
-	Charple,
-	Hazy,
-}
-
-var ProvisionalColors []Key = []Key{NeueGuac, NeueZinc}
-
-var AdditionColors []Key = []Key{Pickle, Gator, Spinach}
-
-var DeletionColors []Key = []Key{Pom, Steak, Toast}
+var (
+	PrimaryColors     = []Key{Guac, Julep, Bok, Pickle, NeueGuac}
+	SecondaryColors   = []Key{Malibu, Sardine, Lichen}
+	TertiaryColors    = []Key{Violet, Mauve, Plum, Orchid, Charple, Hazy}
+	ProvisionalColors = []Key{NeueGuac, NeueZinc}
+	AdditionColors    = []Key{Pickle, Gator, Spinach}
+	DeletionColors    = []Key{Pom, Steak, Toast}
+)
 
 var NoteleafColorScheme fang.ColorSchemeFunc = noteleafColorScheme
 
···
 }
 
 var (
-	Success = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Julep.Hex())).
-		Bold(true)
-
-	Error = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Cherry.Hex())).
-		Bold(true)
-
-	Info = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Malibu.Hex()))
-
-	Warning = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Citron.Hex())).
-		Bold(true)
-
-	Path = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Mustard.Hex())).
-		Italic(true)
-)
-
-var (
-	TaskTitle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Salt.Hex())).
-			Bold(true)
-
-	TaskID = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Squid.Hex())).
-		Width(8)
-)
-
-var (
-	StatusPending = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Citron.Hex()))
-
-	StatusCompleted = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Julep.Hex()))
-)
-
-var (
-	PriorityHigh = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Cherry.Hex())).
-			Bold(true)
+	ColorPrimary = Thunder.Hex() // Blue
+	ColorAccent  = Cumin.Hex()   // Yellow/Gold
+	ColorError   = Paprika.Hex() // Red/Pink
+	ColorText    = Salt.Hex()    // Light text
+	ColorBG      = Pepper.Hex()  // Dark background
 
-	PriorityMedium = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Citron.Hex()))
+	PrimaryStyle      = newStyle().Foreground(lipgloss.Color(ColorPrimary))
+	AccentStyle       = newStyle().Foreground(lipgloss.Color(ColorAccent))
+	ErrorStyle        = newStyle().Foreground(lipgloss.Color(ColorError))
+	TextStyle         = newStyle().Foreground(lipgloss.Color(ColorText))
+	TitleStyle        = newPBoldStyle(0, 1).Foreground(lipgloss.Color(ColorAccent))
+	SubtitleStyle     = newEmStyle().Foreground(lipgloss.Color(ColorPrimary))
+	SuccessStyle      = newBoldStyle().Foreground(lipgloss.Color(ColorPrimary))
+	WarningStyle      = newBoldStyle().Foreground(lipgloss.Color(ColorAccent))
+	InfoStyle         = newStyle().Foreground(lipgloss.Color(ColorText))
+	BoxStyle          = newPStyle(1, 2).Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color(ColorPrimary))
+	ErrorBoxStyle     = newPStyle(1, 2).Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color(ColorError))
+	ListItemStyle     = newStyle().Foreground(lipgloss.Color(ColorText)).PaddingLeft(2)
+	SelectedItemStyle = newBoldStyle().Foreground(lipgloss.Color(ColorAccent)).PaddingLeft(2)
+	HeaderStyle       = newPBoldStyle(0, 1).Foreground(lipgloss.Color(ColorPrimary))
+	CellStyle         = newPStyle(0, 1).Foreground(lipgloss.Color(ColorText))
 
-	PriorityLow = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Squid.Hex()))
-)
+	TaskTitleStyle = newBoldStyle().Foreground(lipgloss.Color(Salt.Hex()))
+	TaskIDStyle    = newStyle().Foreground(lipgloss.Color(Squid.Hex())).Width(8)
 
-var (
-	MovieStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Coral.Hex())).
-			Bold(true)
+	StatusPending   = newStyle().Foreground(lipgloss.Color(Citron.Hex()))
+	StatusCompleted = newStyle().Foreground(lipgloss.Color(Julep.Hex()))
 
-	TVStyle = lipgloss.NewStyle().
-		Foreground(lipgloss.Color(Violet.Hex())).
-		Bold(true)
+	PriorityHigh   = newBoldStyle().Foreground(lipgloss.Color(Cherry.Hex()))
+	PriorityMedium = newStyle().Foreground(lipgloss.Color(Citron.Hex()))
+	PriorityLow    = newStyle().Foreground(lipgloss.Color(Squid.Hex()))
 
-	BookStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Guac.Hex())).
-			Bold(true)
+	MovieStyle = newBoldStyle().Foreground(lipgloss.Color(Coral.Hex()))
+	TVStyle    = newBoldStyle().Foreground(lipgloss.Color(Violet.Hex()))
+	BookStyle  = newBoldStyle().Foreground(lipgloss.Color(Guac.Hex()))
+	MusicStyle = newBoldStyle().Foreground(lipgloss.Color(Lichen.Hex()))
 
-	MusicStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Lichen.Hex())).
-			Bold(true)
-)
-
-// Table and UI styles
-var (
-	TableStyle = lipgloss.NewStyle().
-			BorderStyle(lipgloss.NormalBorder()).
-			BorderForeground(lipgloss.Color(Smoke.Hex()))
-
-	SelectedStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color(Salt.Hex())).
-			Background(lipgloss.Color(Squid.Hex())).
-			Bold(true)
-
-	HeaderStyle = lipgloss.NewStyle().
-			BorderStyle(lipgloss.NormalBorder()).
-			BorderForeground(lipgloss.Color(Smoke.Hex())).
-			BorderBottom(true).
-			Bold(false)
+	TableStyle         = newStyle().BorderStyle(lipgloss.NormalBorder()).BorderForeground(lipgloss.Color(Smoke.Hex()))
+	SelectedStyle      = newBoldStyle().Foreground(lipgloss.Color(Salt.Hex())).Background(lipgloss.Color(Squid.Hex()))
+	TitleColorStyle    = newBoldStyle().Foreground(lipgloss.Color("212"))
+	SelectedColorStyle = newBoldStyle().Foreground(lipgloss.Color("0")).Background(lipgloss.Color("212"))
+	HeaderColorStyle   = newBoldStyle().Foreground(lipgloss.Color("240"))
 )