feat: Implement configurable refresh intervals for tabs, globally and per-tab.

Author: sumant1122

README.md

@@ -55,9 +55,24 @@ cmd = ["top", "-b", "-n", "1"]
 - Memory: `free -m` (Linux)
 - Net: `/proc/net/dev` (Linux) or `netstat -ib` (macOS)
 
-If no configuration file is found, Perfmon falls back to a sensible set of defaults (uptime, vmstat, mpstat, iostat, free, sar, top, neofetch).
+If no configuration file is found, Perfmon falls back to a sensible set of defaults.
 
-If a command is missing, the tab is disabled and a hint is shown.
+### Configuration
+You can customize tabs and refresh rates in `perfmon.toml`.
+
+```toml
+# Global refresh rate (default: 5s)
+global_refresh_interval = "5s"
+
+[[tab]]
+title = "uptime"
+cmd = ["uptime"]
+
+[[tab]]
+title = "top (fast)"
+cmd = ["top", "-b", "-n", "1"]
+refresh_interval = "1s" # Override global rate
+```
 
 
 ## Development

internal/config/config.go

@@ -7,35 +7,58 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/BurntSushi/toml"
 )
 
 type Tab struct {
-	Title       string   `toml:"title"`
-	Cmd         []string `toml:"cmd"`
-	Disabled    bool     `toml:"-"`
-	DisabledMsg string   `toml:"-"`
+	Title           string   `toml:"title"`
+	Cmd             []string `toml:"cmd"`
+	Disabled        bool     `toml:"-"`
+	DisabledMsg     string   `toml:"-"`
+	RefreshInterval duration `toml:"refresh_interval"`
 }
 
 type Config struct {
-	Tabs []Tab `toml:"tab"`
+	Tabs                  []Tab    `toml:"tab"`
+	GlobalRefreshInterval duration `toml:"global_refresh_interval"`
 }
 
