@@ -24,8 +24,5 @@
 # env file
 .env
 
-# Editor/IDE
+# Honk
 .goosehints
-
-# Other
-old_code.ml

@@ -0,0 +1,65 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a
+Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-04-16
+
+### Added
+
+- Complete Go migration from original OCaml implementation
+- Date-based Bible verse progression system
+  - Calculates position based on day of year (1st January = Matthew 1:1-12)
+  - Shows 12 verses per day, cycling through all four Gospels yearly
+- ANSI color-coded output (green for book/chapter, yellow for verse range)
+- Smart lookahead rule: extends to end of chapter if less than 12 verses remain
+- Support for Polish "Nowa Biblia Gdańska" translation (`books/pol_nbg.json``)
+- Complete test suite with edge case validation
+- `README`` documentation with usage examples and algorithm explanation
+
+### Changed
+
+- **BREAKING**: Changed from bookmark-based progression to date-based progression
+  - Previous versions used `bookmark.toml` to track reading position
+  - New version calculates position from current date
+  - Backward incompatible with bookmark-based usage
+- Restructured codebase with modular Go packages:
+  - `internal/loader.go`: JSON Bible data loading and indexing
+  - `internal/dateprogression.go`: Date-to-verse position calculation
+  - `internal/formatter.go`: ANSI color formatting and text extraction
+  - `internal/verse.go`: Data structures and constants
+  - `internal/bookmark.go`: Legacy bookmark support (unused in date-based mode)
+
+### Fixed
+
+- Proper handling of chapter and book boundaries
+- Correct modulo wrapping for yearly cycle (total 3779 Gospel verses)
+- Leap year support via Go's standard `time.YearDay()` function
+- Validation of verse ranges and error handling
+
+### Removed
+
+- OCaml implementation (`old_code.ml` kept for reference)
+- Dependency on `bookmark.toml` file for progression
+- Regex-based verse parsing (replaced with direct JSON indexing)
+
+## [0.1.0] - 2026-04-16
+
+### Added
+
+- Initial Go port of OCaml Bible verse utility
+- Bookmark-based progression system (TOML file)
+- Support for Polish "Nowa Biblia Gdańska" translation
+- Basic ANSI color formatting
+- Lookahead rule implementation
+
+### Changed
+
+- Rewritten from OCaml to Go programming language
+- Changed data format from custom to JSON
+- Improved error handling and validation

@@ -1,19 +1,19 @@
 # `bibel` - Bible Verse CLI Utility
 
-A Go reimplementation of an OCaml utility for displaying Bible verses. This
-tool reads a bookmark file and displays a snippet of Bible text (typically 12
-verses), then updates the bookmark for the next run.
+A Go utility for displaying Bible verses. This tool shows Bible verses based on
+the current date, displaying 12 verses per day through the four Gospels.
 
 ## Features
 
-- **Progressive Reading**: Automatically advances through the first four books
-of the New Testament (Matthew, Mark, Luke, John)
+- **Date-Based Progression**: Automatically calculates position based on day of
+year (1 January = Matthew 1:1-12)
 - **Smart Sizing**: Default snippet size is 12 verses, extends to end of
 chapter if less than 12 verses remain
-- **Bookmark Persistence**: Saves reading position in a TOML file
-- **Color Output**: ANSI color-coded output (green for book/chapter, yellow for
-verse range)
-- **Simple CLI**: Run once to display current snippet and advance bookmark
+- **Colour Output**: ANSI color-coded output (green for book/chapter, yellow
+for verse range)
+- **Yearly Cycle**: Progresses through all four Gospels each year, restarting
+on 1 January
+- **Simple CLI**: Run to display today's Bible snippet
 
 ## Installation
 
@@ -28,10 +28,13 @@ ./bibel
 ```
 
 The program will:
-1. Read the current bookmark from `bookmark.toml` (creates default if not
-   exists)
-2. Display the Bible snippet for that bookmark with colored headers
-3. Calculate and save the next bookmark
+1. Calculate today's date and day of year
+2. Determine Bible position: day_of_year × 12 verses
+3. Find corresponding verses in the Gospels
+4. Display the Bible snippet with colored headers
+
+No bookmark file is needed or created - the position is calculated from the
+date alone.
 
 ## Data Format
 
@@ -52,21 +55,21 @@ ]
 }
 ```
 
-Books 40-43 correspond to the Evangelion:
+Books 40-43 correspond to the four Gospels:
 - 40: Matthew (Mateusza)
 - 41: Mark (Marek)
 - 42: Luke (Łukasz)
 - 43: John (Jana)
 
-## Bookmark Format
+## Date-Based Algorithm
 
-The bookmark file (`bookmark.toml`) uses TOML format:
-```toml
-book = 40        # Book index (40-43)
-chapter = 1      # Chapter number
-first_verse = 1  # First verse in range
-second_verse = 12 # Last verse in range
-```
+The program calculates reading position as follows:
+
+1. **Day of Year**: Get current day number (1-366)
+2. **Verse Offset**: Multiply by 12 verses per day: `offset = (day_of_year - 1) × 12`
+3. **Modulo Wrap**: Apply modulo with total Gospel verses (3779) to cycle yearly
+4. **Position Mapping**: Walk through Gospels to find corresponding verses
+5. **Lookahead Rule**: Extend to chapter end if less than 12 verses remain
 
 ## Project Structure
 
@@ -76,21 +79,19 @@ ├── cmd/bibel.go                 # Main CLI entry point
 ├── internal/bible/
 │   ├── verse.go                 # Data structures
 │   ├── loader.go                # JSON loading and indexing
-│   ├── bookmark.go              # Bookmark management
-│   └── formatter.go             # Output formatting
+│   ├── dateprogression.go       # Date-based position calculation
+│   ├── formatter.go             # Output formatting
+│   └── bookmark.go              # Legacy bookmark management (optional)
 ├── books/pol_nbg.json           # Bible data
 └── old_code.ml                  # Original OCaml implementation
 ```
 
-## Logic Details
+## Examples
 
-- **Advancement**: After displaying verses 1-12, next bookmark is 13-24 (or to
-end of chapter)
-- **Chapter Boundaries**: At chapter end, moves to next chapter in same book
-- **Book Boundaries**: At book end, moves to next book (loops from John back to
-Matthew)
-- **Lookahead Rule**: If less than 12 verses remain after current snippet,
-extends current snippet to end of chapter
+- **1 January**: Matthew 1:1-12
+- **2 January**: Matthew 1:13-25 (extends to end of chapter)
+- **16 April**: Mark 5:41-43
+- **31 December**: Matthew 18:7-18 (year wraps around)
 
 ## Development
 
@@ -98,16 +99,9 @@ ```bash
 # Build
 go build ./cmd/bibel.go
 
-# Run with current bookmark
+# Run with today's date
 ./bibel
 
-# Reset bookmark to Matthew 1:1-12
-echo 'book = 40
-chapter = 1
-first_verse = 1
-second_verse = 12' > bookmark.toml
+# Test with specific date (environment variable)
+GOOSE_TEST_DATE=2026-01-01 ./bibel
 ```
-
-## License
-
-See the original Bible data for copyright information. The code is open source.

@@ -0,0 +1,4 @@
+book = 40
+chapter = 1
+first_verse = 13
+second_verse = 24

@@ -3,49 +3,37 @@
 import (
 	"fmt"
 	"os"
+	"time"
 
 	"maxwelljensen/bibel/internal"
 )
 
 func main() {
-	// TEST: Initialise components
-	biblePath := "books/pol_nbg.json"
-	bookmarkPath := "test/bookmark.toml"
-
 	// Load Bible data
+	biblePath := "books/pol_nbg.json"
 	bibleData, err := bible.LoadBible(biblePath)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error loading Bible data: %v\n", err)
 		os.Exit(1)
 	}
 
-	// Initialise bookmark manager
-	bookmarkMgr := bible.NewBookmarkManager(bookmarkPath)
+	// Initialize date progression
+	dateProg := bible.NewDateProgression(bibleData)
 
-	// Read current bookmark
-	currentBookmark, err := bookmarkMgr.ReadBookmark()
+	// Get current date
+	currentDate := time.Now()
+	
+	// Calculate position for today
+	todayBookmark, err := dateProg.GetPositionForDate(currentDate)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error reading bookmark: %v\n", err)
+		fmt.Fprintf(os.Stderr, "Error calculating date position: %v\n", err)
 		os.Exit(1)
 	}
 
-	// Adjust bookmark based on lookahead rule
-	adjustedBookmark := bookmarkMgr.AdjustForLookahead(currentBookmark, bibleData)
-
-	// Initialise formatter
+	// Initialize formatter
 	formatter := bible.NewFormatter()
 
 	// Print header and snippet
-	fmt.Println(formatter.FormatHeader(adjustedBookmark))
-	fmt.Println(formatter.ExtractAndFormat(bibleData, adjustedBookmark))
-
-	// Calculate next bookmark
-	nextBookmark := bookmarkMgr.AdvanceBookmark(adjustedBookmark, bibleData)
-
-	// Write next bookmark
-	if err := bookmarkMgr.WriteBookmark(nextBookmark); err != nil {
-		fmt.Fprintf(os.Stderr, "Error writing next bookmark: %v\n", err)
-		os.Exit(1)
-	}
-}
-
+	fmt.Println(formatter.FormatHeader(todayBookmark))
+	fmt.Println(formatter.ExtractAndFormat(bibleData, todayBookmark))
+}

@@ -1,5 +1,3 @@
 module maxwelljensen/bibel
 
 go 1.25.8
-
-require github.com/pelletier/go-toml/v2 v2.3.0 // indirect

@@ -1,157 +0,0 @@
-package bible
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/pelletier/go-toml/v2"
-)
-
-const (
-	defaultBookmarkFile = "bookmark.toml"
-)
-
-// BookmarkManager handles reading and writing bookmarks
-type BookmarkManager struct {
-	FilePath string
-}
-
-// NewBookmarkManager creates a new bookmark manager
-func NewBookmarkManager(filePath string) *BookmarkManager {
-	if filePath == "" {
-		filePath = defaultBookmarkFile
-	}
-	return &BookmarkManager{FilePath: filePath}
-}
-
-// ReadBookmark reads a bookmark from the file
-func (bm *BookmarkManager) ReadBookmark() (*Bookmark, error) {
-	data, err := os.ReadFile(bm.FilePath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			// Return default bookmark if file doesn't exist
-			return &Bookmark{
-				Book:        Matthew,
-				Chapter:     1,
-				FirstVerse:  1,
-				SecondVerse: 12,
-			}, nil
-		}
-		return nil, err
-	}
-	
-	var bookmark Bookmark
-	if err := toml.Unmarshal(data, &bookmark); err != nil {
-		return nil, fmt.Errorf("failed to parse bookmark file: %w", err)
-	}
-	
-	// Validate bookmark values
-	if bookmark.Book < Matthew || bookmark.Book > John {
-		bookmark.Book = Matthew
-	}
-	if bookmark.Chapter < 1 {
-		bookmark.Chapter = 1
-	}
-	if bookmark.FirstVerse < 1 {
-		bookmark.FirstVerse = 1
-	}
-	if bookmark.SecondVerse < bookmark.FirstVerse {
-		bookmark.SecondVerse = bookmark.FirstVerse
-	}
-	
-	return &bookmark, nil
-}
-
-// WriteBookmark writes a bookmark to the file
-func (bm *BookmarkManager) WriteBookmark(bookmark *Bookmark) error {
-	data, err := toml.Marshal(bookmark)
-	if err != nil {
-		return fmt.Errorf("failed to marshal bookmark: %w", err)
-	}
-	
-	// Create directory if it doesn't exist
-	dir := filepath.Dir(bm.FilePath)
-	if dir != "" && dir != "." {
-		if err := os.MkdirAll(dir, 0755); err != nil {
-			return fmt.Errorf("failed to create directory: %w", err)
-		}
-	}
-	
-	if err := os.WriteFile(bm.FilePath, data, 0644); err != nil {
-		return fmt.Errorf("failed to write bookmark file: %w", err)
-	}
-	
-	return nil
-}
-
-// AdjustForLookahead adjusts the bookmark if less than 12 verses remain after it
-func (bm *BookmarkManager) AdjustForLookahead(bookmark *Bookmark, bible *Bible) *Bookmark {
-	versesInChapter := bible.CountVersesInChapter(int(bookmark.Book), bookmark.Chapter)
-	versesRemaining := versesInChapter - bookmark.SecondVerse
-	
-	// If we're not at the end of the chapter and less than 12 verses remain for NEXT snippet
-	if versesRemaining > 0 && versesRemaining < 12 {
-		return &Bookmark{
-			Book:        bookmark.Book,
-			Chapter:     bookmark.Chapter,
-			FirstVerse:  bookmark.FirstVerse,
-			SecondVerse: versesInChapter,
-		}
-	}
-	
-	// Otherwise return the original bookmark
-	return bookmark
-}
-
-// AdvanceBookmark calculates the next bookmark based on the current one
-func (bm *BookmarkManager) AdvanceBookmark(current *Bookmark, bible *Bible) *Bookmark {
-	versesInChapter := bible.CountVersesInChapter(int(current.Book), current.Chapter)
-	
-	// Case 1: We are at the end of the chapter, move to the next chapter
-	if current.SecondVerse >= versesInChapter {
-		nextChapter := current.Chapter + 1
-		
-		// Check if next chapter exists in current book
-		if bible.CountVersesInChapter(int(current.Book), nextChapter) > 0 {
-			return &Bookmark{
-				Book:        current.Book,
-				Chapter:     nextChapter,
-				FirstVerse:  1,
-				SecondVerse: min(12, bible.CountVersesInChapter(int(current.Book), nextChapter)),
-			}
-		}
-		
-		// End of book, move to next book or loop to Matthew
-		nextBookInt := int(current.Book) + 1
-		if nextBookInt > int(John) {
-			nextBookInt = int(Matthew)
-		}
-		
-		nextBook := BookIndex(nextBookInt)
-		return &Bookmark{
-			Book:        nextBook,
-			Chapter:     1,
-			FirstVerse:  1,
-			SecondVerse: min(12, bible.CountVersesInChapter(int(nextBook), 1)),
-		}
-	}
-	
-	// Case 2: We are in the middle of a chapter, advance verses
-	newFirstVerse := current.SecondVerse + 1
-	newSecondVerse := min(newFirstVerse+11, versesInChapter)
-	
-	return &Bookmark{
-		Book:        current.Book,
-		Chapter:     current.Chapter,
-		FirstVerse:  newFirstVerse,
-		SecondVerse: newSecondVerse,
-	}
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

@@ -0,0 +1,115 @@
+package bible
+
+import (
+	"fmt"
+	"time"
+)
+
+// DateProgression handles calculating Bible position based on date
+type DateProgression struct {
+	bible *Bible
+}
+
+// NewDateProgression creates a new date progression calculator
+func NewDateProgression(bible *Bible) *DateProgression {
+	return &DateProgression{bible: bible}
+}
+
+// GetPositionForDate calculates the verse range for a given date
+func (dp *DateProgression) GetPositionForDate(date time.Time) (*Bookmark, error) {
+	// Calculate day of year (1-366)
+	dayOfYear := date.YearDay()
+	
+	// Each day shows 12 verses
+	targetVerseOffset := (dayOfYear - 1) * 12 // Zero-indexed
+	
+	// Walk through Gospels to find the position
+	return dp.findPositionForOffset(targetVerseOffset)
+}
+
+// findPositionForOffset finds the bookmark for a given cumulative verse offset
+func (dp *DateProgression) findPositionForOffset(offset int) (*Bookmark, error) {
+	// Iterate through books 40-43 (Matthew, Mark, Luke, John)
+	for book := 40; book <= 43; book++ {
+		// Find last chapter in this book
+		maxChapter := 0
+		for chapter := 1; ; chapter++ {
+			if dp.bible.CountVersesInChapter(book, chapter) == 0 {
+				maxChapter = chapter - 1
+				break
+			}
+		}
+		
+		// Iterate through chapters
+		for chapter := 1; chapter <= maxChapter; chapter++ {
+			versesInChapter := dp.bible.CountVersesInChapter(book, chapter)
+			
+			// Check if offset falls within this chapter
+			if offset < versesInChapter {
+				// Offset is within this chapter
+				firstVerse := offset + 1 // Convert from 0-indexed to 1-indexed
+				
+				// Create initial bookmark (like AdvanceBookmark does)
+				secondVerse := min(firstVerse+11, versesInChapter)
+				bookmark := &Bookmark{
+					Book:        BookIndex(book),
+					Chapter:     chapter,
+					FirstVerse:  firstVerse,
+					SecondVerse: secondVerse,
+				}
+				
+				// Apply lookahead rule (like AdjustForLookahead)
+				return dp.applyLookahead(bookmark), nil
+			}
+			
+			// Move to next chapter, subtracting this chapter's verses
+			offset -= versesInChapter
+		}
+	}
+	
+	// If we've gone through all Gospels and offset is still positive,
+	// wrap around to beginning (start over)
+	// Calculate modulo offset within total Gospel verses
+	totalVerses := dp.GetTotalGospelVerses()
+	if offset >= 0 {
+		adjustedOffset := offset % totalVerses
+		// Recursively find position for adjusted offset
+		return dp.findPositionForOffset(adjustedOffset)
+	}
+	
+	return nil, fmt.Errorf("could not find position for offset %d", offset)
+}
+
+// applyLookahead applies the lookahead rule (same as BookmarkManager.AdjustForLookahead)
+func (dp *DateProgression) applyLookahead(bookmark *Bookmark) *Bookmark {
+	versesInChapter := dp.bible.CountVersesInChapter(int(bookmark.Book), bookmark.Chapter)
+	versesRemaining := versesInChapter - bookmark.SecondVerse
+	
+	// If we're not at the end of the chapter and less than 12 verses remain for NEXT snippet
+	if versesRemaining > 0 && versesRemaining < 12 {
+		return &Bookmark{
+			Book:        bookmark.Book,
+			Chapter:     bookmark.Chapter,
+			FirstVerse:  bookmark.FirstVerse,
+			SecondVerse: versesInChapter,
+		}
+	}
+	
+	// Otherwise return the original bookmark
+	return bookmark
+}
+
+// GetTotalGospelVerses returns the total number of verses in all four Gospels
+func (dp *DateProgression) GetTotalGospelVerses() int {
+	total := 0
+	for book := 40; book <= 43; book++ {
+		for chapter := 1; ; chapter++ {
+			verses := dp.bible.CountVersesInChapter(book, chapter)
+			if verses == 0 {
+				break
+			}
+			total += verses
+		}
+	}
+	return total
+}

@@ -1,4 +0,0 @@
-book = 99
-chapter = 100
-first_verse = 1
-second_verse = 12

@@ -1,4 +0,0 @@
-book = 40
-chapter = 9
-first_verse = 1
-second_verse = 12