feat: article migrations & model code

go.mod

···
 	golang.org/x/time v0.12.0
 )
 
+require github.com/gomarkdown/markdown v0.0.0-20250810172220-2e2c11897d1a // indirect
+
 require (
 	github.com/PuerkitoBio/goquery v1.10.3
 	github.com/andybalholm/cascadia v1.3.3 // indirect

go.sum

···
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/gomarkdown/markdown v0.0.0-20250810172220-2e2c11897d1a h1:l7A0loSszR5zHd/qK53ZIHMO8b3bBSmENnQ6eKnUT0A=
+github.com/gomarkdown/markdown v0.0.0-20250810172220-2e2c11897d1a/go.mod h1:JDGcbDT52eL4fju3sZ4TeHGsQwhG9nbDV21aMyhwPoA=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

internal/models/models.go

···
 
 import (
 	"encoding/json"
+	"net/url"
 	"slices"
 	"time"
 )
···
 	Description     string     `json:"description,omitempty"`
 	Created         time.Time  `json:"created"`
 	Modified        time.Time  `json:"modified"`
+}
+
+// Article represents a parsed article from a web URL
+type Article struct {
+	ID           int64     `json:"id"`
+	URL          string    `json:"url"`
+	Title        string    `json:"title"`
+	Author       string    `json:"author,omitempty"`
+	Date         string    `json:"date,omitempty"`
+	MarkdownPath string    `json:"markdown_path"`
+	HTMLPath     string    `json:"html_path"`
+	Created      time.Time `json:"created"`
+	Modified     time.Time `json:"modified"`
 }
 
 // MarshalTags converts tags slice to JSON string for database storage
···
 func (te *TimeEntry) SetCreatedAt(time time.Time) { te.Created = time }
 func (te *TimeEntry) GetUpdatedAt() time.Time     { return te.Modified }
 func (te *TimeEntry) SetUpdatedAt(time time.Time) { te.Modified = time }
+
+func (a *Article) GetID() int64                { return a.ID }
+func (a *Article) SetID(id int64)              { a.ID = id }
+func (a *Article) GetTableName() string        { return "articles" }
+func (a *Article) GetCreatedAt() time.Time     { return a.Created }
+func (a *Article) SetCreatedAt(time time.Time) { a.Created = time }
+func (a *Article) GetUpdatedAt() time.Time     { return a.Modified }
+func (a *Article) SetUpdatedAt(time time.Time) { a.Modified = time }
+
+// IsValidURL returns true if the article has parseable URL
+func (a *Article) IsValidURL() bool {
+	_, err := url.ParseRequestURI(a.URL)
+	return err == nil
+}
+
+// HasAuthor returns true if the article has an author
+func (a *Article) HasAuthor() bool {
+	return a.Author != ""
+}
+
+// HasDate returns true if the article has a date
+func (a *Article) HasDate() bool {
+	return a.Date != ""
+}

internal/models/models_test.go

