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/blob_chunks_test.go

@@ -0,0 +1,146 @@
+package database
+
+import (
+	"context"
+	"testing"
+)
+
+func TestBlobChunkRepository(t *testing.T) {
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := NewBlobChunkRepository(db)
+
+	// Test Create
+	bc1 := &BlobChunk{
+		BlobHash:  "blob1",
+		ChunkHash: "chunk1",
+		Offset:    0,
+		Length:    1024,
+	}
+
+	err := repo.Create(ctx, nil, bc1)
+	if err != nil {
+		t.Fatalf("failed to create blob chunk: %v", err)
+	}
+
+	// Add more chunks to the same blob
+	bc2 := &BlobChunk{
+		BlobHash:  "blob1",
+		ChunkHash: "chunk2",
+		Offset:    1024,
+		Length:    2048,
+	}
+	err = repo.Create(ctx, nil, bc2)
+	if err != nil {
+		t.Fatalf("failed to create second blob chunk: %v", err)
+	}
+
+	bc3 := &BlobChunk{
+		BlobHash:  "blob1",
+		ChunkHash: "chunk3",
+		Offset:    3072,
+		Length:    512,
+	}
+	err = repo.Create(ctx, nil, bc3)
+	if err != nil {
+		t.Fatalf("failed to create third blob chunk: %v", err)
+	}
+
+	// Test GetByBlobHash
+	chunks, err := repo.GetByBlobHash(ctx, "blob1")
+	if err != nil {
+		t.Fatalf("failed to get blob chunks: %v", err)
+	}
+	if len(chunks) != 3 {
+		t.Errorf("expected 3 chunks, got %d", len(chunks))
+	}
+
+	// Verify order by offset
+	expectedOffsets := []int64{0, 1024, 3072}
+	for i, chunk := range chunks {
+		if chunk.Offset != expectedOffsets[i] {
+			t.Errorf("wrong chunk order: expected offset %d, got %d", expectedOffsets[i], chunk.Offset)
+		}
+	}
+
+	// Test GetByChunkHash
+	bc, err := repo.GetByChunkHash(ctx, "chunk2")
+	if err != nil {
+		t.Fatalf("failed to get blob chunk by chunk hash: %v", err)
+	}
+	if bc == nil {
+		t.Fatal("expected blob chunk, got nil")
+	}
+	if bc.BlobHash != "blob1" {
+		t.Errorf("wrong blob hash: expected blob1, got %s", bc.BlobHash)
+	}
+	if bc.Offset != 1024 {
+		t.Errorf("wrong offset: expected 1024, got %d", bc.Offset)
+	}
+
+	// Test non-existent chunk
+	bc, err = repo.GetByChunkHash(ctx, "nonexistent")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if bc != nil {
+		t.Error("expected nil for non-existent chunk")
+	}
+}
+
+func TestBlobChunkRepositoryMultipleBlobs(t *testing.T) {
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	repo := NewBlobChunkRepository(db)
+
+	// Create chunks across multiple blobs
+	// Some chunks are shared between blobs (deduplication scenario)
+	blobChunks := []BlobChunk{
+		{BlobHash: "blob1", ChunkHash: "chunk1", Offset: 0, Length: 1024},
+		{BlobHash: "blob1", ChunkHash: "chunk2", Offset: 1024, Length: 1024},
+		{BlobHash: "blob2", ChunkHash: "chunk2", Offset: 0, Length: 1024}, // chunk2 is shared
+		{BlobHash: "blob2", ChunkHash: "chunk3", Offset: 1024, Length: 1024},
+	}
+
+	for _, bc := range blobChunks {
+		err := repo.Create(ctx, nil, &bc)
+		if err != nil {
+			t.Fatalf("failed to create blob chunk: %v", err)
+		}
+	}
+
+	// Verify blob1 chunks
+	chunks, err := repo.GetByBlobHash(ctx, "blob1")
+	if err != nil {
+		t.Fatalf("failed to get blob1 chunks: %v", err)
+	}
+	if len(chunks) != 2 {
+		t.Errorf("expected 2 chunks for blob1, got %d", len(chunks))
+	}
+
+	// Verify blob2 chunks
+	chunks, err = repo.GetByBlobHash(ctx, "blob2")
+	if err != nil {
+		t.Fatalf("failed to get blob2 chunks: %v", err)
+	}
+	if len(chunks) != 2 {
+		t.Errorf("expected 2 chunks for blob2, got %d", len(chunks))
+	}
+
+	// Verify shared chunk
+	bc, err := repo.GetByChunkHash(ctx, "chunk2")
+	if err != nil {
+		t.Fatalf("failed to get shared chunk: %v", err)
+	}
+	if bc == nil {
+		t.Fatal("expected shared chunk, got nil")
+	}
+	// GetByChunkHash returns first match, should be blob1
+	if bc.BlobHash != "blob1" {
+		t.Errorf("expected blob1 for shared chunk, got %s", bc.BlobHash)
+	}
+}