feat: fix query and cleanup in db

fix.md

···
 - ✅ #14: No Rate Limiting (SSH, SCP, web, email)
 - ✅ #15: Token Generation (verify crypto/rand usage)
 
-## **P1 - High (Performance & Reliability)**
+## **P1 - High (Performance & Reliability)** ✅ COMPLETE
 
-- #8: N+1 Query Problem (batch operations)
-- #26: No Cleanup of Old seen_items (6 month cleanup job)
-- #23: Missing Graceful Shutdown for Scheduler (panic recovery)
+- ✅ #8: N+1 Query Problem (batch operations)
+- ✅ #26: No Cleanup of Old seen_items (6 month cleanup job)
+- ✅ #23: Missing Graceful Shutdown for Scheduler (panic recovery)
 
 ## **P2 - Medium (Code Quality & UX)**
 
···
 
 ## **Performance Issues**
 
-### 8. **N+1 Query Problem** 🐌
+### 8. **N+1 Query Problem** ✅
 
 **Location:** Multiple locations
 
 - `web/handlers.go:99-103` - Gets feeds for each config in a loop
 - `scheduler/scheduler.go` - Checks each item individually for seen status
 
-**Fix:** Batch operations:
-
-```go
-// Instead of checking each item individually
-seenGuids, err := s.store.GetSeenGUIDs(ctx, feedID, itemGUIDs)
-```
+**Fixed:** 
+- Added `GetSeenGUIDs()` batch method in `store/items.go` to check multiple items at once
+- Added `GetFeedsByConfigs()` batch method in `store/feeds.go` to fetch feeds for multiple configs
+- Updated `scheduler/scheduler.go:collectNewItems()` to use batch GUID checking
+- Updated `web/handlers.go` dashboard handler to batch fetch all feeds
 
 ### 9. **No Prepared Statements** 📝
 
···
 
 Some errors are `logger.Error`, some are `logger.Warn`. For example, feed fetch errors are `Warn` (line 89 of scheduler.go) but other errors are `Error`. Establish consistent criteria.
 
-### 23. **Missing Graceful Shutdown for Scheduler** 🛑
+### 23. **Missing Graceful Shutdown for Scheduler** ✅
 
 **Location:** `main.go:194-197`
 
-The scheduler runs in a goroutine with errgroup, but `Start()` only returns on context cancellation. If scheduler panics, errgroup won't capture it.
-
-**Fix:** Add defer recover in scheduler or use errgroup.Go properly.
+**Fixed:**
+- Added panic recovery with defer in `scheduler/scheduler.go:tick()` 
+- Added panic recovery wrapper in `main.go` scheduler goroutine
+- Added panic recovery in cleanup job
 
 ---
 
···
 
 You log `"email sent"` but don't verify SMTP actually accepted it (some SMTP servers queue and fail later).
 
-### 26. **No Cleanup of Old seen_items** 🧹
-
-The `seen_items` table will grow indefinitely. With the 3-month filter, items older than 3 months can be safely deleted.
+### 26. **No Cleanup of Old seen_items** ✅
 
-**Fix:** Add periodic cleanup job:
-
-```go
-DELETE FROM seen_items WHERE seen_at < datetime('now', '-6 months')
-```
+**Fixed:**
+- Added `CleanupOldSeenItems()` method in `store/items.go` to delete items older than specified duration
+- Added cleanup ticker in `scheduler/scheduler.go:Start()` that runs every 24 hours
+- Cleanup runs on startup and then daily, removing items older than 6 months
+- Added logging for cleanup operations showing number of items deleted
 
 ### 27. **No Feed Validation on Upload** 🔍
 

main.go

···
 	})
 
 	g.Go(func() error {
+		defer func() {
+			if r := recover(); r != nil {
+				logger.Error("scheduler panic", "panic", r)
+			}
+		}()
 		sched.Start(ctx)
 		return nil
 	})

scheduler/scheduler.go

···
 	ticker := time.NewTicker(s.interval)
 	defer ticker.Stop()
 
+	// Cleanup ticker runs every 24 hours
+	cleanupTicker := time.NewTicker(24 * time.Hour)
+	defer cleanupTicker.Stop()
+
 	s.logger.Info("scheduler started", "interval", s.interval)
 
+	// Run cleanup on start
+	s.cleanupOldSeenItems(ctx)
+
 	for {
 		select {
 		case <-ctx.Done():
···
 			return
 		case <-ticker.C:
 			s.tick(ctx)
+		case <-cleanupTicker.C:
+			s.cleanupOldSeenItems(ctx)
 		}
 	}
 }
 
