feat: add cloud status command (Quick Win #7)

Added 'dbbackup cloud status' command for cloud storage health checks:

Features:
- Cloud provider configuration validation
- Authentication/credentials testing
- Bucket/container existence verification
- List permissions check (read access)
- Upload/delete permissions test (write access)
- Network connectivity testing
- Latency/performance measurements
- Storage usage statistics

Supports:
- AWS S3
- Google Cloud Storage (GCS)
- Azure Blob Storage
- MinIO
- Backblaze B2

Usage Examples:
  dbbackup cloud status                  # Full check
  dbbackup cloud status --quick          # Skip upload test
  dbbackup cloud status --verbose        # Show detailed info
  dbbackup cloud status --format json    # JSON output

Validation Checks:
✓ Configuration (provider, bucket)
✓ Initialize connection
✓ Bucket access
✓ List objects (read permissions)
✓ Upload test file (write permissions)
✓ Delete test file (cleanup)

Helps diagnose cloud storage issues before critical operations,
preventing backup/restore failures due to connectivity or permission
problems.

Quick Win #7: Cloud Status - 25 min implementation

cmd/cloud.go

@@ -125,7 +125,7 @@ func init() {
 	cloudCmd.AddCommand(cloudUploadCmd, cloudDownloadCmd, cloudListCmd, cloudDeleteCmd)
 
 	// Cloud configuration flags
-	for _, cmd := range []*cobra.Command{cloudUploadCmd, cloudDownloadCmd, cloudListCmd, cloudDeleteCmd} {
+	for _, cmd := range []*cobra.Command{cloudUploadCmd, cloudDownloadCmd, cloudListCmd, cloudDeleteCmd, cloudStatusCmd} {
 		cmd.Flags().StringVar(&cloudProvider, "cloud-provider", getEnv("DBBACKUP_CLOUD_PROVIDER", "s3"), "Cloud provider (s3, minio, b2)")
 		cmd.Flags().StringVar(&cloudBucket, "cloud-bucket", getEnv("DBBACKUP_CLOUD_BUCKET", ""), "Bucket name")
 		cmd.Flags().StringVar(&cloudRegion, "cloud-region", getEnv("DBBACKUP_CLOUD_REGION", "us-east-1"), "Region")

cmd/cloud_status.go

@@ -0,0 +1,460 @@
+package cmd
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"time"
+
+	"dbbackup/internal/cloud"
+
+	"github.com/spf13/cobra"
+)
+
+var cloudStatusCmd = &cobra.Command{
+	Use:   "status",
+	Short: "Check cloud storage connectivity and status",
+	Long: `Check cloud storage connectivity, credentials, and bucket access.
+
+This command verifies:
+  - Cloud provider configuration
+  - Authentication/credentials
+  - Bucket/container existence and access
+  - List capabilities (read permissions)
+  - Upload capabilities (write permissions)
+  - Network connectivity
+  - Response times
+
+Supports:
+  - AWS S3
+  - Google Cloud Storage (GCS)
+  - Azure Blob Storage
+  - MinIO
+  - Backblaze B2
+
+Examples:
+  # Check configured cloud storage
+  dbbackup cloud status
+
+  # Check with JSON output
+  dbbackup cloud status --format json
+
+  # Quick check (skip upload test)
+  dbbackup cloud status --quick
+
+  # Verbose diagnostics
+  dbbackup cloud status --verbose`,
+	RunE: runCloudStatus,
+}
+
+var (
+	cloudStatusFormat  string
+	cloudStatusQuick   bool
+	// cloudStatusVerbose uses the global cloudVerbose flag from cloud.go
+)
+
+type CloudStatus struct {
+	Provider      string                 `json:"provider"`
+	Bucket        string                 `json:"bucket"`
+	Region        string                 `json:"region,omitempty"`
+	Endpoint      string                 `json:"endpoint,omitempty"`
+	Connected     bool                   `json:"connected"`
+	BucketExists  bool                   `json:"bucket_exists"`
+	CanList       bool                   `json:"can_list"`
+	CanUpload     bool                   `json:"can_upload"`
+	ObjectCount   int                    `json:"object_count,omitempty"`
+	TotalSize     int64                  `json:"total_size_bytes,omitempty"`
+	LatencyMs     int64                  `json:"latency_ms,omitempty"`
+	Error         string                 `json:"error,omitempty"`
+	Checks        []CloudStatusCheck     `json:"checks"`
+	Details       map[string]interface{} `json:"details,omitempty"`
+}
+
+type CloudStatusCheck struct {
+	Name    string `json:"name"`
+	Status  string `json:"status"` // "pass", "fail", "skip"
+	Message string `json:"message,omitempty"`
+	Error   string `json:"error,omitempty"`
+}
+
+func init() {
+	cloudCmd.AddCommand(cloudStatusCmd)
+
+	cloudStatusCmd.Flags().StringVar(&cloudStatusFormat, "format", "table", "Output format (table, json)")
+	cloudStatusCmd.Flags().BoolVar(&cloudStatusQuick, "quick", false, "Quick check (skip upload test)")
+	// Note: verbose flag is added by cloud.go init()
+}
+
+func runCloudStatus(cmd *cobra.Command, args []string) error {
+	if !cfg.CloudEnabled {
+		fmt.Println("[WARN] Cloud storage is not enabled")
+		fmt.Println("Enable with: --cloud-enabled")
+		fmt.Println()
+		fmt.Println("Example configuration:")
+		fmt.Println("  cloud_enabled = true")
+		fmt.Println("  cloud_provider = \"s3\"        # s3, gcs, azure, minio, b2")
+		fmt.Println("  cloud_bucket = \"my-backups\"")
+		fmt.Println("  cloud_region = \"us-east-1\"   # for S3/GCS")
+		fmt.Println("  cloud_access_key = \"...\"")
+		fmt.Println("  cloud_secret_key = \"...\"")
+		return nil
+	}
+
+	status := &CloudStatus{
+		Provider: cfg.CloudProvider,
+		Bucket:   cfg.CloudBucket,
+		Region:   cfg.CloudRegion,
+		Endpoint: cfg.CloudEndpoint,
+		Checks:   []CloudStatusCheck{},
+		Details:  make(map[string]interface{}),
+	}
+
+	fmt.Println("[CHECK] Cloud Storage Status")
+	fmt.Println()
+	fmt.Printf("Provider: %s\n", cfg.CloudProvider)
+	fmt.Printf("Bucket:   %s\n", cfg.CloudBucket)
+	if cfg.CloudRegion != "" {
+		fmt.Printf("Region:   %s\n", cfg.CloudRegion)
+	}
+	if cfg.CloudEndpoint != "" {
+		fmt.Printf("Endpoint: %s\n", cfg.CloudEndpoint)
+	}
+	fmt.Println()
+
+	// Check configuration
+	checkConfig(status)
+
+	// Initialize cloud storage
+	ctx := context.Background()
+	
+	startTime := time.Now()
+	
+	// Create cloud config
+	cloudCfg := &cloud.Config{
+		Provider:   cfg.CloudProvider,
+		Bucket:     cfg.CloudBucket,
+		Region:     cfg.CloudRegion,
+		Endpoint:   cfg.CloudEndpoint,
+		AccessKey:  cfg.CloudAccessKey,
+		SecretKey:  cfg.CloudSecretKey,
+		UseSSL:     true,
+		PathStyle:  cfg.CloudProvider == "minio",
+		Prefix:     cfg.CloudPrefix,
+		Timeout:    300,
+		MaxRetries: 3,
+	}
+	
+	backend, err := cloud.NewBackend(cloudCfg)
+	if err != nil {
+		status.Connected = false
+		status.Error = fmt.Sprintf("Failed to initialize cloud storage: %v", err)
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "Initialize",
+			Status: "fail",
+			Error:  err.Error(),
+		})
+		
+		printStatus(status)
+		return fmt.Errorf("cloud storage initialization failed: %w", err)
+	}
+	
+	initDuration := time.Since(startTime)
+	status.Details["init_time_ms"] = initDuration.Milliseconds()
+
+	if cloudVerbose {
+		fmt.Printf("[DEBUG] Initialization took %s\n", initDuration.Round(time.Millisecond))
+	}
+
+	status.Connected = true
+	status.Checks = append(status.Checks, CloudStatusCheck{
+		Name:    "Initialize",
+		Status:  "pass",
+		Message: fmt.Sprintf("Connected (%s)", initDuration.Round(time.Millisecond)),
+	})
+
+	// Test bucket existence (via list operation)
+	checkBucketAccess(ctx, backend, status)
+
+	// Test list permissions
+	checkListPermissions(ctx, backend, status)
+
+	// Test upload permissions (unless quick mode)
+	if !cloudStatusQuick {
+		checkUploadPermissions(ctx, backend, status)
+	} else {
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "Upload",
+			Status: "skip",
+			Message: "Skipped (--quick mode)",
+		})
+	}
+
+	// Calculate overall latency
+	totalLatency := int64(0)
+	for _, check := range status.Checks {
+		if check.Status == "pass" {
+			totalLatency++
+		}
+	}
+	if totalLatency > 0 {
+		status.LatencyMs = initDuration.Milliseconds()
+	}
+
+	// Output results
+	if cloudStatusFormat == "json" {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		return enc.Encode(status)
+	}
+
+	printStatus(status)
+
+	// Return error if any checks failed
+	for _, check := range status.Checks {
+		if check.Status == "fail" {
+			return fmt.Errorf("cloud status check failed")
+		}
+	}
+
+	return nil
+}
+
+func checkConfig(status *CloudStatus) {
+	if status.Provider == "" {
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "Configuration",
+			Status: "fail",
+			Error:  "Cloud provider not configured",
+		})
+		return
+	}
+
+	if status.Bucket == "" {
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "Configuration",
+			Status: "fail",
+			Error:  "Bucket/container name not configured",
+		})
+		return
+	}
+
+	status.Checks = append(status.Checks, CloudStatusCheck{
+		Name:    "Configuration",
+		Status:  "pass",
+		Message: fmt.Sprintf("%s / %s", status.Provider, status.Bucket),
+	})
+}
+
+func checkBucketAccess(ctx context.Context, backend cloud.Backend, status *CloudStatus) {
+	fmt.Print("[TEST] Checking bucket access... ")
+	
+	startTime := time.Now()
+	// Try to list - this will fail if bucket doesn't exist or no access
+	_, err := backend.List(ctx, "")
+	duration := time.Since(startTime)
+
+	if err != nil {
+		fmt.Printf("[FAIL] %v\n", err)
+		status.BucketExists = false
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "Bucket Access",
+			Status: "fail",
+			Error:  err.Error(),
+		})
+		return
+	}
+
+	fmt.Printf("[OK] (%s)\n", duration.Round(time.Millisecond))
+	status.BucketExists = true
+	status.Checks = append(status.Checks, CloudStatusCheck{
+		Name:    "Bucket Access",
+		Status:  "pass",
+		Message: fmt.Sprintf("Accessible (%s)", duration.Round(time.Millisecond)),
+	})
+}
+
+func checkListPermissions(ctx context.Context, backend cloud.Backend, status *CloudStatus) {
+	fmt.Print("[TEST] Checking list permissions... ")
+
+	startTime := time.Now()
+	objects, err := backend.List(ctx, cfg.CloudPrefix)
+	duration := time.Since(startTime)
+
+	if err != nil {
+		fmt.Printf("[FAIL] %v\n", err)
+		status.CanList = false
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "List Objects",
+			Status: "fail",
+			Error:  err.Error(),
+		})
+		return
+	}
+
+	fmt.Printf("[OK] Found %d object(s) (%s)\n", len(objects), duration.Round(time.Millisecond))
+	status.CanList = true
+	status.ObjectCount = len(objects)
+
+	// Calculate total size
+	var totalSize int64
+	for _, obj := range objects {
+		totalSize += obj.Size
+	}
+	status.TotalSize = totalSize
+
+	status.Checks = append(status.Checks, CloudStatusCheck{
+		Name:    "List Objects",
+		Status:  "pass",
+		Message: fmt.Sprintf("%d objects, %s total (%s)", len(objects), formatCloudBytes(totalSize), duration.Round(time.Millisecond)),
+	})
+
+	if cloudVerbose && len(objects) > 0 {
+		fmt.Println("\n[OBJECTS]")
+		limit := 5
+		for i, obj := range objects {
+			if i >= limit {
+				fmt.Printf("  ... and %d more\n", len(objects)-limit)
+				break
+			}
+			fmt.Printf("  %s (%s, %s)\n", obj.Key, formatCloudBytes(obj.Size), obj.LastModified.Format("2006-01-02 15:04"))
+		}
+		fmt.Println()
+	}
+}
+
+func checkUploadPermissions(ctx context.Context, backend cloud.Backend, status *CloudStatus) {
+	fmt.Print("[TEST] Checking upload permissions... ")
+
+	// Create a small test file
+	testKey := cfg.CloudPrefix + "/.dbbackup-test-" + time.Now().Format("20060102150405")
+	testData := []byte("dbbackup cloud status test")
+
+	// Create temp file for upload
+	tmpFile, err := os.CreateTemp("", "dbbackup-test-*")
+	if err != nil {
+		fmt.Printf("[FAIL] Could not create test file: %v\n", err)
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:  "Upload Test",
+			Status: "fail",
+			Error: fmt.Sprintf("temp file creation failed: %v", err),
+		})
+		return
+	}
+	defer os.Remove(tmpFile.Name())
+	
+	if _, err := tmpFile.Write(testData); err != nil {
+		tmpFile.Close()
+		fmt.Printf("[FAIL] Could not write test file: %v\n", err)
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:  "Upload Test",
+			Status: "fail",
+			Error: fmt.Sprintf("test file write failed: %v", err),
+		})
+		return
+	}
+	tmpFile.Close()
+
+	startTime := time.Now()
+	err = backend.Upload(ctx, tmpFile.Name(), testKey, nil)
+	uploadDuration := time.Since(startTime)
+
+	if err != nil {
+		fmt.Printf("[FAIL] %v\n", err)
+		status.CanUpload = false
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:   "Upload Test",
+			Status: "fail",
+			Error:  err.Error(),
+		})
+		return
+	}
+
+	fmt.Printf("[OK] Test file uploaded (%s)\n", uploadDuration.Round(time.Millisecond))
+
+	// Try to delete the test file
+	fmt.Print("[TEST] Checking delete permissions... ")
+	deleteStartTime := time.Now()
+	err = backend.Delete(ctx, testKey)
+	deleteDuration := time.Since(deleteStartTime)
+
+	if err != nil {
+		fmt.Printf("[WARN] Could not delete test file: %v\n", err)
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:    "Upload Test",
+			Status:  "pass",
+			Message: fmt.Sprintf("Upload OK (%s), delete failed", uploadDuration.Round(time.Millisecond)),
+		})
+	} else {
+		fmt.Printf("[OK] Test file deleted (%s)\n", deleteDuration.Round(time.Millisecond))
+		status.CanUpload = true
+		status.Checks = append(status.Checks, CloudStatusCheck{
+			Name:    "Upload/Delete Test",
+			Status:  "pass",
+			Message: fmt.Sprintf("Both successful (upload: %s, delete: %s)", 
+				uploadDuration.Round(time.Millisecond), 
+				deleteDuration.Round(time.Millisecond)),
+		})
+	}
+}
+
+func printStatus(status *CloudStatus) {
+	fmt.Println("\n[RESULTS]")
+	fmt.Println("================================================")
+
+	for _, check := range status.Checks {
+		var statusStr string
+		switch check.Status {
+		case "pass":
+			statusStr = "[OK]  "
+		case "fail":
+			statusStr = "[FAIL]"
+		case "skip":
+			statusStr = "[SKIP]"
+		}
+
+		fmt.Printf("  %-20s %s", check.Name+":", statusStr)
+		if check.Message != "" {
+			fmt.Printf(" %s", check.Message)
+		}
+		if check.Error != "" {
+			fmt.Printf(" - %s", check.Error)
+		}
+		fmt.Println()
+	}
+
+	fmt.Println("================================================")
+
+	if status.CanList && status.ObjectCount > 0 {
+		fmt.Printf("\nStorage Usage: %d object(s), %s total\n", status.ObjectCount, formatCloudBytes(status.TotalSize))
+	}
+
+	// Overall status
+	fmt.Println()
+	allPassed := true
+	for _, check := range status.Checks {
+		if check.Status == "fail" {
+			allPassed = false
+			break
+		}
+	}
+
+	if allPassed {
+		fmt.Println("[OK] All checks passed - cloud storage is ready")
+	} else {
+		fmt.Println("[FAIL] Some checks failed - review configuration")
+	}
+}
+
+func formatCloudBytes(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%d B", bytes)
+	}
+	div, exp := int64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}