···
 
 import (
 	"encoding/json"
+	"fmt"
 	"testing"
 	"time"
 )
 
 func TestModels(t *testing.T) {
-	t.Run("Task Model", func(t *testing.T) {
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			task := &Task{
-				ID:          1,
-				UUID:        "test-uuid",
-				Description: "Test task",
-				Status:      "pending",
-				Entry:       time.Now(),
-				Modified:    time.Now(),
-			}
+	t.Run("Model Interface", func(t *testing.T) {
+		now := time.Now()
+		time.Sleep(time.Duration(500) * time.Duration(time.Millisecond))
+		updated := time.Now()
+
+		for i, tc := range []struct {
+			name        string
+			model       Model
+			unmarshaled Model
+		}{
+			{name: "Task", model: &Task{ID: 1, Entry: now, Modified: updated}, unmarshaled: &Task{}},
+			{name: "Movie", model: &Movie{ID: 1, Title: "Test Movie", Year: 2023, Added: now}, unmarshaled: &Movie{}},
+			{name: "TVShow", model: &TVShow{ID: 1, Title: "Test Show", Added: now}, unmarshaled: &TVShow{}},
+			{name: "Book", model: &Book{ID: 1, Title: "Test Book", Added: now}, unmarshaled: &Book{}},
+			{name: "Note", model: &Note{ID: 1, Title: "Test Note", Content: "This is test content", Created: now}, unmarshaled: &Note{}},
+			{name: "Album", model: &Album{ID: 1, Title: "Test Album", Artist: "Test Artist", Created: now}, unmarshaled: &Album{}},
+			{name: "TimeEntry", model: &TimeEntry{ID: 1, TaskID: 100, Created: now, Modified: updated}, unmarshaled: &TimeEntry{}},
+			{name: "Article", model: &Article{ID: 1, Created: now, Modified: updated}, unmarshaled: &Article{}},
+		} {
+			model := tc.model
+			t.Run(fmt.Sprintf("%v Implementation", tc.name), func(t *testing.T) {
+				model.SetID(int64(i + 1))
+				if model.GetID() != int64(i+1) {
+					t.Errorf("Model %d: ID not set correctly", i)
+				}
+
+				tableName := model.GetTableName()
+				if tableName == "" {
+					t.Errorf("Model %d: table name should not be empty", i)
+				}
+
+				now = time.Now()
+				model.SetCreatedAt(now)
+				// NOTE: We don't test exact equality due to potential precision differences
+				if model.GetCreatedAt().IsZero() {
+					t.Errorf("Model %d: created at should not be zero", i)
+				}
 
-			if task.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", task.GetID())
-			}
+				updatedAt := time.Now().Add(time.Hour)
+				model.SetUpdatedAt(updatedAt)
+				if !model.GetUpdatedAt().Equal(updatedAt) {
+					t.Errorf("Expected updated at %v, got %v", updatedAt, model.GetUpdatedAt())
+				}
 
-			task.SetID(2)
-			if task.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", task.GetID())
-			}
+				if model.GetUpdatedAt().IsZero() {
+					t.Errorf("Model %d: updated at should not be zero", i)
+				}
+				model.SetUpdatedAt(now)
 
-			if task.GetTableName() != "tasks" {
-				t.Errorf("Expected table name 'tasks', got '%s'", task.GetTableName())
-			}
+				t.Run(fmt.Sprintf("%v JSON Marshal/Unmarshal", tc.name), func(t *testing.T) {
+					if data, err := json.Marshal(model); err != nil {
+						t.Fatalf("JSON marshal failed: %v", err)
+					} else {
+						var unmarshaled = tc.unmarshaled
+						if err = json.Unmarshal(data, &unmarshaled); err != nil {
+							t.Fatalf("JSON unmarshal failed: %v", err)
+						}
 
-			createdAt := time.Now()
-			task.SetCreatedAt(createdAt)
-			if !task.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, task.GetCreatedAt())
-			}
+						if unmarshaled.GetID() != model.GetID() {
+							t.Fatalf("IDs should be the same")
+						}
+					}
+				})
+			})
+		}
 
-			updatedAt := time.Now().Add(time.Hour)
-			task.SetUpdatedAt(updatedAt)
-			if !task.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, task.GetUpdatedAt())
-			}
-		})
+	})
 
+	t.Run("Task Model", func(t *testing.T) {
 		t.Run("Status Methods", func(t *testing.T) {
 			testCases := []struct {
 				status      string
···
 			}
 		})
 
-		t.Run("JSON Marshaling", func(t *testing.T) {
-			now := time.Now()
-			due := now.Add(24 * time.Hour)
-			task := &Task{
-				ID:          1,
-				UUID:        "test-uuid",
-				Description: "Test task",
-				Status:      "pending",
-				Priority:    "A",
-				Project:     "test-project",
-				Tags:        []string{"work", "urgent"},
-				Due:         &due,
-				Entry:       now,
-				Modified:    now,
-				Annotations: []string{"Note 1"},
-			}
-
-			data, err := json.Marshal(task)
-			if err != nil {
-				t.Fatalf("JSON marshal failed: %v", err)
-			}
-
-			var unmarshaled Task
-			err = json.Unmarshal(data, &unmarshaled)
-			if err != nil {
-				t.Fatalf("JSON unmarshal failed: %v", err)
-			}
-
-			if unmarshaled.ID != task.ID {
-				t.Errorf("Expected ID %d, got %d", task.ID, unmarshaled.ID)
-			}
-			if unmarshaled.UUID != task.UUID {
-				t.Errorf("Expected UUID %s, got %s", task.UUID, unmarshaled.UUID)
-			}
-			if unmarshaled.Description != task.Description {
-				t.Errorf("Expected description %s, got %s", task.Description, unmarshaled.Description)
-			}
-		})
 	})
 
 	t.Run("Movie Model", func(t *testing.T) {
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			movie := &Movie{
-				ID:    1,
-				Title: "Test Movie",
-				Year:  2023,
-				Added: time.Now(),
-			}
-
-			if movie.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", movie.GetID())
-			}
-
-			movie.SetID(2)
-			if movie.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", movie.GetID())
-			}
-
-			if movie.GetTableName() != "movies" {
-				t.Errorf("Expected table name 'movies', got '%s'", movie.GetTableName())
-			}
-
-			createdAt := time.Now()
-			movie.SetCreatedAt(createdAt)
-			if !movie.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, movie.GetCreatedAt())
-			}
-
-			updatedAt := time.Now().Add(time.Hour)
-			movie.SetUpdatedAt(updatedAt)
-			if !movie.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, movie.GetUpdatedAt())
-			}
-		})
-
 		t.Run("Status Methods", func(t *testing.T) {
 			testCases := []struct {
 				status    string
···
 				}
 			}
 		})
