fix: handle first-time feeds and fetch more items, remove fetch limit

internal/rss/feed.go

···
 }
 
 // FetchLatestItems fetches the latest items from an RSS feed
-func (c *Checker) FetchLatestItems(ctx context.Context, feedURL string, limit int) ([]*FeedItem, error) {
+func (c *Checker) FetchLatestItems(ctx context.Context, feedURL string) ([]*FeedItem, error) {
 	feed, err := c.parser.ParseURLWithContext(feedURL, ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse RSS feed: %w", err)
···
 
 	// Limit the number of items to return
 	maxItems := len(feed.Items)
-	if limit > 0 && limit < maxItems {
-		maxItems = limit
-	}
-
 	items := make([]*FeedItem, 0, maxItems)
 	for i := 0; i < maxItems; i++ {
 		item := feed.Items[i]

internal/rss/feed_test.go

···
 
 	// Test fetching all items
 	t.Run("FetchAllItems", func(t *testing.T) {
-		items, err := checker.FetchLatestItems(context.Background(), server.URL, 0)
+		items, err := checker.FetchLatestItems(context.Background(), server.URL)
 		if err != nil {
 			t.Fatalf("Failed to fetch items: %v", err)
 		}
···
 		}
 	})
 
-	// Test limiting items
-	t.Run("FetchLimitedItems", func(t *testing.T) {
-		items, err := checker.FetchLatestItems(context.Background(), server.URL, 2)
-		if err != nil {
-			t.Fatalf("Failed to fetch items: %v", err)
-		}
-
-		if len(items) != 2 {
-			t.Errorf("Expected 2 items, got %d", len(items))
-		}
-	})
-
 	// Test with context timeout
 	t.Run("ContextTimeout", func(t *testing.T) {
 		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
···
 
 		time.Sleep(2 * time.Millisecond) // Ensure context is expired
 
-		_, err := checker.FetchLatestItems(ctx, server.URL, 0)
+		_, err := checker.FetchLatestItems(ctx, server.URL)
 		if err == nil {
 			t.Error("Expected error with expired context, got nil")
 		}
···
 func TestFetchLatestItems_InvalidURL(t *testing.T) {
 	checker := NewChecker()
 
-	_, err := checker.FetchLatestItems(context.Background(), "not-a-valid-url", 0)
+	_, err := checker.FetchLatestItems(context.Background(), "not-a-valid-url")
 	if err == nil {
 		t.Error("Expected error with invalid URL, got nil")
 	}
···
 	defer server.Close()
 
 	checker := NewChecker()
-	items, err := checker.FetchLatestItems(context.Background(), server.URL, 0)
+	items, err := checker.FetchLatestItems(context.Background(), server.URL)
 
 	if err != nil {
 		t.Fatalf("Expected no error with empty feed, got: %v", err)
···
 	defer server.Close()
 
 	checker := NewChecker()
-	items, err := checker.FetchLatestItems(context.Background(), server.URL, 0)
+	items, err := checker.FetchLatestItems(context.Background(), server.URL)
 
 	if err != nil {
 		t.Fatalf("Failed to fetch items: %v", err)

main.go

···
 	if err != nil {
 		log.Fatalf("Failed to initialize storage: %v", err)
 	}
-
-	// Determine if this is the first run (no items in storage)
-	isFirstRun := store.Count() == 0
-	if isFirstRun {
-		log.Println("First run detected - will mark existing items as seen without posting")
-	} else {
-		log.Printf("Storage initialized with %d previously posted items", store.Count())
-	}
+	log.Printf("Storage initialized with %d previously posted items", store.Count())
 
 	rssChecker := rss.NewChecker()
 
···
 	defer ticker.Stop()
 
 	// Check immediately on startup
-	if err := checkAndPostFeeds(ctx, rssChecker, bskyClient, store, feeds, *dryRun, isFirstRun); err != nil {
+	if err := checkAndPostFeeds(ctx, rssChecker, bskyClient, store, feeds, *dryRun); err != nil {
 		log.Printf("Error during initial check: %v", err)
 	}
 
···
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
-			if err := checkAndPostFeeds(ctx, rssChecker, bskyClient, store, feeds, *dryRun, false); err != nil {
+			if err := checkAndPostFeeds(ctx, rssChecker, bskyClient, store, feeds, *dryRun); err != nil {
 				log.Printf("Error during check: %v", err)
 			}
 		}
···
 	return feeds
 }
 
-func checkAndPostFeeds(ctx context.Context, rssChecker *rss.Checker, bskyClient *bluesky.Client, store *storage.Storage, feedURLs []string, dryRun bool, isFirstRun bool) error {
+func checkAndPostFeeds(ctx context.Context, rssChecker *rss.Checker, bskyClient *bluesky.Client, store *storage.Storage, feedURLs []string, dryRun bool) error {
 	for _, feedURL := range feedURLs {
-		if err := checkAndPost(ctx, rssChecker, bskyClient, store, feedURL, dryRun, isFirstRun); err != nil {
+		if err := checkAndPost(ctx, rssChecker, bskyClient, store, feedURL, dryRun); err != nil {
 			log.Printf("Error checking feed %s: %v", feedURL, err)
 			// Continue with other feeds even if one fails
 		}
···
 	return nil
 }
 
-func checkAndPost(
-	ctx context.Context,
-	rssChecker *rss.Checker,
-	bskyClient *bluesky.Client,
-	store *storage.Storage,
-	feedURL string,
-	dryRun bool,
-	isFirstRun bool,
-) error {
+func checkAndPost(ctx context.Context, rssChecker *rss.Checker, bskyClient *bluesky.Client, store *storage.Storage, feedURL string, dryRun bool) error {
 	log.Printf("Checking RSS feed: %s", feedURL)
 
-	limit := 20
-	items, err := rssChecker.FetchLatestItems(ctx, feedURL, limit)
+	items, err := rssChecker.FetchLatestItems(ctx, feedURL)
 	if err != nil {
 		return fmt.Errorf("failed to fetch RSS items: %w", err)
 	}
 
 	log.Printf("Found %d items in feed", len(items))
 
+	// Check if this is the first time seeing this feed (no items from it in storage)
+	hasSeenFeedBefore := false
+	for _, item := range items {
+		if store.IsPosted(item.GUID) {
+			hasSeenFeedBefore = true
+			break
+		}
+	}
+
 	// Process items in reverse order (oldest first)
 	newItemCount := 0
 	postedCount := 0
···
 
 		newItemCount++
 
-		// On first run, just mark items as seen without posting
-		if isFirstRun {
+		// If this is first time seeing this feed, mark items as seen without posting
+		if !hasSeenFeedBefore {
 			if err := store.MarkPosted(item.GUID); err != nil {
 				log.Printf("Failed to mark item as seen: %v", err)
 			}
···
 		}
 
 		// Rate limiting - wait a bit between posts to avoid overwhelming Bluesky
-		if postedCount > 0 && !dryRun && !isFirstRun {
+		if postedCount > 0 && !dryRun {
 			time.Sleep(2 * time.Second)
 		}
 	}
 
-	if isFirstRun {
+	if !hasSeenFeedBefore {
 		if newItemCount > 0 {
-			log.Printf("Marked %d items as seen from feed %s", newItemCount, feedURL)
+			log.Printf("New feed detected: marked %d items as seen from %s (not posted)", newItemCount, feedURL)
 		}
 	} else {
 		if newItemCount == 0 {