-func Load() []Tab {
-	if cfgTabs, ok := loadFromConfig(); ok {
-		validated := make([]Tab, 0, len(cfgTabs))
-		for _, t := range cfgTabs {
+// Custom duration type for TOML parsing
+type duration struct {
+	time.Duration
+}
+
+func (d *duration) UnmarshalText(text []byte) error {
+	var err error
+	d.Duration, err = time.ParseDuration(string(text))
+	return err
+}
+
+func Load() (Config, []Tab) {
+	if cfg, ok := loadFromConfig(); ok {
+		validated := make([]Tab, 0, len(cfg.Tabs))
+		for _, t := range cfg.Tabs {
 			validated = append(validated, validateTab(t))
 		}
 		if len(validated) > 0 {
-			return validated
+			// Apply global refresh if tab refresh is missing
+			if cfg.GlobalRefreshInterval.Duration <= 0 {
+				cfg.GlobalRefreshInterval.Duration = 5 * time.Second
+			}
+			for i := range validated {
+				if validated[i].RefreshInterval.Duration <= 0 {
+					validated[i].RefreshInterval = cfg.GlobalRefreshInterval
+				}
+			}
+			return cfg, validated
 		}
 	}
-	return buildDefaultTabs()
+	return Config{GlobalRefreshInterval: duration{5 * time.Second}}, buildDefaultTabs()
 }
 
-func loadFromConfig() ([]Tab, bool) {
+func loadFromConfig() (Config, bool) {
 	paths := configPaths()
 	for _, path := range paths {
 		data, err := os.ReadFile(path)
@@ -50,20 +73,21 @@ func loadFromConfig() ([]Tab, bool) {
 		if len(cfg.Tabs) == 0 {
 			continue
 		}
-		
+
 		// Filter invalid tabs
 		validTabs := make([]Tab, 0, len(cfg.Tabs))
 		for _, t := range cfg.Tabs {
 			if t.Title != "" && len(t.Cmd) > 0 {
 				validTabs = append(validTabs, t)
 			}
 		}
-		
+
 		if len(validTabs) > 0 {
-			return validTabs, true
+			cfg.Tabs = validTabs
+			return cfg, true
 		}
 	}
-	return nil, false
+	return Config{}, false
 }
 
 func configPaths() []string {
@@ -134,17 +158,19 @@ func buildDefaultTabs() []Tab {
 
 	fetchTitle, fetchCmd := detectFetchCmd()
 
+	defaultInterval := duration{5 * time.Second}
+
 	tabs := []Tab{
-		{Title: "uptime", Cmd: []string{"uptime"}},
-		{Title: "vmstat", Cmd: []string{"vmstat"}},
-		{Title: "mpstat -P ALL", Cmd: []string{"mpstat", "-P", "ALL"}},
-		{Title: "pidstat -p ALL", Cmd: []string{"pidstat", "-p", "ALL"}},
-		{Title: "iostat", Cmd: []string{"iostat"}},
-		{Title: freeTitle, Cmd: freeCmd},
-		{Title: "sar -n DEV", Cmd: []string{"sar", "-n", "DEV"}},
-		{Title: "sar -n TCP,ETCP", Cmd: []string{"sar", "-n", "TCP,ETCP"}},
-		{Title: topTitle, Cmd: topCmd},
-		{Title: fetchTitle, Cmd: fetchCmd},
+		{Title: "uptime", Cmd: []string{"uptime"}, RefreshInterval: defaultInterval},
+		{Title: "vmstat", Cmd: []string{"vmstat"}, RefreshInterval: defaultInterval},
+		{Title: "mpstat -P ALL", Cmd: []string{"mpstat", "-P", "ALL"}, RefreshInterval: defaultInterval},
+		{Title: "pidstat -p ALL", Cmd: []string{"pidstat", "-p", "ALL"}, RefreshInterval: defaultInterval},
+		{Title: "iostat", Cmd: []string{"iostat"}, RefreshInterval: defaultInterval},
+		{Title: freeTitle, Cmd: freeCmd, RefreshInterval: defaultInterval},
+		{Title: "sar -n DEV", Cmd: []string{"sar", "-n", "DEV"}, RefreshInterval: defaultInterval},
+		{Title: "sar -n TCP,ETCP", Cmd: []string{"sar", "-n", "TCP,ETCP"}, RefreshInterval: defaultInterval},
+		{Title: topTitle, Cmd: topCmd, RefreshInterval: defaultInterval},
+		{Title: fetchTitle, Cmd: fetchCmd, RefreshInterval: defaultInterval},
 	}
 
 	for i := range tabs {

internal/config/config_test.go

@@ -4,39 +4,48 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
+
 	"github.com/BurntSushi/toml"
 )
 
 func TestParseTomlConfig(t *testing.T) {
 	data := []byte(`
+global_refresh_interval = "10s"
+
 [[tab]]
 title = "uptime"
 cmd = ["uptime"]
 
 [[tab]]
 title = "top"
 cmd = ["top","-b","-n","1"]
+refresh_interval = "1s"
 `)
 	var cfg Config
 	if _, err := toml.Decode(string(data), &cfg); err != nil {
 		t.Fatalf("parse error: %v", err)
 	}
 
+	if cfg.GlobalRefreshInterval.Duration != 10*time.Second {
+		t.Errorf("expected global 10s, got %v", cfg.GlobalRefreshInterval.Duration)
+	}
+
 	if len(cfg.Tabs) != 2 {
 		t.Fatalf("expected 2 tabs, got %d", len(cfg.Tabs))
 	}
-	if cfg.Tabs[0].Title != "uptime" || len(cfg.Tabs[0].Cmd) != 1 {
-		t.Fatalf("unexpected first tab: %+v", cfg.Tabs[0])
-	}
-	if cfg.Tabs[1].Cmd[0] != "top" || cfg.Tabs[1].Cmd[3] != "1" {
-		t.Fatalf("unexpected second tab cmd: %+v", cfg.Tabs[1].Cmd)
+
+	// Note: Load() handles applying global defaults to tabs, so we just check raw parsing here
+	if cfg.Tabs[1].RefreshInterval.Duration != 1*time.Second {
+		t.Errorf("expected tab 1s, got %v", cfg.Tabs[1].RefreshInterval.Duration)
 	}
 }
 
 func TestLoadTabsFromConfig(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "perfmon.toml")
 	err := os.WriteFile(path, []byte(`
+global_refresh_interval = "2s"
 [[tab]]
 title = "vmstat"
 cmd = ["vmstat"]
@@ -46,11 +55,13 @@ cmd = ["vmstat"]
 	}
 
 	t.Setenv("PERFMON_CONFIG", path)
-	tabs, ok := loadFromConfig()
-	if !ok {
-		t.Fatalf("expected config load")
+	_, tabs := Load() // Load now returns (Config, []Tab)
+
+	if len(tabs) != 1 {
+		t.Fatalf("expected 1 tab")
 	}
-	if len(tabs) != 1 || tabs[0].Title != "vmstat" || tabs[0].Cmd[0] != "vmstat" {
-		t.Fatalf("unexpected tabs: %+v", tabs)
+
+	if tabs[0].RefreshInterval.Duration != 2*time.Second {
+		t.Errorf("expected inherited 2s refresh, got %v", tabs[0].RefreshInterval.Duration)
 	}
 }

internal/ui/model.go

@@ -34,7 +34,6 @@ type systemMsg struct {
 }
 
 const (
-	refreshInterval = 5 * time.Second
 	spinnerInterval = 200 * time.Millisecond
 	fixedRows       = 9
 )
@@ -60,8 +59,12 @@ func NewModel() Model {
 	vp := viewport.New(0, 0)
 	vp.SetContent("Loading...")
 
+	// config.Load() now returns (Config, []Tab), we only need []Tab here
+	// but the signature of Load changed in previous step, so we need to adapt
+	_, tabs := config.Load()
+
 	return Model{
-		tabs:       config.Load(),
+		tabs:       tabs,
 		active:     0,
 		viewport:   vp,
 		themeIndex: 0,
@@ -70,15 +73,18 @@ func NewModel() Model {
 }
 
 func (m Model) Init() tea.Cmd {
+	interval := m.tabs[m.active].RefreshInterval.Duration
 	if m.tabs[m.active].Disabled {
 		m.content = m.tabs[m.active].DisabledMsg
 		m.viewport.SetContent(m.content)
-		return tea.Batch(tick(), spinnerTick(), sampleMetricsCmd(), sampleSystemCmd())
+		return tea.Batch(tick(interval), spinnerTick(), sampleMetricsCmd(), sampleSystemCmd())
 	}
-	return tea.Batch(runCommandCmd(m.tabs[m.active]), tick(), spinnerTick(), sampleMetricsCmd(), sampleSystemCmd())
+	return tea.Batch(runCommandCmd(m.tabs[m.active]), tick(interval), spinnerTick(), sampleMetricsCmd(), sampleSystemCmd())
 }
 
 func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	interval := m.tabs[m.active].RefreshInterval.Duration
+
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
 		if isQuitKey(msg) {
@@ -109,9 +115,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.viewport.SetContent(m.content)
 	case tickMsg:
 		if m.tabs[m.active].Disabled {
-			return m, tea.Batch(tick(), sampleMetricsCmd(), sampleSystemCmd())
+			return m, tea.Batch(tick(interval), sampleMetricsCmd(), sampleSystemCmd())
 		}
-		return m, tea.Batch(runCommandCmd(m.tabs[m.active]), tick(), sampleMetricsCmd(), sampleSystemCmd())
+		return m, tea.Batch(runCommandCmd(m.tabs[m.active]), tick(interval), sampleMetricsCmd(), sampleSystemCmd())
 	case spinnerMsg:
 		m.spinnerIdx = (m.spinnerIdx + 1) % len(spinnerFrames)
 		return m, spinnerTick()
@@ -124,7 +130,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if msg.err != nil {
 			m.statusLine = fmt.Sprintf("error: %v", msg.err)
 		} else {
-			m.statusLine = fmt.Sprintf("updated %s", time.Now().Format("15:04:05"))
+			m.statusLine = fmt.Sprintf("updated %s (every %s)", time.Now().Format("15:04:05"), interval)
 		}
 	case metricsMsg:
 		m.metrics = monitor.UpdateHistory(m.metrics, msg.metrics)
@@ -172,8 +178,8 @@ func (m Model) onTabSelected() tea.Cmd {
 	return runCommandCmd(m.tabs[m.active])
 }
 
-func tick() tea.Cmd {
-	return tea.Tick(refreshInterval, func(t time.Time) tea.Msg { return tickMsg(t) })
+func tick(d time.Duration) tea.Cmd {
+	return tea.Tick(d, func(t time.Time) tea.Msg { return tickMsg(t) })
 }
 
 func spinnerTick() tea.Cmd {
@@ -207,7 +213,7 @@ func runCommandCmd(t config.Tab) tea.Cmd {
 	}
 }
 
-// Rendering helpers
+// Rendering helpers (unchanged)
 
 func (m Model) renderTabs(tabs []config.Tab, active, width int) string {
 	if width <= 0 {