-
-		t.Run("JSON Marshaling", func(t *testing.T) {
-			now := time.Now()
-			watched := now.Add(-24 * time.Hour)
-			movie := &Movie{
-				ID:      1,
-				Title:   "Test Movie",
-				Year:    2023,
-				Status:  "watched",
-				Rating:  8.5,
-				Notes:   "Great movie!",
-				Added:   now,
-				Watched: &watched,
-			}
-
-			data, err := json.Marshal(movie)
-			if err != nil {
-				t.Fatalf("JSON marshal failed: %v", err)
-			}
-
-			var unmarshaled Movie
-			err = json.Unmarshal(data, &unmarshaled)
-			if err != nil {
-				t.Fatalf("JSON unmarshal failed: %v", err)
-			}
-
-			if unmarshaled.ID != movie.ID {
-				t.Errorf("Expected ID %d, got %d", movie.ID, unmarshaled.ID)
-			}
-			if unmarshaled.Title != movie.Title {
-				t.Errorf("Expected title %s, got %s", movie.Title, unmarshaled.Title)
-			}
-			if unmarshaled.Rating != movie.Rating {
-				t.Errorf("Expected rating %f, got %f", movie.Rating, unmarshaled.Rating)
-			}
-		})
 	})
 
 	t.Run("TV Show Model", func(t *testing.T) {
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			tvShow := &TVShow{
-				ID:    1,
-				Title: "Test Show",
-				Added: time.Now(),
-			}
-
-			if tvShow.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", tvShow.GetID())
-			}
-
-			tvShow.SetID(2)
-			if tvShow.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", tvShow.GetID())
-			}
-
-			if tvShow.GetTableName() != "tv_shows" {
-				t.Errorf("Expected table name 'tv_shows', got '%s'", tvShow.GetTableName())
-			}
-
-			createdAt := time.Now()
-			tvShow.SetCreatedAt(createdAt)
-			if !tvShow.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, tvShow.GetCreatedAt())
-			}
-
-			updatedAt := time.Now().Add(time.Hour)
-			tvShow.SetUpdatedAt(updatedAt)
-			if !tvShow.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, tvShow.GetUpdatedAt())
-			}
-		})
-
 		t.Run("Status Methods", func(t *testing.T) {
 			testCases := []struct {
 				status     string
···
 				}
 			}
 		})
