Implement SQLite index database layer

- Add pure Go SQLite driver (modernc.org/sqlite) to avoid CGO dependency
- Implement database connection management with WAL mode
- Add write mutex for serializing concurrent writes
- Create schema for all tables matching DESIGN.md specifications
- Implement repository pattern for all database entities:
  - Files, FileChunks, Chunks, Blobs, BlobChunks, ChunkFiles, Snapshots
- Add transaction support with proper rollback handling
- Add fatal error handling for database integrity issues
- Add snapshot fields for tracking file sizes and compression ratios
- Make index path configurable via VAULTIK_INDEX_PATH environment variable
- Add comprehensive test coverage for all repositories
- Add format check to Makefile to ensure code formatting

internal/database/snapshots_test.go

@@ -0,0 +1,181 @@
+package database
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"testing"
+	"time"
+)
+
+const (
+	Mebibyte               = 1024 * 1024
+	oneHundredMebibytes    = 100 * Mebibyte
+	fortyMebibytes         = 40 * Mebibyte
+	sixtyMebibytes         = 60 * Mebibyte
+	twoHundredMebibytes    = 200 * Mebibyte
+	compressionRatioPoint4 = 0.4
+	compressionRatioPoint3 = 0.3
+)
+
+func TestSnapshotRepository(t *testing.T) {
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := NewSnapshotRepository(db)
+
+	// Test Create
+	snapshot := &Snapshot{
+		ID:               "2024-01-01T12:00:00Z",
+		Hostname:         "test-host",
+		VaultikVersion:   "1.0.0",
+		CreatedTS:        time.Now().Truncate(time.Second),
+		FileCount:        100,
+		ChunkCount:       500,
+		BlobCount:        10,
+		TotalSize:        oneHundredMebibytes,
+		BlobSize:         fortyMebibytes,
+		CompressionRatio: compressionRatioPoint4, // 40MB / 100MB
+	}
+
+	err := repo.Create(ctx, nil, snapshot)
+	if err != nil {
+		t.Fatalf("failed to create snapshot: %v", err)
+	}
+
+	// Test GetByID
+	retrieved, err := repo.GetByID(ctx, snapshot.ID)
+	if err != nil {
+		t.Fatalf("failed to get snapshot: %v", err)
+	}
+	if retrieved == nil {
+		t.Fatal("expected snapshot, got nil")
+	}
+	if retrieved.ID != snapshot.ID {
+		t.Errorf("ID mismatch: got %s, want %s", retrieved.ID, snapshot.ID)
+	}
+	if retrieved.Hostname != snapshot.Hostname {
+		t.Errorf("hostname mismatch: got %s, want %s", retrieved.Hostname, snapshot.Hostname)
+	}
+	if retrieved.FileCount != snapshot.FileCount {
+		t.Errorf("file count mismatch: got %d, want %d", retrieved.FileCount, snapshot.FileCount)
+	}
+
+	// Test UpdateCounts
+	err = repo.UpdateCounts(ctx, nil, snapshot.ID, 200, 1000, 20, twoHundredMebibytes, sixtyMebibytes)
+	if err != nil {
+		t.Fatalf("failed to update counts: %v", err)
+	}
+
+	retrieved, err = repo.GetByID(ctx, snapshot.ID)
+	if err != nil {
+		t.Fatalf("failed to get updated snapshot: %v", err)
+	}
+	if retrieved.FileCount != 200 {
+		t.Errorf("file count not updated: got %d, want %d", retrieved.FileCount, 200)
+	}
+	if retrieved.ChunkCount != 1000 {
+		t.Errorf("chunk count not updated: got %d, want %d", retrieved.ChunkCount, 1000)
+	}
+	if retrieved.BlobCount != 20 {
+		t.Errorf("blob count not updated: got %d, want %d", retrieved.BlobCount, 20)
+	}
+	if retrieved.TotalSize != twoHundredMebibytes {
+		t.Errorf("total size not updated: got %d, want %d", retrieved.TotalSize, twoHundredMebibytes)
+	}
+	if retrieved.BlobSize != sixtyMebibytes {
+		t.Errorf("blob size not updated: got %d, want %d", retrieved.BlobSize, sixtyMebibytes)
+	}
+	expectedRatio := compressionRatioPoint3 // 0.3
+	if math.Abs(retrieved.CompressionRatio-expectedRatio) > 0.001 {
+		t.Errorf("compression ratio not updated: got %f, want %f", retrieved.CompressionRatio, expectedRatio)
+	}
+
+	// Test ListRecent
+	// Add more snapshots
+	for i := 2; i <= 5; i++ {
+		s := &Snapshot{
+			ID:             fmt.Sprintf("2024-01-0%dT12:00:00Z", i),
+			Hostname:       "test-host",
+			VaultikVersion: "1.0.0",
+			CreatedTS:      time.Now().Add(time.Duration(i) * time.Hour).Truncate(time.Second),
+			FileCount:      int64(100 * i),
+			ChunkCount:     int64(500 * i),
+			BlobCount:      int64(10 * i),
+		}
+		err := repo.Create(ctx, nil, s)
+		if err != nil {
+			t.Fatalf("failed to create snapshot %d: %v", i, err)
+		}
+	}
+
+	// Test listing with limit
+	recent, err := repo.ListRecent(ctx, 3)
+	if err != nil {
+		t.Fatalf("failed to list recent snapshots: %v", err)
+	}
+	if len(recent) != 3 {
+		t.Errorf("expected 3 recent snapshots, got %d", len(recent))
+	}
+
+	// Verify order (most recent first)
+	for i := 0; i < len(recent)-1; i++ {
+		if recent[i].CreatedTS.Before(recent[i+1].CreatedTS) {
+			t.Error("snapshots not in descending order")
+		}
+	}
+}
+
+func TestSnapshotRepositoryNotFound(t *testing.T) {
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := NewSnapshotRepository(db)
+
+	// Test GetByID with non-existent ID
+	snapshot, err := repo.GetByID(ctx, "nonexistent")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if snapshot != nil {
+		t.Error("expected nil for non-existent snapshot")
+	}
+
+	// Test UpdateCounts on non-existent snapshot
+	err = repo.UpdateCounts(ctx, nil, "nonexistent", 100, 200, 10, oneHundredMebibytes, fortyMebibytes)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// No error expected, but no rows should be affected
+}
+
+func TestSnapshotRepositoryDuplicate(t *testing.T) {
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := NewSnapshotRepository(db)
+
+	snapshot := &Snapshot{
+		ID:             "2024-01-01T12:00:00Z",
+		Hostname:       "test-host",
+		VaultikVersion: "1.0.0",
+		CreatedTS:      time.Now().Truncate(time.Second),
+		FileCount:      100,
+		ChunkCount:     500,
+		BlobCount:      10,
+	}
+
+	err := repo.Create(ctx, nil, snapshot)
+	if err != nil {
+		t.Fatalf("failed to create snapshot: %v", err)
+	}
+
+	// Try to create duplicate - should fail due to primary key constraint
+	err = repo.Create(ctx, nil, snapshot)
+	if err == nil {
+		t.Error("expected error for duplicate snapshot")
+	}
+}