Release v0.2.0 - Major improvements

New Features:
- Real-time CPU and memory statistics with parallel fetching
- Container logs viewer with vim-style scrolling (j/k, g/G, PgUp/PgDn)
- Instant startup - containers load immediately, stats populate in background
- Preserve expand/collapse state across refreshes

Performance:
- Parallel stats collection (10s → 2.4s for 5 containers)
- Non-blocking initial load for instant UI feedback
- Optimized refresh cycle

UI/UX:
- Aligned action names with Docker conventions (Down, Remove)
- Fixed column alignment and selection width issues
- Stable expand/collapse state during refreshes
- Better logs navigation with line counter

Code Quality:
- Refactored view mode system (Main/Menu/Logs)
- Improved stats parsing with custom structs
- Better error handling and resource cleanup
- Code cleanup (TrimPrefix optimization)

Author: ekinertac

README.md

@@ -104,17 +104,18 @@ NAME                                               STATUS
 ## Actions
 
 ### Project-level Actions
-- Restart All - Restart all containers in the project
-- Stop All - Stop all running containers (containers remain, ports held)
-- Stop & Remove All - Stop and remove all containers (frees ports, **keeps volumes**)
-- Start All - Start all stopped containers in the project
+- Restart All - Restart all containers (`docker compose restart`)
+- Stop All - Stop all running containers (`docker compose stop`)
+- Down - Stop and remove all containers (`docker compose down`, **keeps volumes**)
+- Start All - Start all stopped containers (`docker compose start`)
 
 ### Container-level Actions
-- Restart - Restart the container
-- Stop - Stop the container (keeps it, holds port)
-- Stop & Remove - Stop and remove the container (frees port, **keeps volumes**)
+- Restart - Restart the container (`docker restart`)
+- Stop - Stop the container (`docker stop`)
+- Remove - Remove the container (`docker rm`, **keeps volumes**)
+- Logs - View container logs (last 1000 lines, scrollable)
 
-**Note:** Removing containers is safe - your data in volumes is always preserved. To remove volumes, use `docker volume rm` or `docker compose down --volumes` from the terminal.
+**Note:** All operations preserve volumes by default. To remove volumes, use `docker volume rm` or `docker compose down --volumes` from the terminal.
 
 ## How It Works
 
@@ -200,8 +201,8 @@ fi
 ## Roadmap
 
 - [x] List mode for non-interactive use (`--list` / `-l`)
-- [ ] Real-time CPU/Memory statistics
-- [ ] Log viewer in split pane
+- [x] Real-time CPU/Memory statistics
+- [x] Log viewer with scrolling
 - [ ] Container inspect view
 - [ ] Exec into container
 - [ ] Filter/search functionality

docker/client.go

@@ -2,6 +2,9 @@ package docker
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
+	"io"
 	"strings"
 	"time"
 