-
-		t.Run("JSON Marshaling", func(t *testing.T) {
-			now := time.Now()
-			lastWatched := now.Add(-24 * time.Hour)
-			tvShow := &TVShow{
-				ID:          1,
-				Title:       "Test Show",
-				Season:      1,
-				Episode:     5,
-				Status:      "watching",
-				Rating:      9.0,
-				Notes:       "Amazing series!",
-				Added:       now,
-				LastWatched: &lastWatched,
-			}
-
-			data, err := json.Marshal(tvShow)
-			if err != nil {
-				t.Fatalf("JSON marshal failed: %v", err)
-			}
-
-			var unmarshaled TVShow
-			err = json.Unmarshal(data, &unmarshaled)
-			if err != nil {
-				t.Fatalf("JSON unmarshal failed: %v", err)
-			}
-
-			if unmarshaled.ID != tvShow.ID {
-				t.Errorf("Expected ID %d, got %d", tvShow.ID, unmarshaled.ID)
-			}
-			if unmarshaled.Title != tvShow.Title {
-				t.Errorf("Expected title %s, got %s", tvShow.Title, unmarshaled.Title)
-			}
-			if unmarshaled.Season != tvShow.Season {
-				t.Errorf("Expected season %d, got %d", tvShow.Season, unmarshaled.Season)
-			}
-			if unmarshaled.Episode != tvShow.Episode {
-				t.Errorf("Expected episode %d, got %d", tvShow.Episode, unmarshaled.Episode)
-			}
-		})
 	})
 
 	t.Run("Book Model", func(t *testing.T) {
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			book := &Book{
-				ID:    1,
-				Title: "Test Book",
-				Added: time.Now(),
-			}
-
-			if book.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", book.GetID())
-			}
-
-			book.SetID(2)
-			if book.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", book.GetID())
-			}
-
-			if book.GetTableName() != "books" {
-				t.Errorf("Expected table name 'books', got '%s'", book.GetTableName())
-			}
-
-			createdAt := time.Now()
-			book.SetCreatedAt(createdAt)
-			if !book.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, book.GetCreatedAt())
-			}
-
-			updatedAt := time.Now().Add(time.Hour)
-			book.SetUpdatedAt(updatedAt)
-			if !book.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, book.GetUpdatedAt())
-			}
-		})
-
 		t.Run("Status Methods", func(t *testing.T) {
 			testCases := []struct {
 				status     string
···
 				t.Errorf("Expected progress 75%%, got %d%%", book.ProgressPercent())
 			}
 		})
-
-		t.Run("JSON Marshaling", func(t *testing.T) {
-			now := time.Now()
-			started := now.Add(-7 * 24 * time.Hour)
-			finished := now.Add(-24 * time.Hour)
-			book := &Book{
-				ID:       1,
-				Title:    "Test Book",
-				Author:   "Test Author",
-				Status:   "finished",
-				Progress: 100,
-				Pages:    300,
-				Rating:   4.5,
-				Notes:    "Excellent read!",
-				Added:    now,
-				Started:  &started,
-				Finished: &finished,
-			}
-
-			data, err := json.Marshal(book)
-			if err != nil {
-				t.Fatalf("JSON marshal failed: %v", err)
-			}
-
-			var unmarshaled Book
-			err = json.Unmarshal(data, &unmarshaled)
-			if err != nil {
-				t.Fatalf("JSON unmarshal failed: %v", err)
-			}
-
-			if unmarshaled.ID != book.ID {
-				t.Errorf("Expected ID %d, got %d", book.ID, unmarshaled.ID)
-			}
-			if unmarshaled.Title != book.Title {
-				t.Errorf("Expected title %s, got %s", book.Title, unmarshaled.Title)
-			}
-			if unmarshaled.Author != book.Author {
-				t.Errorf("Expected author %s, got %s", book.Author, unmarshaled.Author)
-			}
-			if unmarshaled.Progress != book.Progress {
-				t.Errorf("Expected progress %d, got %d", book.Progress, unmarshaled.Progress)
-			}
-			if unmarshaled.Pages != book.Pages {
-				t.Errorf("Expected pages %d, got %d", book.Pages, unmarshaled.Pages)
-			}
-		})
 	})
 
 	t.Run("Note Model", func(t *testing.T) {
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			note := &Note{
-				ID:      1,
-				Title:   "Test Note",
-				Content: "This is test content",
-				Created: time.Now(),
-			}
-
-			if note.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", note.GetID())
-			}
-
-			note.SetID(2)
-			if note.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", note.GetID())
-			}
-
-			if note.GetTableName() != "notes" {
-				t.Errorf("Expected table name 'notes', got '%s'", note.GetTableName())
-			}
-
-			createdAt := time.Now()
-			note.SetCreatedAt(createdAt)
-			if !note.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, note.GetCreatedAt())
-			}
-
-			updatedAt := time.Now().Add(time.Hour)
-			note.SetUpdatedAt(updatedAt)
-			if !note.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, note.GetUpdatedAt())
-			}
-		})
-
 		t.Run("Archive Methods", func(t *testing.T) {
 			note := &Note{Archived: false}
 
···
 				t.Error("Expected nil tags for empty string")
 			}
 		})
