feat: add NeonPulse theme and DIMM temperature sensors

- Add NeonPulse theme with 2x2 grid layout (device/storage, CPU, GPU, memory)
- Add DIMM temperature reading from spd5118 sensors (DDR5)
- Add disk labels feature for custom mount point names
- Add network speed display in device panel
- Load sensor_options from config in theme dev command
- Remove unused CPU power/voltage fields

Author: oae

cmd/sensor.go

@@ -2,12 +2,14 @@ package cmd
 
 import (
 	"bufio"
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 
+	"github.com/alperen/sensorpanel/pkg/config"
 	"github.com/alperen/sensorpanel/pkg/sensors"
 	"github.com/spf13/cobra"
 )
@@ -51,15 +53,30 @@ or configured in the config file.`,
 	RunE: runSensorOpts,
 }
 
+var sensorReadCmd = &cobra.Command{
+	Use:   "read [sensor_id...]",
+	Short: "Read current sensor values",
+	Long: `Read and display current values from all or specified sensors.
+
+Examples:
+  sensorpanel sensor read           # Read all sensors
+  sensorpanel sensor read cpu       # Read only CPU sensor
+  sensorpanel sensor read cpu memory # Read CPU and memory sensors
+  sensorpanel sensor read --json    # Output as JSON`,
+	RunE: runSensorRead,
+}
+
 func init() {
 	rootCmd.AddCommand(sensorCmd)
 	sensorCmd.AddCommand(sensorListCmd)
 	sensorCmd.AddCommand(sensorTypesCmd)
 	sensorCmd.AddCommand(sensorCreateCmd)
 	sensorCmd.AddCommand(sensorOptsCmd)
+	sensorCmd.AddCommand(sensorReadCmd)
 
 	sensorListCmd.Flags().BoolP("available", "a", false, "Only show available sensors on this system")
 	sensorTypesCmd.Flags().StringP("output", "o", "", "Output file path (default: stdout)")
+	sensorReadCmd.Flags().BoolP("json", "j", false, "Output as JSON")
 }
 
 func runSensorList(cmd *cobra.Command, args []string) error {
@@ -489,6 +506,191 @@ func sensorToCamelCase(s string) string {
 	return result
 }
 
+func runSensorRead(cmd *cobra.Command, args []string) error {
+	jsonOutput, _ := cmd.Flags().GetBool("json")
+
+	// Load config from file to get sensor options
+	cfg, err := config.Load()
+	if err != nil {
+		// Fall back to default config if no config file
+		cfg = &config.Config{}
+	}
+
+	// Create sensor config with options from config file
+	sensorConfig := sensors.DefaultConfig()
+	if cfg.SensorOptions != nil {
+		sensorConfig.Options = make(map[string]interface{})
+		for k, v := range cfg.SensorOptions {
+			sensorConfig.Options[k] = v
+		}
+	}
+
+	collector := sensors.NewCollector(sensorConfig)
+
+	// Collect data
+	var data map[string]interface{}
+
+	if len(args) == 0 {
+		// Collect all sensors
+		data = collector.CollectAll()
+	} else {
+		// Collect specified sensors
+		data = make(map[string]interface{})
+		for _, id := range args {
+			if sensorData, ok := collector.CollectByID(id); ok {
+				data[id] = sensorData
+			} else {
+				fmt.Fprintf(os.Stderr, "Warning: sensor '%s' not available\n", id)
+			}
+		}
+	}
+
+	if len(data) == 0 {
+		fmt.Println("No sensor data available.")
+		return nil
+	}
+
+	// Output as JSON
+	if jsonOutput {
+		jsonBytes, err := jsonMarshalIndent(data)
+		if err != nil {
+			return fmt.Errorf("failed to marshal JSON: %w", err)
+		}
+		fmt.Println(string(jsonBytes))
+		return nil
+	}
+
+	// Pretty print output
+	registry := sensors.GlobalRegistry()
+
+	// Group sensors by category for display
+	categories := make(map[string][]string)
+	for sensorID := range data {
+		if p, ok := registry.Get(sensorID); ok {
+			cat := p.Meta().Category
+			categories[cat] = append(categories[cat], sensorID)
+		}
+	}
+
+	// Sort categories
+	catNames := make([]string, 0, len(categories))
+	for cat := range categories {
+		catNames = append(catNames, cat)
+	}
+	sort.Strings(catNames)
+
+	for _, cat := range catNames {
+		fmt.Printf("\n[%s]\n", strings.ToUpper(cat))
+
+		sensorIDs := categories[cat]
+		sort.Strings(sensorIDs)
+
+		for _, sensorID := range sensorIDs {
+			sensorData := data[sensorID]
+			p, _ := registry.Get(sensorID)
+			meta := p.Meta()
+
+			fmt.Printf("  %s\n", meta.Name)
+
+			// Handle map data (arrays like disk, network)
+			if meta.IsArray {
+				if mapData, ok := sensorData.(map[string]interface{}); ok {
+					// Array sensors store items in "_items" key
+					if items, ok := mapData["_items"].([]map[string]interface{}); ok {
+						for _, item := range items {
+							// Use the array key field as the header
+							keyValue := ""
+							if v, ok := item[meta.ArrayKey]; ok {
+								keyValue = fmt.Sprintf("%v", v)
+							}
+							fmt.Printf("    [%s]\n", keyValue)
+							printSensorFields(meta.Fields, item, "      ")
+						}
+					} else if items, ok := mapData["_items"].([]interface{}); ok {
+						// Handle case where items are []interface{}
+						for _, item := range items {
+							if itemMap, ok := item.(map[string]interface{}); ok {
+								keyValue := ""
+								if v, ok := itemMap[meta.ArrayKey]; ok {
+									keyValue = fmt.Sprintf("%v", v)
+								}
+								fmt.Printf("    [%s]\n", keyValue)
+								printSensorFields(meta.Fields, itemMap, "      ")
+							}
+						}
+					}
+				}
+			} else {
+				// Single sensor data
+				if mapData, ok := sensorData.(map[string]interface{}); ok {
+					printSensorFields(meta.Fields, mapData, "    ")
+				}
+			}
+		}
+	}
+
+	fmt.Println()
+	return nil
+}
+
+func printSensorFields(fields []sensors.FieldDef, data map[string]interface{}, indent string) {
+	for _, field := range fields {
+		value, ok := data[field.JSONName]
+		if !ok {
+			continue
+		}
+
+		// Format value based on type and unit
+		var formatted string
+		switch v := value.(type) {
+		case float64:
+			if field.Unit == "%" {
+				formatted = fmt.Sprintf("%.1f%%", v)
+			} else if field.Unit == "°C" {
+				formatted = fmt.Sprintf("%.1f°C", v)
+			} else if field.Unit == "W" {
+				formatted = fmt.Sprintf("%.2f W", v)
+			} else if field.Unit == "V" {
+				formatted = fmt.Sprintf("%.3f V", v)
+			} else if field.Unit == "MHz" {
+				formatted = fmt.Sprintf("%.0f MHz", v)
+			} else if field.Unit == "RPM" {
+				formatted = fmt.Sprintf("%.0f RPM", v)
+			} else if field.Unit == "MB" {
+				if v >= 1024 {
+					formatted = fmt.Sprintf("%.1f GB", v/1024)
+				} else {
+					formatted = fmt.Sprintf("%.0f MB", v)
+				}
+			} else if field.Unit == "GB" {
+				formatted = fmt.Sprintf("%.1f GB", v)
+			} else if field.Unit == "B/s" {
+				formatted = sensors.FormatBytesPerSec(v)
+			} else if field.Unit == "bytes" {
+				formatted = sensors.FormatBytes(v)
+			} else {
+				formatted = fmt.Sprintf("%.2f", v)
+			}
+		case string:
+			formatted = v
+		case bool:
+			if v {
+				formatted = "yes"
+			} else {
+				formatted = "no"
+			}
+		default:
+			formatted = fmt.Sprintf("%v", v)
+		}
+
+		fmt.Printf("%s%-16s %s\n", indent, field.Name+":", formatted)
+	}
+}
+
+func jsonMarshalIndent(v interface{}) ([]byte, error) {
+	return json.MarshalIndent(v, "", "  ")
+}
+
 func runSensorOpts(cmd *cobra.Command, args []string) error {
 	registry := sensors.GlobalRegistry()
 	options := registry.AllOptions()

cmd/theme.go

@@ -261,10 +261,20 @@ Press Ctrl+C to stop all servers.`,
 		fmt.Printf("Starting development server for theme: %s\n", themeName)
 		fmt.Printf("Theme path: %s\n\n", t.Path)
 
-		// Parse sensor options from --opt flags
+		// Load sensor options from config file first
 		var sensorOptions map[string]interface{}
-		if len(themeDevOpts) > 0 {
+		if cfg, err := config.Load(); err == nil && cfg.SensorOptions != nil {
 			sensorOptions = make(map[string]interface{})
+			for k, v := range cfg.SensorOptions {
+				sensorOptions[k] = v
+			}
+		}
+
+		// Override with --opt flags if provided
+		if len(themeDevOpts) > 0 {
+			if sensorOptions == nil {
+				sensorOptions = make(map[string]interface{})
+			}
 			for _, opt := range themeDevOpts {
 				key, value, ok := strings.Cut(opt, "=")
 				if !ok {

pkg/sensors/cpu_linux.go

@@ -33,8 +33,6 @@ func (p *CPUProvider) Meta() SensorMeta {
 			{Name: "Temperature", JSONName: "temperature", TSName: "temperature", Type: FieldTypeOptionalNumber, Unit: "°C", Description: "CPU temperature"},
 			{Name: "Frequency", JSONName: "frequency", TSName: "frequency", Type: FieldTypeOptionalNumber, Unit: "MHz", Description: "CPU frequency"},
 			{Name: "Cores", JSONName: "cores", TSName: "cores", Type: FieldTypeNumber, Unit: "", Description: "Number of CPU cores"},
-			{Name: "Power", JSONName: "power", TSName: "power", Type: FieldTypeOptionalNumber, Unit: "W", Description: "CPU package power"},
-			{Name: "Voltage", JSONName: "voltage", TSName: "voltage", Type: FieldTypeOptionalNumber, Unit: "V", Description: "CPU core voltage"},
 		},
 	}
 }
@@ -69,16 +67,6 @@ func (p *CPUProvider) Collect(state *CollectorState) map[string]interface{} {
 	// Get core count
 	result["cores"] = runtime.NumCPU()
 
-	// Get power (from RAPL or hwmon)
-	if power := p.collectPower(); power != nil {
-		result["power"] = *power
-	}
-
-	// Get voltage (from hwmon)
-	if voltage := p.collectVoltage(); voltage != nil {
-		result["voltage"] = *voltage
-	}
-
 	return result
 }
 
@@ -254,89 +242,3 @@ func (p *CPUProvider) collectName() string {
 
 	return "Unknown CPU"
 }
-
-func (p *CPUProvider) collectPower() *float64 {
-	// Try RAPL (Running Average Power Limit) for Intel/AMD
-	raplPaths, _ := filepath.Glob("/sys/class/powercap/intel-rapl:0/energy_uj")
-	for _, raplPath := range raplPaths {
-		// RAPL gives cumulative energy, we'd need to track delta
-		// For now, try hwmon power sensors instead
-		_ = raplPath
-	}
-
-	// Try hwmon power sensors (zenpower, k10temp with power)
-	hwmonPaths, _ := filepath.Glob("/sys/class/hwmon/hwmon*/name")
-	for _, namePath := range hwmonPaths {
-		nameBytes, err := os.ReadFile(namePath)
-		if err != nil {
-			continue
-		}
-		name := strings.TrimSpace(string(nameBytes))
-
-		// Look for CPU power sensors
-		if strings.Contains(name, "zenpower") || strings.Contains(name, "k10temp") {
-			dir := filepath.Dir(namePath)
-			powerFiles, _ := filepath.Glob(filepath.Join(dir, "power*_input"))
-			for _, powerFile := range powerFiles {
-				data, err := os.ReadFile(powerFile)
-				if err != nil {
-					continue
-				}
-				microW, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)
-				if err != nil {
-					continue
-				}
-				power := float64(microW) / 1000000.0
-				return &power
-			}
-		}
-	}
-
-	return nil
-}
-
-func (p *CPUProvider) collectVoltage() *float64 {
-	// Try hwmon voltage sensors
-	hwmonPaths, _ := filepath.Glob("/sys/class/hwmon/hwmon*/name")
-	for _, namePath := range hwmonPaths {
-		nameBytes, err := os.ReadFile(namePath)
-		if err != nil {
-			continue
-		}
-		name := strings.TrimSpace(string(nameBytes))
-
-		// Look for CPU voltage sensors (zenpower, nct6687, etc.)
-		if strings.Contains(name, "zenpower") || strings.Contains(name, "nct6") {
-			dir := filepath.Dir(namePath)
-
-			// Try labeled voltage inputs first
-			inLabels, _ := filepath.Glob(filepath.Join(dir, "in*_label"))
-			for _, labelPath := range inLabels {
-				labelBytes, err := os.ReadFile(labelPath)
-				if err != nil {
-					continue
-				}
-				label := strings.TrimSpace(string(labelBytes))
-
-				// Look for CPU core voltage labels
-				if strings.Contains(strings.ToLower(label), "vcore") ||
-					strings.Contains(strings.ToLower(label), "cpu") ||
-					strings.Contains(strings.ToLower(label), "svi2_core") {
-					inputPath := strings.Replace(labelPath, "_label", "_input", 1)
-					data, err := os.ReadFile(inputPath)
-					if err != nil {
-						continue
-					}
-					milliV, err := strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)
-					if err != nil {
-						continue
-					}
-					voltage := float64(milliV) / 1000.0
-					return &voltage
-				}
-			}
-		}
-	}
-
-	return nil
-}