+func (s *Scheduler) cleanupOldSeenItems(ctx context.Context) {
+	defer func() {
+		if r := recover(); r != nil {
+			s.logger.Error("panic during cleanup", "panic", r)
+		}
+	}()
+
+	// Delete items older than 6 months
+	deleted, err := s.store.CleanupOldSeenItems(ctx, 6*30*24*time.Hour)
+	if err != nil {
+		s.logger.Error("failed to cleanup old seen items", "err", err)
+		return
+	}
+	if deleted > 0 {
+		s.logger.Info("cleaned up old seen items", "deleted", deleted)
+	}
+}
+
 func (s *Scheduler) tick(ctx context.Context) {
+	defer func() {
+		if r := recover(); r != nil {
+			s.logger.Error("panic during tick", "panic", r)
+		}
+	}()
+
 	now := time.Now()
 	configs, err := s.store.GetDueConfigs(ctx, now)
 	if err != nil {
···
 			continue
 		}
 
-		var newItems []email.FeedItem
+		// Collect all GUIDs for this feed to batch check
+		var guids []string
 		for _, item := range result.Items {
 			if !item.Published.IsZero() && item.Published.Before(threeMonthsAgo) {
 				continue
 			}
+			guids = append(guids, item.GUID)
+		}
 
-			seen, err := s.store.IsItemSeen(ctx, result.FeedID, item.GUID)
-			if err != nil {
-				s.logger.Warn("failed to check if item seen", "err", err)
+		// Batch check which items have been seen
+		seenSet, err := s.store.GetSeenGUIDs(ctx, result.FeedID, guids)
+		if err != nil {
+			s.logger.Warn("failed to check seen items", "err", err)
+			continue
+		}
+
+		// Collect new items
+		var newItems []email.FeedItem
+		for _, item := range result.Items {
+			if !item.Published.IsZero() && item.Published.Before(threeMonthsAgo) {
 				continue
 			}
 
-			if !seen {
+			if !seenSet[item.GUID] {
 				newItems = append(newItems, email.FeedItem{
 					Title:     item.Title,
 					Link:      item.Link,

store/feeds.go

···
 	return feeds, rows.Err()
 }
 
+// GetFeedsByConfigs returns a map of configID to feeds for multiple configs in a single query
+func (db *DB) GetFeedsByConfigs(ctx context.Context, configIDs []int64) (map[int64][]*Feed, error) {
+	if len(configIDs) == 0 {
+		return make(map[int64][]*Feed), nil
+	}
+
+	// Build the query with the appropriate number of placeholders
+	args := make([]interface{}, len(configIDs))
+	placeholders := "?"
+	for i := 0; i < len(configIDs)-1; i++ {
+		placeholders += ",?"
+	}
+	for i, id := range configIDs {
+		args[i] = id
+	}
+
+	query := fmt.Sprintf(
+		`SELECT id, config_id, url, name, last_fetched, etag, last_modified
+		 FROM feeds WHERE config_id IN (%s) ORDER BY config_id, id`,
+		placeholders,
+	)
+
+	rows, err := db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query feeds: %w", err)
+	}
+	defer rows.Close()
+
+	feedMap := make(map[int64][]*Feed)
+	for rows.Next() {
+		var f Feed
+		if err := rows.Scan(&f.ID, &f.ConfigID, &f.URL, &f.Name, &f.LastFetched, &f.ETag, &f.LastModified); err != nil {
+			return nil, fmt.Errorf("scan feed: %w", err)
+		}
+		feedMap[f.ConfigID] = append(feedMap[f.ConfigID], &f)
+	}
+	
+	return feedMap, rows.Err()
+}
+
 func (db *DB) UpdateFeedFetched(ctx context.Context, feedID int64, etag, lastModified string) error {
 	var etagVal, lmVal sql.NullString
 	if etag != "" {

store/items.go

···
 	}
 	return items, rows.Err()
 }
+
+// GetSeenGUIDs returns a set of GUIDs that have been seen for a given feed
+func (db *DB) GetSeenGUIDs(ctx context.Context, feedID int64, guids []string) (map[string]bool, error) {
+	if len(guids) == 0 {
+		return make(map[string]bool), nil
+	}
+
+	// Build the query with the appropriate number of placeholders
+	args := make([]interface{}, 0, len(guids)+1)
+	args = append(args, feedID)
+	
+	placeholders := "?"
+	for i := 0; i < len(guids)-1; i++ {
+		placeholders += ",?"
+	}
+	for _, guid := range guids {
+		args = append(args, guid)
+	}
+
+	query := fmt.Sprintf(
+		`SELECT guid FROM seen_items WHERE feed_id = ? AND guid IN (%s)`,
+		placeholders,
+	)
+
+	rows, err := db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query seen guids: %w", err)
+	}
+	defer rows.Close()
+
+	seenSet := make(map[string]bool)
+	for rows.Next() {
+		var guid string
+		if err := rows.Scan(&guid); err != nil {
+			return nil, fmt.Errorf("scan guid: %w", err)
+		}
+		seenSet[guid] = true
+	}
+	
+	return seenSet, rows.Err()
+}
+
+// CleanupOldSeenItems deletes seen items older than the specified duration
+func (db *DB) CleanupOldSeenItems(ctx context.Context, olderThan time.Duration) (int64, error) {
+	cutoff := time.Now().Add(-olderThan)
+	result, err := db.ExecContext(ctx,
+		`DELETE FROM seen_items WHERE seen_at < ?`,
+		cutoff,
+	)
+	if err != nil {
+		return 0, fmt.Errorf("cleanup old seen items: %w", err)
+	}
+	
+	deleted, err := result.RowsAffected()
+	if err != nil {
+		return 0, fmt.Errorf("get rows affected: %w", err)
+	}
+	
+	return deleted, nil
+}

web/handlers.go

···
 		return
 	}
 
+	// Batch fetch all feeds for all configs
+	configIDs := make([]int64, len(configs))
+	for i, cfg := range configs {
+		configIDs[i] = cfg.ID
+	}
+	feedsByConfig, err := s.store.GetFeedsByConfigs(ctx, configIDs)
+	if err != nil {
+		s.logger.Error("get feeds by configs", "err", err)
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+
 	var configInfos []configInfo
 	var earliestNextRun time.Time
 	hasAnyActive := false
 
 	for _, cfg := range configs {
-		feeds, err := s.store.GetFeedsByConfig(ctx, cfg.ID)
-		if err != nil {
-			s.logger.Error("get feeds", "err", err)
-			continue
-		}
+		feeds := feedsByConfig[cfg.ID]
 
 		isActive := cfg.NextRun.Valid
 		if isActive {