-
-		t.Run("JSON Marshaling", func(t *testing.T) {
-			now := time.Now()
-			modified := now.Add(time.Hour)
-			note := &Note{
-				ID:       1,
-				Title:    "Test Note",
-				Content:  "This is test content with **markdown**",
-				Tags:     []string{"personal", "markdown"},
-				Archived: false,
-				Created:  now,
-				Modified: modified,
-				FilePath: "/path/to/note.md",
-			}
-
-			data, err := json.Marshal(note)
-			if err != nil {
-				t.Fatalf("JSON marshal failed: %v", err)
-			}
-
-			var unmarshaled Note
-			err = json.Unmarshal(data, &unmarshaled)
-			if err != nil {
-				t.Fatalf("JSON unmarshal failed: %v", err)
-			}
-
-			if unmarshaled.ID != note.ID {
-				t.Errorf("Expected ID %d, got %d", note.ID, unmarshaled.ID)
-			}
-			if unmarshaled.Title != note.Title {
-				t.Errorf("Expected title %s, got %s", note.Title, unmarshaled.Title)
-			}
-			if unmarshaled.Content != note.Content {
-				t.Errorf("Expected content %s, got %s", note.Content, unmarshaled.Content)
-			}
-			if unmarshaled.Archived != note.Archived {
-				t.Errorf("Expected archived %v, got %v", note.Archived, unmarshaled.Archived)
-			}
-			if unmarshaled.FilePath != note.FilePath {
-				t.Errorf("Expected file path %s, got %s", note.FilePath, unmarshaled.FilePath)
-			}
-		})
 	})
 
 	t.Run("Album Model", func(t *testing.T) {
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			album := &Album{
-				ID:      1,
-				Title:   "Test Album",
-				Artist:  "Test Artist",
-				Created: time.Now(),
-			}
-
-			if album.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", album.GetID())
-			}
-
-			album.SetID(2)
-			if album.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", album.GetID())
-			}
-
-			if album.GetTableName() != "albums" {
-				t.Errorf("Expected table name 'albums', got '%s'", album.GetTableName())
-			}
-
-			createdAt := time.Now()
-			album.SetCreatedAt(createdAt)
-			if !album.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, album.GetCreatedAt())
-			}
-
-			updatedAt := time.Now().Add(time.Hour)
-			album.SetUpdatedAt(updatedAt)
-			if !album.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, album.GetUpdatedAt())
-			}
-		})
-
 		t.Run("Rating Methods", func(t *testing.T) {
 			album := &Album{}
 
···
 				t.Error("Album with valid rating should return true for IsValidRating")
 			}
 
-			testCases := []struct {
+			for _, tc := range []struct {
 				rating  int
 				isValid bool
-			}{
-				{0, false},
-				{1, true},
-				{3, true},
-				{5, true},
-				{6, false},
-				{-1, false},
-			}
-
-			for _, tc := range testCases {
+			}{{0, false}, {1, true}, {3, true}, {5, true}, {6, false}, {-1, false}} {
 				album.Rating = tc.rating
 				if album.IsValidRating() != tc.isValid {
 					t.Errorf("Rating %d: expected IsValidRating %v, got %v", tc.rating, tc.isValid, album.IsValidRating())
···
 		t.Run("Tracks Marshaling", func(t *testing.T) {
 			album := &Album{}
 
-			result, err := album.MarshalTracks()
-			if err != nil {
+			if result, err := album.MarshalTracks(); err != nil {
 				t.Fatalf("MarshalTracks failed: %v", err)
-			}
-			if result != "" {
-				t.Errorf("Expected empty string for empty tracks, got '%s'", result)
+			} else {
+				if result != "" {
+					t.Errorf("Expected empty string for empty tracks, got '%s'", result)
+				}
 			}
 
 			album.Tracks = []string{"Track 1", "Track 2", "Interlude"}
-			result, err = album.MarshalTracks()
+			result, err := album.MarshalTracks()
 			if err != nil {
 				t.Fatalf("MarshalTracks failed: %v", err)
 			}
 
-			expected := `["Track 1","Track 2","Interlude"]`
-			if result != expected {
+			if expected := `["Track 1","Track 2","Interlude"]`; result != expected {
 				t.Errorf("Expected %s, got %s", expected, result)
 			}
 
 			newAlbum := &Album{}
-			err = newAlbum.UnmarshalTracks(result)
-			if err != nil {
+			if err = newAlbum.UnmarshalTracks(result); err != nil {
 				t.Fatalf("UnmarshalTracks failed: %v", err)
-			}
+			} else {
+				if len(newAlbum.Tracks) != 3 {
+					t.Errorf("Expected 3 tracks, got %d", len(newAlbum.Tracks))
+				}
 
-			if len(newAlbum.Tracks) != 3 {
-				t.Errorf("Expected 3 tracks, got %d", len(newAlbum.Tracks))
-			}
-			if newAlbum.Tracks[0] != "Track 1" || newAlbum.Tracks[1] != "Track 2" || newAlbum.Tracks[2] != "Interlude" {
-				t.Errorf("Tracks not unmarshaled correctly: %v", newAlbum.Tracks)
+				if newAlbum.Tracks[0] != "Track 1" || newAlbum.Tracks[1] != "Track 2" || newAlbum.Tracks[2] != "Interlude" {
+					t.Errorf("Tracks not unmarshaled correctly: %v", newAlbum.Tracks)
+				}
 			}
 
 			emptyAlbum := &Album{}
-			err = emptyAlbum.UnmarshalTracks("")
-			if err != nil {
+			if err = emptyAlbum.UnmarshalTracks(""); err != nil {
 				t.Fatalf("UnmarshalTracks with empty string failed: %v", err)
-			}
-			if emptyAlbum.Tracks != nil {
+			} else if emptyAlbum.Tracks != nil {
 				t.Error("Expected nil tracks for empty string")
 			}
 		})
-
-		t.Run("JSON Marshaling", func(t *testing.T) {
-			now := time.Now()
-			modified := now.Add(time.Hour)
-			album := &Album{
-				ID:              1,
-				Title:           "Test Album",
-				Artist:          "Test Artist",
-				Genre:           "Rock",
-				ReleaseYear:     2023,
-				Tracks:          []string{"Track 1", "Track 2"},
-				DurationSeconds: 3600,
-				AlbumArtPath:    "/path/to/art.jpg",
-				Rating:          4,
-				Created:         now,
-				Modified:        modified,
-			}
-
-			data, err := json.Marshal(album)
-			if err != nil {
-				t.Fatalf("JSON marshal failed: %v", err)
-			}
-
-			var unmarshaled Album
-			err = json.Unmarshal(data, &unmarshaled)
-			if err != nil {
-				t.Fatalf("JSON unmarshal failed: %v", err)
-			}
-
-			if unmarshaled.ID != album.ID {
-				t.Errorf("Expected ID %d, got %d", album.ID, unmarshaled.ID)
-			}
-			if unmarshaled.Title != album.Title {
-				t.Errorf("Expected title %s, got %s", album.Title, unmarshaled.Title)
-			}
-			if unmarshaled.Artist != album.Artist {
-				t.Errorf("Expected artist %s, got %s", album.Artist, unmarshaled.Artist)
-			}
-			if unmarshaled.Genre != album.Genre {
-				t.Errorf("Expected genre %s, got %s", album.Genre, unmarshaled.Genre)
-			}
-			if unmarshaled.ReleaseYear != album.ReleaseYear {
-				t.Errorf("Expected release year %d, got %d", album.ReleaseYear, unmarshaled.ReleaseYear)
-			}
-			if unmarshaled.DurationSeconds != album.DurationSeconds {
-				t.Errorf("Expected duration %d, got %d", album.DurationSeconds, unmarshaled.DurationSeconds)
-			}
-			if unmarshaled.Rating != album.Rating {
-				t.Errorf("Expected rating %d, got %d", album.Rating, unmarshaled.Rating)
-			}
-		})
 	})
 
-	t.Run("Interface Implementations", func(t *testing.T) {
-		t.Run("All models implement Model interface", func(t *testing.T) {
-			var models []Model
-
-			task := &Task{}
-			movie := &Movie{}
-			tvShow := &TVShow{}
-			book := &Book{}
-			note := &Note{}
-			album := &Album{}
-
-			models = append(models, task, movie, tvShow, book, note, album)
-
-			if len(models) != 6 {
-				t.Errorf("Expected 6 models, got %d", len(models))
-			}
+	t.Run("Article Model", func(t *testing.T) {
+		article := Article{URL: "", Author: "", Date: ""}
+		want := false
 
-			for i, model := range models {
-				model.SetID(int64(i + 1))
-				if model.GetID() != int64(i+1) {
-					t.Errorf("Model %d: ID not set correctly", i)
-				}
-
-				tableName := model.GetTableName()
-				if tableName == "" {
-					t.Errorf("Model %d: table name should not be empty", i)
-				}
-
-				now := time.Now()
-				model.SetCreatedAt(now)
-				model.SetUpdatedAt(now)
-
-				// NOTE: We don't test exact equality due to potential precision differences
-				if model.GetCreatedAt().IsZero() {
-					t.Errorf("Model %d: created at should not be zero", i)
-				}
-				if model.GetUpdatedAt().IsZero() {
-					t.Errorf("Model %d: updated at should not be zero", i)
-				}
-			}
-		})
-	})
-
-	t.Run("Errors & Edge cases", func(t *testing.T) {
-		t.Run("Marshaling Errors", func(t *testing.T) {
-			t.Run("UnmarshalTags handles invalid JSON", func(t *testing.T) {
-				task := &Task{}
-				err := task.UnmarshalTags(`{"invalid": "json"}`)
-				if err == nil {
-					t.Error("Expected error for invalid JSON, got nil")
-				}
-			})
-
-			t.Run("UnmarshalAnnotations handles invalid JSON", func(t *testing.T) {
-				task := &Task{}
-				err := task.UnmarshalAnnotations(`{"invalid": "json"}`)
-				if err == nil {
-					t.Error("Expected error for invalid JSON, got nil")
-				}
-			})
-		})
-	})
-
-	t.Run("Edge Cases", func(t *testing.T) {
-		t.Run("Task with nil slices", func(t *testing.T) {
-			task := &Task{
-				Tags:        nil,
-				Annotations: nil,
-			}
-
-			tagsJSON, err := task.MarshalTags()
-			if err != nil {
-				t.Errorf("MarshalTags with nil slice failed: %v", err)
-			}
-			if tagsJSON != "" {
-				t.Errorf("Expected empty string for nil tags, got '%s'", tagsJSON)
-			}
-
-			annotationsJSON, err := task.MarshalAnnotations()
-			if err != nil {
-				t.Errorf("MarshalAnnotations with nil slice failed: %v", err)
-			}
-			if annotationsJSON != "" {
-				t.Errorf("Expected empty string for nil annotations, got '%s'", annotationsJSON)
-			}
-		})
-
-		t.Run("Models with zero values", func(t *testing.T) {
-			task := &Task{}
-			movie := &Movie{}
-			tvShow := &TVShow{}
-			book := &Book{}
-			note := &Note{}
-
-			if task.IsCompleted() || task.IsPending() || task.IsDeleted() {
-				t.Error("Zero value task should have false status methods")
-			}
-
-			if movie.IsWatched() || movie.IsQueued() {
-				t.Error("Zero value movie should have false status methods")
-			}
-
-			if tvShow.IsWatching() || tvShow.IsWatched() || tvShow.IsQueued() {
-				t.Error("Zero value TV show should have false status methods")
-			}
-
-			if book.IsReading() || book.IsFinished() || book.IsQueued() {
-				t.Error("Zero value book should have false status methods")
+		for _, tc := range []func() bool{article.HasAuthor, article.HasDate, article.IsValidURL} {
+			got := tc()
+			if got != want {
+				t.Errorf("wanted %v, got %v", want, got)
 			}
+		}
 
-			if book.ProgressPercent() != 0 {
-				t.Errorf("Zero value book should have 0%% progress, got %d%%", book.ProgressPercent())
-			}
+		article.URL = "http//wikipedia.org"
+		if article.IsValidURL() != want {
+			t.Errorf("%v is invalid but got valid", article.URL)
+		}
 
-			if note.IsArchived() {
-				t.Error("Zero value note should not be archived")
-			}
-		})
+		article.URL = "http://wikipedia.org"
+		if !article.IsValidURL() {
+			t.Errorf("%v should be valid", article.URL)
+		}
 	})
 
 	t.Run("TimeEntry Model", func(t *testing.T) {
···
 				}
 			})
 		})
+	})
 
-		t.Run("Model Interface Implementation", func(t *testing.T) {
-			now := time.Now()
-			te := &TimeEntry{
-				ID:       1,
-				TaskID:   100,
-				Created:  now,
-				Modified: now,
+	t.Run("Error Handling", func(t *testing.T) {
+		t.Run("Marshaling Errors", func(t *testing.T) {
+			t.Run("UnmarshalTags handles invalid JSON", func(t *testing.T) {
+				task := &Task{}
+				if err := task.UnmarshalTags(`{"invalid": "json"}`); err == nil {
+					t.Error("Expected error for invalid JSON, got nil")
+				}
+			})
+
+			t.Run("UnmarshalAnnotations handles invalid JSON", func(t *testing.T) {
+				task := &Task{}
+				if err := task.UnmarshalAnnotations(`{"invalid": "json"}`); err == nil {
+					t.Error("Expected error for invalid JSON, got nil")
+				}
+			})
+		})
+	})
+
+	t.Run("Edge Cases", func(t *testing.T) {
+		t.Run("Task with nil slices", func(t *testing.T) {
+			task := &Task{
+				Tags:        nil,
+				Annotations: nil,
 			}
 
-			if te.GetID() != 1 {
-				t.Errorf("Expected ID 1, got %d", te.GetID())
+			if tagsJSON, err := task.MarshalTags(); err != nil {
+				t.Errorf("MarshalTags with nil slice failed: %v", err)
+			} else if tagsJSON != "" {
+				t.Errorf("Expected empty string for nil tags, got '%s'", tagsJSON)
 			}
 
-			te.SetID(2)
-			if te.GetID() != 2 {
-				t.Errorf("Expected ID 2 after SetID, got %d", te.GetID())
+			if annotationsJSON, err := task.MarshalAnnotations(); err != nil {
+				t.Errorf("MarshalAnnotations with nil slice failed: %v", err)
+			} else if annotationsJSON != "" {
+				t.Errorf("Expected empty string for nil annotations, got '%s'", annotationsJSON)
 			}
+		})
 
-			if te.GetTableName() != "time_entries" {
-				t.Errorf("Expected table name 'time_entries', got '%s'", te.GetTableName())
+		t.Run("Models with zero values", func(t *testing.T) {
+			task := &Task{}
+			movie := &Movie{}
+			tvShow := &TVShow{}
+			book := &Book{}
+			note := &Note{}
+
+			if task.IsCompleted() || task.IsPending() || task.IsDeleted() {
+				t.Error("Zero value task should have false status methods")
 			}
 
-			createdAt := time.Now()
-			te.SetCreatedAt(createdAt)
-			if !te.GetCreatedAt().Equal(createdAt) {
-				t.Errorf("Expected created at %v, got %v", createdAt, te.GetCreatedAt())
+			if movie.IsWatched() || movie.IsQueued() {
+				t.Error("Zero value movie should have false status methods")
 			}
 
-			updatedAt := time.Now().Add(time.Hour)
-			te.SetUpdatedAt(updatedAt)
-			if !te.GetUpdatedAt().Equal(updatedAt) {
-				t.Errorf("Expected updated at %v, got %v", updatedAt, te.GetUpdatedAt())
+			if tvShow.IsWatching() || tvShow.IsWatched() || tvShow.IsQueued() {
+				t.Error("Zero value TV show should have false status methods")
+			}
+
+			if book.IsReading() || book.IsFinished() || book.IsQueued() {
+				t.Error("Zero value book should have false status methods")
+			}
+
+			if book.ProgressPercent() != 0 {
+				t.Errorf("Zero value book should have 0%% progress, got %d%%", book.ProgressPercent())
+			}
+
+			if note.IsArchived() {
+				t.Error("Zero value note should not be archived")
 			}
 		})
 	})

internal/store/sql/migrations/0006_create_articles_table_down.sql

···
+-- Drop articles table
+DROP TABLE IF EXISTS articles;

internal/store/sql/migrations/0006_create_articles_table_up.sql

···
+-- Articles table
+CREATE TABLE IF NOT EXISTS articles (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    url TEXT UNIQUE NOT NULL,
+    title TEXT NOT NULL,
+    author TEXT,
+    date TEXT,
+    markdown_path TEXT NOT NULL,
+    html_path TEXT NOT NULL,
+    created DATETIME DEFAULT CURRENT_TIMESTAMP,
+    modified DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_articles_url ON articles(url);
+CREATE INDEX IF NOT EXISTS idx_articles_title ON articles(title);
+CREATE INDEX IF NOT EXISTS idx_articles_author ON articles(author);
+CREATE INDEX IF NOT EXISTS idx_articles_date ON articles(date);
+CREATE INDEX IF NOT EXISTS idx_articles_created ON articles(created);