cmd/forecast.go

@@ -59,25 +59,25 @@ var (
 )
 
 type ForecastResult struct {
-	Database          string              `json:"database"`
-	CurrentSize       int64               `json:"current_size_bytes"`
-	TotalBackups      int                 `json:"total_backups"`
-	OldestBackup      time.Time           `json:"oldest_backup"`
-	NewestBackup      time.Time           `json:"newest_backup"`
-	ObservationPeriod time.Duration       `json:"observation_period_seconds"`
-	DailyGrowthRate   float64             `json:"daily_growth_bytes"`
-	DailyGrowthPct    float64             `json:"daily_growth_percent"`
+	Database          string               `json:"database"`
+	CurrentSize       int64                `json:"current_size_bytes"`
+	TotalBackups      int                  `json:"total_backups"`
+	OldestBackup      time.Time            `json:"oldest_backup"`
+	NewestBackup      time.Time            `json:"newest_backup"`
+	ObservationPeriod time.Duration        `json:"observation_period_seconds"`
+	DailyGrowthRate   float64              `json:"daily_growth_bytes"`
+	DailyGrowthPct    float64              `json:"daily_growth_percent"`
 	Projections       []ForecastProjection `json:"projections"`
-	TimeToLimit       *time.Duration      `json:"time_to_limit_seconds,omitempty"`
-	SizeAtLimit       *time.Time          `json:"date_reaching_limit,omitempty"`
-	Confidence        string              `json:"confidence"` // "high", "medium", "low"
+	TimeToLimit       *time.Duration       `json:"time_to_limit_seconds,omitempty"`
+	SizeAtLimit       *time.Time           `json:"date_reaching_limit,omitempty"`
+	Confidence        string               `json:"confidence"` // "high", "medium", "low"
 }
 
 type ForecastProjection struct {
-	Days         int       `json:"days_from_now"`
-	Date         time.Time `json:"date"`
-	PredictedSize int64    `json:"predicted_size_bytes"`
-	Confidence   float64   `json:"confidence_percent"`
+	Days          int       `json:"days_from_now"`
+	Date          time.Time `json:"date"`
+	PredictedSize int64     `json:"predicted_size_bytes"`
+	Confidence    float64   `json:"confidence_percent"`
 }
 
 func init() {
@@ -197,10 +197,10 @@ func calculateForecast(ctx context.Context, cat *catalog.SQLiteCatalog, database
 	firstSize := entries[0].SizeBytes
 	lastSize := entries[len(entries)-1].SizeBytes
 	sizeDelta := float64(lastSize - firstSize)
-	
+
 	daysObserved := observationPeriod.Hours() / 24
 	dailyGrowthRate := sizeDelta / daysObserved
-	
+
 	// Calculate daily growth percentage
 	var dailyGrowthPct float64
 	if firstSize > 0 {
@@ -213,7 +213,7 @@ func calculateForecast(ctx context.Context, cat *catalog.SQLiteCatalog, database
 	// Generate projections
 	projections := make([]ForecastProjection, 0)
 	projectionDates := []int{7, 30, 60, 90, 180, 365}
-	
+
 	if forecastDays > 0 {
 		// Use user-specified days
 		projectionDates = []int{forecastDays}
@@ -317,13 +317,13 @@ func printForecast(f *ForecastResult, limitBytes int64) {
 	fmt.Printf("\n[CURRENT STATE]\n")
 	fmt.Printf("  Size:         %s\n", catalog.FormatSize(f.CurrentSize))
 	fmt.Printf("  Backups:      %d backups\n", f.TotalBackups)
-	fmt.Printf("  Observed:     %s (%.0f days)\n", 
+	fmt.Printf("  Observed:     %s (%.0f days)\n",
 		formatForecastDuration(f.ObservationPeriod),
 		f.ObservationPeriod.Hours()/24)
 
 	fmt.Printf("\n[GROWTH RATE]\n")
 	if f.DailyGrowthRate > 0 {
-		fmt.Printf("  Daily:        +%s/day (%.2f%%/day)\n", 
+		fmt.Printf("  Daily:        +%s/day (%.2f%%/day)\n",
 			catalog.FormatSize(int64(f.DailyGrowthRate)), f.DailyGrowthPct)
 		fmt.Printf("  Weekly:       +%s/week\n", catalog.FormatSize(int64(f.DailyGrowthRate*7)))
 		fmt.Printf("  Monthly:      +%s/month\n", catalog.FormatSize(int64(f.DailyGrowthRate*30)))
@@ -340,7 +340,7 @@ func printForecast(f *ForecastResult, limitBytes int64) {
 		w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
 		fmt.Fprintf(w, "  Days\tDate\tPredicted Size\tConfidence\n")
 		fmt.Fprintf(w, "  ----\t----\t--------------\t----------\n")
-		
+
 		for _, proj := range f.Projections {
 			fmt.Fprintf(w, "  %d\t%s\t%s\t%.0f%%\n",
 				proj.Days,
@@ -355,7 +355,7 @@ func printForecast(f *ForecastResult, limitBytes int64) {
 	if limitBytes > 0 {
 		fmt.Printf("\n[CAPACITY LIMIT]\n")
 		fmt.Printf("  Limit:        %s\n", catalog.FormatSize(limitBytes))
-		
+
 		currentPct := float64(f.CurrentSize) / float64(limitBytes) * 100
 		fmt.Printf("  Current:      %.1f%% used\n", currentPct)
 
@@ -371,12 +371,12 @@ func printForecast(f *ForecastResult, limitBytes int64) {
 		if f.DailyGrowthRate > 0 {
 			remaining := limitBytes - f.CurrentSize
 			daysToLimit := float64(remaining) / f.DailyGrowthRate
-			
+
 			if daysToLimit > 0 && daysToLimit < 1000 {
 				dateAtLimit := f.NewestBackup.Add(time.Duration(daysToLimit*24) * time.Hour)
-				fmt.Printf("  Estimated:    Limit reached in %.0f days (%s)\n", 
+				fmt.Printf("  Estimated:    Limit reached in %.0f days (%s)\n",
 					daysToLimit, dateAtLimit.Format("2006-01-02"))
-				
+
 				if daysToLimit < 30 {
 					fmt.Printf("  Alert:        [CRITICAL] Less than 30 days remaining!\n")
 				} else if daysToLimit < 90 {
@@ -413,10 +413,10 @@ func formatForecastDuration(d time.Duration) string {
 func parseSize(s string) (int64, error) {
 	// Simple size parser (supports KB, MB, GB, TB)
 	s = strings.ToUpper(strings.TrimSpace(s))
-	
+
 	var multiplier int64 = 1
 	var numStr string
-	
+
 	if strings.HasSuffix(s, "TB") {
 		multiplier = 1024 * 1024 * 1024 * 1024
 		numStr = strings.TrimSuffix(s, "TB")
@@ -432,12 +432,12 @@ func parseSize(s string) (int64, error) {
 	} else {
 		numStr = s
 	}
-	
+
 	var num float64
 	_, err := fmt.Sscanf(numStr, "%f", &num)
 	if err != nil {
 		return 0, fmt.Errorf("invalid size format: %s", s)
 	}
-	
+
 	return int64(num * float64(multiplier)), nil
 }

cmd/notify.go

@@ -116,11 +116,11 @@ func runNotifyTest(cmd *cobra.Command, args []string) error {
 		SMTPTo:       cfg.NotifySMTPTo,
 		SMTPTLS:      cfg.NotifySMTPTLS,
 		SMTPStartTLS: cfg.NotifySMTPStartTLS,
-		
+
 		WebhookEnabled: hasWebhook,
 		WebhookURL:     cfg.NotifyWebhookURL,
 		WebhookMethod:  "POST",
-		
+
 		OnSuccess: true,
 		OnFailure: true,
 	}
@@ -139,7 +139,7 @@ func runNotifyTest(cmd *cobra.Command, args []string) error {
 
 	// Send notification
 	fmt.Println("[SEND] Sending test notification...")
-	
+
 	ctx := context.Background()
 	if err := manager.NotifySync(ctx, event); err != nil {
 		fmt.Printf("[FAIL] Notification failed: %v\n", err)
@@ -149,6 +149,6 @@ func runNotifyTest(cmd *cobra.Command, args []string) error {
 	fmt.Println("[OK] Notification sent successfully")
 	fmt.Println()
 	fmt.Println("Check your notification endpoint to confirm delivery.")
-	
+
 	return nil
 }

cmd/schedule.go

@@ -108,7 +108,7 @@ func runSchedule(cmd *cobra.Command, args []string) error {
 func getSystemdTimers() ([]TimerInfo, error) {
 	// Run systemctl list-timers --all --no-pager
 	cmdArgs := []string{"list-timers", "--all", "--no-pager"}
-	
+
 	output, err := exec.Command("systemctl", cmdArgs...).CombinedOutput()
 	if err != nil {
 		return nil, fmt.Errorf("failed to list timers: %w\nOutput: %s", err, string(output))
@@ -137,7 +137,7 @@ func parseTimerList(output string) []TimerInfo {
 
 		// Extract timer info
 		timer := TimerInfo{}
-		
+
 		// Check if NEXT field is "n/a" (inactive timer)
 		if fields[0] == "n/a" {
 			timer.NextRun = "n/a"
@@ -227,11 +227,11 @@ func filterTimers(timers []TimerInfo) []TimerInfo {
 
 		// Default: filter for backup-related timers
 		name := strings.ToLower(timer.Unit)
-		if strings.Contains(name, "backup") || 
-		   strings.Contains(name, "dbbackup") ||
-		   strings.Contains(name, "postgres") ||
-		   strings.Contains(name, "mysql") ||
-		   strings.Contains(name, "mariadb") {
+		if strings.Contains(name, "backup") ||
+			strings.Contains(name, "dbbackup") ||
+			strings.Contains(name, "postgres") ||
+			strings.Contains(name, "mysql") ||
+			strings.Contains(name, "mariadb") {
 			filtered = append(filtered, timer)
 		}
 	}
@@ -243,7 +243,7 @@ func outputTimerTable(timers []TimerInfo) {
 	fmt.Println()
 	fmt.Println("Scheduled Backups")
 	fmt.Println("=====================================================")
-	
+
 	for _, timer := range timers {
 		name := timer.Unit
 		if strings.HasSuffix(name, ".timer") {
@@ -252,7 +252,7 @@ func outputTimerTable(timers []TimerInfo) {
 
 		fmt.Printf("\n[TIMER] %s\n", name)
 		fmt.Printf("  Status:     %s\n", timer.Active)
-		
+
 		if timer.Active == "active" && timer.NextRun != "" && timer.NextRun != "n/a" {
 			fmt.Printf("  Next Run:   %s\n", timer.NextRun)
 			if timer.Left != "" {
@@ -261,7 +261,7 @@ func outputTimerTable(timers []TimerInfo) {
 		} else {
 			fmt.Printf("  Next Run:   Not scheduled (timer inactive)\n")
 		}
-		
+
 		if timer.LastRun != "" && timer.LastRun != "n/a" {
 			fmt.Printf("  Last Run:   %s\n", timer.LastRun)
 		}

cmd/validate.go

@@ -53,11 +53,11 @@ var (
 )
 
 type ValidationResult struct {
-	Valid      bool               `json:"valid"`
-	Issues     []ValidationIssue  `json:"issues"`
-	Warnings   []ValidationIssue  `json:"warnings"`
-	Checks     []ValidationCheck  `json:"checks"`
-	Summary    string             `json:"summary"`
+	Valid    bool              `json:"valid"`
+	Issues   []ValidationIssue `json:"issues"`
+	Warnings []ValidationIssue `json:"warnings"`
+	Checks   []ValidationCheck `json:"checks"`
+	Summary  string            `json:"summary"`
 }
 
 type ValidationIssue struct {

internal/tui/chain.go

@@ -62,7 +62,7 @@ func (c *ChainView) loadChains() tea.Msg {
 	// Open catalog - use default path
 	home, _ := os.UserHomeDir()
 	catalogPath := filepath.Join(home, ".dbbackup", "catalog.db")
-	
+
 	cat, err := catalog.NewSQLiteCatalog(catalogPath)
 	if err != nil {
 		return chainLoadedMsg{err: fmt.Errorf("failed to open catalog: %w", err)}
@@ -230,7 +230,7 @@ func (c *ChainView) View() string {
 
 		if len(chain.Incrementals) > 0 {
 			b.WriteString(fmt.Sprintf("  [CHAIN] %d Incremental(s)\n", len(chain.Incrementals)))
-			
+
 			// Show first few
 			limit := 3
 			for i, inc := range chain.Incrementals {

internal/tui/menu.go

@@ -455,6 +455,7 @@ func (m *MenuModel) handleDiagnoseBackup() (tea.Model, tea.Cmd) {
 	browser := NewArchiveBrowser(m.config, m.logger, m, m.ctx, "diagnose")
 	return browser, browser.Init()
 }
+
 // handleSchedule shows backup schedule
 func (m *MenuModel) handleSchedule() (tea.Model, tea.Cmd) {
 	schedule := NewScheduleView(m.config, m.logger, m)
@@ -466,6 +467,7 @@ func (m *MenuModel) handleChain() (tea.Model, tea.Cmd) {
 	chain := NewChainView(m.config, m.logger, m)
 	return chain, chain.Init()
 }
+
 // handleTools opens the tools submenu
 func (m *MenuModel) handleTools() (tea.Model, tea.Cmd) {
 	tools := NewToolsMenu(m.config, m.logger, m, m.ctx)

internal/tui/schedule.go

@@ -14,21 +14,21 @@ import (
 
 // ScheduleView displays systemd timer schedules
 type ScheduleView struct {
-	config    *config.Config
-	logger    logger.Logger
-	parent    tea.Model
-	timers    []TimerInfo
-	loading   bool
-	error     string
-	quitting  bool
+	config   *config.Config
+	logger   logger.Logger
+	parent   tea.Model
+	timers   []TimerInfo
+	loading  bool
+	error    string
+	quitting bool
 }
 
 type TimerInfo struct {
-	Name     string
-	NextRun  string
-	Left     string
-	LastRun  string
-	Active   string
+	Name    string
+	NextRun string
+	Left    string
+	LastRun string
+	Active  string
 }
 
 func NewScheduleView(cfg *config.Config, log logger.Logger, parent tea.Model) *ScheduleView {
@@ -66,16 +66,16 @@ func (s *ScheduleView) loadTimers() tea.Msg {
 	}
 
 	timers := parseTimerList(string(output))
-	
+
 	// Filter for backup-related timers
 	var filtered []TimerInfo
 	for _, timer := range timers {
 		name := strings.ToLower(timer.Name)
-		if strings.Contains(name, "backup") || 
-		   strings.Contains(name, "dbbackup") ||
-		   strings.Contains(name, "postgres") ||
-		   strings.Contains(name, "mysql") ||
-		   strings.Contains(name, "mariadb") {
+		if strings.Contains(name, "backup") ||
+			strings.Contains(name, "dbbackup") ||
+			strings.Contains(name, "postgres") ||
+			strings.Contains(name, "mysql") ||
+			strings.Contains(name, "mariadb") {
 			filtered = append(filtered, timer)
 		}
 	}