@@ -46,42 +49,139 @@ func (c *Client) Close() error {
 }
 
 func (c *Client) ListContainers() ([]ContainerInfo, error) {
+	return c.ListContainersWithStats(true)
+}
+
+func (c *Client) ListContainersWithStats(includeStats bool) ([]ContainerInfo, error) {
 	// Only list running containers (equivalent to `docker ps` without -a)
 	containers, err := c.cli.ContainerList(c.ctx, container.ListOptions{All: false})
 	if err != nil {
 		return nil, err
 	}
 
-	var result []ContainerInfo
-	for _, ctr := range containers {
-		// Get container stats for CPU and memory
-		// Note: For now, we'll use placeholder values for stats
-		// In the future, we can implement real-time stats collection
-		var cpuPerc, memPerc float64 = 0.0, 0.0
-		var memUsage string = "N/A"
-
-		name := ctr.Names[0]
-		if strings.HasPrefix(name, "/") {
-			name = name[1:]
-		}
+	// Build initial result without stats
+	result := make([]ContainerInfo, len(containers))
+	type statsResult struct {
+		index    int
+		cpuPerc  float64
+		memPerc  float64
+		memUsage string
+	}
+	statsChan := make(chan statsResult, len(containers))
+
+	// Fetch stats in parallel for running containers
+	runningCount := 0
+	for i, ctr := range containers {
+		name := strings.TrimPrefix(ctr.Names[0], "/")
 
-		result = append(result, ContainerInfo{
+		result[i] = ContainerInfo{
 			ID:        ctr.ID[:12],
 			Name:      name,
 			Image:     ctr.Image,
 			State:     ctr.State,
 			Status:    ctr.Status,
-			CPUPerc:   cpuPerc,
-			MemPerc:   memPerc,
-			MemUsage:  memUsage,
+			CPUPerc:   0.0,
+			MemPerc:   0.0,
+			MemUsage:  "N/A",
 			CreatedAt: time.Unix(ctr.Created, 0),
 			Labels:    ctr.Labels,
-		})
+		}
+
+		if ctr.State == "running" && includeStats {
+			runningCount++
+			go func(idx int, containerID string) {
+				cpu, mem, usage := c.getContainerStats(containerID)
+				statsChan <- statsResult{
+					index:    idx,
+					cpuPerc:  cpu,
+					memPerc:  mem,
+					memUsage: usage,
+				}
+			}(i, ctr.ID)
+		}
+	}
+
+	// Collect stats results (only if requested)
+	if includeStats {
+		for i := 0; i < runningCount; i++ {
+			stats := <-statsChan
+			result[stats.index].CPUPerc = stats.cpuPerc
+			result[stats.index].MemPerc = stats.memPerc
+			result[stats.index].MemUsage = stats.memUsage
+		}
 	}
 
 	return result, nil
 }
 
+// Stats structures for parsing Docker stats JSON
+type statsResponse struct {
+	CPUStats struct {
+		CPUUsage struct {
+			TotalUsage uint64 `json:"total_usage"`
+		} `json:"cpu_usage"`
+		SystemUsage uint64 `json:"system_cpu_usage"`
+		OnlineCPUs  uint32 `json:"online_cpus"`
+	} `json:"cpu_stats"`
+	PreCPUStats struct {
+		CPUUsage struct {
+			TotalUsage uint64 `json:"total_usage"`
+		} `json:"cpu_usage"`
+		SystemUsage uint64 `json:"system_cpu_usage"`
+	} `json:"precpu_stats"`
+	MemoryStats struct {
+		Usage uint64 `json:"usage"`
+		Limit uint64 `json:"limit"`
+	} `json:"memory_stats"`
+}
+
+func (c *Client) getContainerStats(containerID string) (cpuPerc, memPerc float64, memUsage string) {
+	// Get a single stats snapshot (stream=false)
+	stats, err := c.cli.ContainerStats(c.ctx, containerID, false)
+	if err != nil {
+		return 0.0, 0.0, "N/A"
+	}
+	defer stats.Body.Close()
+
+	// Decode the stats
+	var v statsResponse
+	if err := json.NewDecoder(stats.Body).Decode(&v); err != nil && err != io.EOF {
+		return 0.0, 0.0, "N/A"
+	}
+
+	// Calculate CPU percentage
+	cpuDelta := float64(v.CPUStats.CPUUsage.TotalUsage - v.PreCPUStats.CPUUsage.TotalUsage)
+	systemDelta := float64(v.CPUStats.SystemUsage - v.PreCPUStats.SystemUsage)
+	onlineCPUs := float64(v.CPUStats.OnlineCPUs)
+
+	if systemDelta > 0.0 && cpuDelta > 0.0 {
+		cpuPerc = (cpuDelta / systemDelta) * onlineCPUs * 100.0
+	}
+
+	// Calculate memory percentage
+	if v.MemoryStats.Limit > 0 {
+		memPerc = (float64(v.MemoryStats.Usage) / float64(v.MemoryStats.Limit)) * 100.0
+	}
+
+	// Format memory usage
+	memUsage = formatBytes(v.MemoryStats.Usage) + " / " + formatBytes(v.MemoryStats.Limit)
+
+	return cpuPerc, memPerc, memUsage
+}
+
+func formatBytes(bytes uint64) string {
+	const unit = 1024
+	if bytes < unit {
+		return "0 B"
+	}
+	div, exp := uint64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %ciB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
+
 func (c *Client) RestartContainer(containerID string) error {
 	timeout := 10
 	return c.cli.ContainerRestart(c.ctx, containerID, container.StopOptions{Timeout: &timeout})
@@ -103,3 +203,22 @@ func (c *Client) RemoveContainer(containerID string) error {
 	})
 }
 
+func (c *Client) GetContainerLogs(containerID string, tail int) (string, error) {
+	options := container.LogsOptions{
+		ShowStdout: true,
+		ShowStderr: true,
+		Tail:       fmt.Sprintf("%d", tail),
+	}
+
+	logs, err := c.cli.ContainerLogs(c.ctx, containerID, options)
+	if err != nil {
+		return "", err
+	}
+	defer logs.Close()
+
+	// Read all logs
+	buf := make([]byte, 1024*1024) // 1MB buffer
+	n, _ := logs.Read(buf)
+
+	return string(buf[:n]), nil
+}

main.go

@@ -21,7 +21,7 @@ func main() {
 
 	// Version flag
 	if *version {
-		fmt.Println("dtop v0.1.0")
+		fmt.Println("dtop v0.2.0")
 		fmt.Println("Docker container monitor - https://github.com/ekinertac/dtop")
 		return
 	}

ui/logs.go

@@ -0,0 +1,56 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (m Model) renderLogs() string {
+	var b strings.Builder
+
+	// Title
+	title := fmt.Sprintf("dtop - Logs: %s", m.logsContainer)
+	b.WriteString(titleStyle.Render(title))
+	b.WriteString("\n\n")
+
+	// Split logs into lines
+	lines := strings.Split(m.logsContent, "\n")
+	
+	// Calculate visible height
+	visibleHeight := m.height - 4 // Title + blank + footer + blank
+
+	// Clamp scroll position
+	maxScroll := len(lines) - visibleHeight
+	if maxScroll < 0 {
+		maxScroll = 0
+	}
+	if m.logsScroll > maxScroll {
+		m.logsScroll = maxScroll
+	}
+
+	// Render visible lines
+	end := m.logsScroll + visibleHeight
+	if end > len(lines) {
+		end = len(lines)
+	}
+
+	for i := m.logsScroll; i < end; i++ {
+		b.WriteString(lines[i])
+		b.WriteString("\n")
+	}
+
+	// Fill remaining space
+	renderedLines := end - m.logsScroll
+	for i := renderedLines; i < visibleHeight; i++ {
+		b.WriteString("\n")
+	}
+
+	// Footer with scroll indicator
+	footer := fmt.Sprintf("Lines %d-%d of %d", m.logsScroll+1, end, len(lines))
+	b.WriteString(helpStyle.Render(footer))
+	b.WriteString("  ")
+	b.WriteString(helpStyle.Render("↑↓/PgUp/PgDn/g/G:scroll  q/esc:back"))
+
+	return b.String()
+}
+