feat(ui): add dark/light/system theme support with toggle

cmd/main.go

@@ -20,10 +20,9 @@ import (
 	"path/filepath"
 
 	"github.com/Adembc/lazyssh/internal/adapters/data/ssh_config_file"
-	"github.com/Adembc/lazyssh/internal/logger"
-
 	"github.com/Adembc/lazyssh/internal/adapters/ui"
 	"github.com/Adembc/lazyssh/internal/core/services"
+	"github.com/Adembc/lazyssh/internal/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -51,6 +50,13 @@ func main() {
 	sshConfigFile := filepath.Join(home, ".ssh", "config")
 	metaDataFile := filepath.Join(home, ".lazyssh", "metadata.json")
 
+	// Load theme preference before creating UI
+	settings, err := ssh_config_file.LoadSettings(metaDataFile)
+	if err != nil {
+		log.Warnw("failed to load settings, using default theme", "error", err)
+	}
+	ui.SetTheme(settings.Theme)
+
 	serverRepo := ssh_config_file.NewRepository(log, sshConfigFile, metaDataFile)
 	serverService := services.NewServerService(log, serverRepo)
 	tui := ui.NewTUI(log, serverService, version, gitCommit)

internal/adapters/data/ssh_config_file/metadata_manager.go

@@ -25,13 +25,26 @@ import (
 	"go.uber.org/zap"
 )
 
+// Settings contains application-level settings stored in the metadata file.
+type Settings struct {
+	Theme string `json:"theme,omitempty"`
+}
+
+// ServerMetadata contains per-server metadata that is not part of SSH config.
 type ServerMetadata struct {
 	Tags     []string `json:"tags,omitempty"`
 	LastSeen string   `json:"last_seen,omitempty"`
 	PinnedAt string   `json:"pinned_at,omitempty"`
 	SSHCount int      `json:"ssh_count,omitempty"`
 }
 
+// MetadataFile is the top-level structure of the metadata JSON file.
+// It contains both application settings and per-server metadata.
+type MetadataFile struct {
+	Settings Settings                  `json:"settings,omitempty"`
+	Servers  map[string]ServerMetadata `json:"servers,omitempty"`
+}
+
 type metadataManager struct {
 	filePath string
 	logger   *zap.SugaredLogger
@@ -41,11 +54,16 @@ func newMetadataManager(filePath string, logger *zap.SugaredLogger) *metadataMan
 	return &metadataManager{filePath: filePath, logger: logger}
 }
 
-func (m *metadataManager) loadAll() (map[string]ServerMetadata, error) {
-	metadata := make(map[string]ServerMetadata)
+// loadFile loads the entire metadata file, handling both old and new formats.
+// Old format: {"server1": {...}, "server2": {...}}
+// New format: {"settings": {...}, "servers": {"server1": {...}, ...}}
+func (m *metadataManager) loadFile() (*MetadataFile, error) {
+	result := &MetadataFile{
+		Servers: make(map[string]ServerMetadata),
+	}
 
 	if _, err := os.Stat(m.filePath); os.IsNotExist(err) {
-		return metadata, nil
+		return result, nil
 	}
 
 	data, err := os.ReadFile(m.filePath)
@@ -54,24 +72,51 @@ func (m *metadataManager) loadAll() (map[string]ServerMetadata, error) {
 	}
 
 	if len(data) == 0 {
-		return metadata, nil
+		return result, nil
 	}
 
-	if err := json.Unmarshal(data, &metadata); err != nil {
+	// First, try to parse as the new format
+	if err := json.Unmarshal(data, result); err != nil {
 		return nil, fmt.Errorf("parse metadata JSON '%s': %w", m.filePath, err)
 	}
 
-	return metadata, nil
+	// Check if this was the old format (no "servers" key, just server entries at root)
+	// In the old format, result.Servers will be nil/empty and the root object contains server data
+	if len(result.Servers) == 0 {
+		// Try parsing as old format (map of server metadata directly)
+		var oldFormat map[string]ServerMetadata
+		if err := json.Unmarshal(data, &oldFormat); err == nil {
+			// Check if this looks like server metadata (has expected fields)
+			// and not a settings object
+			isOldFormat := false
+			for _, v := range oldFormat {
+				// If any entry has tags, last_seen, pinned_at, or ssh_count, it's old format
+				if len(v.Tags) > 0 || v.LastSeen != "" || v.PinnedAt != "" || v.SSHCount > 0 {
+					isOldFormat = true
+					break
+				}
+			}
+			if isOldFormat {
+				result.Servers = oldFormat
+			}
+		}
+	}
+
+	if result.Servers == nil {
+		result.Servers = make(map[string]ServerMetadata)
+	}
+
+	return result, nil
 }
 
-func (m *metadataManager) saveAll(metadata map[string]ServerMetadata) error {
+// saveFile saves the entire metadata file in the new format.
+func (m *metadataManager) saveFile(file *MetadataFile) error {
 	if err := m.ensureDirectory(); err != nil {
 		m.logger.Errorw("failed to ensure metadata directory", "path", m.filePath, "error", err)
-
 		return fmt.Errorf("ensure metadata directory for '%s': %w", m.filePath, err)
 	}
 
-	data, err := json.MarshalIndent(metadata, "", "  ")
+	data, err := json.MarshalIndent(file, "", "  ")
 	if err != nil {
 		m.logger.Errorw("failed to marshal metadata", "path", m.filePath, "error", err)
 		return fmt.Errorf("marshal metadata for '%s': %w", m.filePath, err)
@@ -84,6 +129,46 @@ func (m *metadataManager) saveAll(metadata map[string]ServerMetadata) error {
 	return nil
 }
 
+// GetSettings returns the application settings from the metadata file.
+func (m *metadataManager) GetSettings() (Settings, error) {
+	file, err := m.loadFile()
+	if err != nil {
+		return Settings{}, err
+	}
+	return file.Settings, nil
+}
+
+// SaveSettings saves the application settings to the metadata file.
+func (m *metadataManager) SaveSettings(settings Settings) error {
+	file, err := m.loadFile()
+	if err != nil {
+		m.logger.Errorw("failed to load metadata in SaveSettings", "path", m.filePath, "error", err)
+		return fmt.Errorf("load metadata: %w", err)
+	}
+
+	file.Settings = settings
+	return m.saveFile(file)
+}
+
+func (m *metadataManager) loadAll() (map[string]ServerMetadata, error) {
+	file, err := m.loadFile()
+	if err != nil {
+		return nil, err
+	}
+	return file.Servers, nil
+}
+
+func (m *metadataManager) saveAll(metadata map[string]ServerMetadata) error {
+	file, err := m.loadFile()
+	if err != nil {
+		// If we can't load, start fresh but preserve any settings
+		file = &MetadataFile{}
+	}
+
+	file.Servers = metadata
+	return m.saveFile(file)
+}
+
 func (m *metadataManager) updateServer(server domain.Server, oldAlias string) error {
 	metadata, err := m.loadAll()
 	if err != nil {

internal/adapters/data/ssh_config_file/settings_test.go

@@ -0,0 +1,195 @@
+// Copyright 2025.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ssh_config_file
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoadSettings_NonExistentFile(t *testing.T) {
+	settings, err := LoadSettings("/nonexistent/path/metadata.json")
+	if err != nil {
+		t.Errorf("LoadSettings() with non-existent file should not error, got %v", err)
+	}
+	if settings.Theme != "" {
+		t.Errorf("LoadSettings() with non-existent file should return empty theme, got %q", settings.Theme)
+	}
+}
+
+func TestLoadSettings_EmptyFile(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "metadata.json")
+
+	if err := os.WriteFile(tmpFile, []byte{}, 0o644); err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+
+	settings, err := LoadSettings(tmpFile)
+	if err != nil {
+		t.Errorf("LoadSettings() with empty file should not error, got %v", err)
+	}
+	if settings.Theme != "" {
+		t.Errorf("LoadSettings() with empty file should return empty theme, got %q", settings.Theme)
+	}
+}
+
+func TestLoadSettings_NewFormat(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "metadata.json")
+
+	content := `{
+		"settings": {"theme": "light"},
+		"servers": {"server1": {"tags": ["prod"]}}
+	}`
+	if err := os.WriteFile(tmpFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+
+	settings, err := LoadSettings(tmpFile)
+	if err != nil {
+		t.Errorf("LoadSettings() unexpected error: %v", err)
+	}
+	if settings.Theme != "light" {
+		t.Errorf("LoadSettings() theme = %q, want %q", settings.Theme, "light")
+	}
+}
+
+func TestLoadSettings_OldFormat(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "metadata.json")
+
+	// Old format: servers directly at root level
+	content := `{
+		"server1": {"tags": ["prod"], "ssh_count": 5},
+		"server2": {"tags": ["dev"]}
+	}`
+	if err := os.WriteFile(tmpFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+
+	settings, err := LoadSettings(tmpFile)
+	if err != nil {
+		t.Errorf("LoadSettings() unexpected error: %v", err)
+	}
+	// Old format has no settings, should return empty theme
+	if settings.Theme != "" {
+		t.Errorf("LoadSettings() with old format should return empty theme, got %q", settings.Theme)
+	}
+}
+
+func TestMetadataManager_SaveAndGetSettings(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "metadata.json")
+
+	mm := newMetadataManager(tmpFile, nil)
+
+	// Save settings
+	settings := Settings{Theme: "light"}
+	if err := mm.SaveSettings(settings); err != nil {
+		t.Fatalf("SaveSettings() unexpected error: %v", err)
+	}
+
+	// Read back
+	got, err := mm.GetSettings()
+	if err != nil {
+		t.Fatalf("GetSettings() unexpected error: %v", err)
+	}
+	if got.Theme != "light" {
+		t.Errorf("GetSettings() theme = %q, want %q", got.Theme, "light")
+	}
+}
+
+func TestMetadataManager_SettingsPreserveServers(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "metadata.json")
+
+	mm := newMetadataManager(tmpFile, nil)
+
+	// First, save some server metadata
+	serverMeta := map[string]ServerMetadata{
+		"server1": {Tags: []string{"prod"}, SSHCount: 5},
+	}
+	if err := mm.saveAll(serverMeta); err != nil {
+		t.Fatalf("saveAll() unexpected error: %v", err)
+	}
+
+	// Now save settings
+	settings := Settings{Theme: "light"}
+	if err := mm.SaveSettings(settings); err != nil {
+		t.Fatalf("SaveSettings() unexpected error: %v", err)
+	}
+
+	// Verify servers are still there
+	servers, err := mm.loadAll()
+	if err != nil {
+		t.Fatalf("loadAll() unexpected error: %v", err)
+	}
+	if len(servers) != 1 {
+		t.Errorf("Expected 1 server, got %d", len(servers))
+	}
+	if servers["server1"].SSHCount != 5 {
+		t.Errorf("Server metadata was not preserved, SSHCount = %d, want 5", servers["server1"].SSHCount)
+	}
+
+	// Verify settings are there too
+	got, err := mm.GetSettings()
+	if err != nil {
+		t.Fatalf("GetSettings() unexpected error: %v", err)
+	}
+	if got.Theme != "light" {
+		t.Errorf("GetSettings() theme = %q, want %q", got.Theme, "light")
+	}
+}
+
+func TestMetadataManager_ServersSavePreservesSettings(t *testing.T) {
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "metadata.json")
+
+	mm := newMetadataManager(tmpFile, nil)
+
+	// First, save settings
+	settings := Settings{Theme: "light"}
+	if err := mm.SaveSettings(settings); err != nil {
+		t.Fatalf("SaveSettings() unexpected error: %v", err)
+	}
+
+	// Now save server metadata
+	serverMeta := map[string]ServerMetadata{
+		"server1": {Tags: []string{"prod"}, SSHCount: 10},
+	}
+	if err := mm.saveAll(serverMeta); err != nil {
+		t.Fatalf("saveAll() unexpected error: %v", err)
+	}
+
+	// Verify settings are still there
+	got, err := mm.GetSettings()
+	if err != nil {
+		t.Fatalf("GetSettings() unexpected error: %v", err)
+	}
+	if got.Theme != "light" {
+		t.Errorf("Settings were not preserved, theme = %q, want %q", got.Theme, "light")
+	}
+
+	// Verify servers are there too
+	servers, err := mm.loadAll()
+	if err != nil {
+		t.Fatalf("loadAll() unexpected error: %v", err)
+	}
+	if servers["server1"].SSHCount != 10 {
+		t.Errorf("Server metadata incorrect, SSHCount = %d, want 10", servers["server1"].SSHCount)
+	}
+}