21461163438

Committed 29 Jan 2026 12:25AM UTC coverage: 79.94% (+1.4%) from 78.528%

Build # 21461163438

Build Type

Pull #36

github

Committed by

melonamin

Commit Message

Improve watch-only dashboard UX

Pull Request Pull Request #36: feat(web): interactive plan creation from web dashboard

Coverage Stats

808 of 932 new or added lines in 11 files covered. (86.7%)

334 existing lines in 3 files now uncovered.

4531 of 5668 relevant lines covered (79.94%)

54.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.03

/pkg/web/server.go

package web

import (
        "context"
        "embed"
        "encoding/json"
        "errors"
        "fmt"
        "html/template"
        "io/fs"
        "log"
        "net/http"
        "path/filepath"
        "sort"
        "strings"
        "sync"
        "time"
)

//go:embed templates static
var embeddedFS embed.FS

// ServerConfig holds configuration for the web server.
type ServerConfig struct {
        Port          int    // port to listen on
        PlanName      string // plan name to display in dashboard
        Branch        string // git branch name
        PlanFile      string // path to plan file for /api/plan endpoint
        WatchExplicit bool   // true when watch dirs were explicitly configured
}

// Server provides HTTP server for the real-time dashboard.
type Server struct {
        cfg     ServerConfig
        session *Session        // used for single-session mode (direct execution)
        sm      *SessionManager // used for multi-session mode (dashboard)
        srv     *http.Server
        tmpl    *template.Template

        // plan caching - set after first successful load (single-session mode)
        planMu    sync.Mutex
        planCache *Plan

        // planRunner for web-initiated plan creation (optional)
        planRunner *PlanRunner
}

// NewServer creates a new web server for single-session mode (direct execution).
// returns an error if the embedded template fails to parse.
func NewServer(cfg ServerConfig, session *Session) (*Server, error) {
        tmpl, err := template.ParseFS(embeddedFS, "templates/base.html")
        if err != nil {
                return nil, fmt.Errorf("parse template: %w", err)
        }

        return &Server{
                cfg:     cfg,
                session: session,
                tmpl:    tmpl,
        }, nil
}

// NewServerWithSessions creates a new web server for multi-session mode (dashboard).
// returns an error if the embedded template fails to parse.
func NewServerWithSessions(cfg ServerConfig, sm *SessionManager) (*Server, error) {
        tmpl, err := template.ParseFS(embeddedFS, "templates/base.html")
        if err != nil {
                return nil, fmt.Errorf("parse template: %w", err)
        }

        return &Server{
                cfg:  cfg,
                sm:   sm,
                tmpl: tmpl,
        }, nil
}

// Start begins listening for HTTP requests.
// blocks until the server is stopped or an error occurs.
func (s *Server) Start(ctx context.Context) error {
        mux := http.NewServeMux()

        // register routes
        mux.HandleFunc("/", s.handleIndex)
        mux.HandleFunc("/events", s.handleEvents)
        mux.HandleFunc("/api/plan", s.handlePlanDispatch)
        mux.HandleFunc("/api/plan/resume", s.handleResumePlan)
        mux.HandleFunc("/api/resumable", s.handleResumable)
        mux.HandleFunc("/api/sessions", s.handleSessions)
        mux.HandleFunc("/api/sessions/", s.handleSessionsSubpath)
        mux.HandleFunc("/api/answer", s.handleAnswer)
        mux.HandleFunc("/api/recent-dirs", s.handleRecentDirs)

        // static files
        staticFS, err := fs.Sub(embeddedFS, "static")
        if err != nil {
                return fmt.Errorf("static filesystem: %w", err)
        }
        mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))))

        s.srv = &http.Server{
                Addr:              fmt.Sprintf("127.0.0.1:%d", s.cfg.Port),
                Handler:           mux,
                ReadHeaderTimeout: 10 * time.Second,
        }

        // start shutdown listener
        go func() {
                <-ctx.Done()
                shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
                defer cancel()
                _ = s.srv.Shutdown(shutdownCtx)
        }()

        err = s.srv.ListenAndServe()
        if errors.Is(err, http.ErrServerClosed) {
                return nil
        }
        return fmt.Errorf("http server: %w", err)
}

// Stop gracefully shuts down the server.
func (s *Server) Stop() error {
        if s.srv == nil {
                return nil
        }
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()
        if err := s.srv.Shutdown(ctx); err != nil {
                return fmt.Errorf("shutdown server: %w", err)
        }
        return nil
}

// Session returns the server's session (for single-session mode).
func (s *Server) Session() *Session {
        return s.session
}

// SetPlanRunner sets the plan runner for web-initiated plan creation.
func (s *Server) SetPlanRunner(runner *PlanRunner) {
        s.planRunner = runner
}

// handlePlanDispatch routes /api/plan requests based on method.
// GET requests go to handlePlan, POST requests go to handleStartPlan.
func (s *Server) handlePlanDispatch(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
                s.handlePlan(w, r)
        case http.MethodPost:
                s.handleStartPlan(w, r)
        default:
                w.Header().Set("Allow", "GET, POST")
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
        }
}

// handleSessionsSubpath routes /api/sessions/{id}/... requests.
func (s *Server) handleSessionsSubpath(w http.ResponseWriter, r *http.Request) {
        // extract session ID and action from path
        path := strings.TrimPrefix(r.URL.Path, "/api/sessions/")
        parts := strings.Split(path, "/")

        if len(parts) < 1 || parts[0] == "" {
                http.NotFound(w, r)
                return
        }

        sessionID := parts[0]

        if len(parts) == 2 && parts[1] == "cancel" {
                s.handleCancelSession(w, r, sessionID)
                return
        }

        http.NotFound(w, r)
}

// templateData holds data for the dashboard template.
type templateData struct {
        PlanName string
        Branch   string
}

// handleIndex serves the main dashboard page.
func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/" {
                http.NotFound(w, r)
                return
        }

        w.Header().Set("Content-Type", "text/html; charset=utf-8")

        data := templateData{
                PlanName: s.cfg.PlanName,
                Branch:   s.cfg.Branch,
        }

        if err := s.tmpl.Execute(w, data); err != nil {
                http.Error(w, "template execution error", http.StatusInternalServerError)
                return
        }
}

// handlePlan serves the parsed plan as JSON.
// in single-session mode, uses the server's configured plan file with caching.
// in multi-session mode, accepts ?session=<id> to load plan from session metadata.
func (s *Server) handlePlan(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
                w.Header().Set("Allow", http.MethodGet)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        sessionID := r.URL.Query().Get("session")

        // multi-session mode with session ID
        if s.sm != nil && sessionID != "" {
                s.handleSessionPlan(w, sessionID)
                return
        }

        // single-session mode - use cached server plan
        if s.cfg.PlanFile == "" {
                http.Error(w, "no plan file configured", http.StatusNotFound)
                return
        }

        plan, err := s.loadPlan()
        if err != nil {
                log.Printf("[WARN] failed to load plan file %s: %v", s.cfg.PlanFile, err)
                http.Error(w, "unable to load plan", http.StatusInternalServerError)
                return
        }

        data, err := plan.JSON()
        if err != nil {
                log.Printf("[WARN] failed to encode plan: %v", err)
                http.Error(w, "unable to encode plan", http.StatusInternalServerError)
                return
        }

        w.Header().Set("Content-Type", "application/json")
        _, _ = w.Write(data)
}

// handleSessionPlan handles plan requests for a specific session in multi-session mode.
func (s *Server) handleSessionPlan(w http.ResponseWriter, sessionID string) {
        session := s.sm.Get(sessionID)
        if session == nil {
                http.Error(w, "session not found: "+sessionID, http.StatusNotFound)
                return
        }

        meta := session.GetMetadata()
        if meta.PlanPath == "" {
                http.Error(w, "no plan file for session", http.StatusNotFound)
                return
        }

        // resolve plan path: absolute paths used as-is, relative paths resolved from session directory
        var planPath string
        if filepath.IsAbs(meta.PlanPath) {
                planPath = meta.PlanPath
        } else {
                sessionDir := filepath.Dir(session.Path)
                planPath = filepath.Join(sessionDir, meta.PlanPath)
        }

        plan, err := loadPlanWithFallback(planPath)
        if err != nil {
                log.Printf("[WARN] failed to load plan file %s: %v", meta.PlanPath, err)
                http.Error(w, "unable to load plan", http.StatusInternalServerError)
                return
        }

        data, err := plan.JSON()
        if err != nil {
                log.Printf("[WARN] failed to encode plan: %v", err)
                http.Error(w, "unable to encode plan", http.StatusInternalServerError)
                return
        }

        w.Header().Set("Content-Type", "application/json")
        _, _ = w.Write(data)
}

// loadPlan returns a cached plan or loads it from disk (with completed/ fallback).
func (s *Server) loadPlan() (*Plan, error) {
        s.planMu.Lock()
        defer s.planMu.Unlock()

        if s.planCache != nil {
                return s.planCache, nil
        }

        plan, err := loadPlanWithFallback(s.cfg.PlanFile)
        if err != nil {
                return nil, err
        }

        s.planCache = plan
        return plan, nil
}

// loadPlanWithFallback loads a plan from disk with completed/ directory fallback.
// does not cache - each call reads from disk.
func loadPlanWithFallback(path string) (*Plan, error) {
        plan, err := ParsePlanFile(path)
        if err != nil && errors.Is(err, fs.ErrNotExist) {
                completedPath := filepath.Join(filepath.Dir(path), "completed", filepath.Base(path))
                plan, err = ParsePlanFile(completedPath)
        }
        return plan, err
}

// handleEvents serves the SSE stream.
// in multi-session mode, accepts ?session=<id> query parameter.
func (s *Server) handleEvents(w http.ResponseWriter, r *http.Request) {
        sessionID := r.URL.Query().Get("session")
        log.Printf("[SSE] connection request: session=%s", sessionID)

        // get session for SSE handling
        session, err := s.getSession(r)
        if err != nil {
                log.Printf("[SSE] session not found: %s - %v", sessionID, err)
                http.Error(w, err.Error(), http.StatusNotFound)
                return
        }

        // delegate to go-sse Server which handles:
        // - SSE protocol (headers, event formatting)
        // - Connection management
        // - History replay via FiniteReplayer
        // - Graceful disconnection
        session.SSE.ServeHTTP(w, r)
        log.Printf("[SSE] connection closed: session=%s", sessionID)
}

// getSession returns the session for the request.
// in single-session mode, returns the server's session.
// in multi-session mode, looks up the session by ID from query parameter.
func (s *Server) getSession(r *http.Request) (*Session, error) {
        sessionID := r.URL.Query().Get("session")

        // single-session mode (no session manager)
        if s.sm == nil {
                return s.getSingleSession(sessionID)
        }

        if sessionID == "" {
                return nil, errors.New("no session specified")
        }

        // multi-session mode - look up session
        session := s.sm.Get(sessionID)
        if session == nil {
                log.Printf("[SSE] session lookup failed: %s (not in manager)", sessionID)
                return nil, fmt.Errorf("session not found: %s", sessionID)
        }

        return session, nil
}

func (s *Server) getSingleSession(sessionID string) (*Session, error) {
        if sessionID == "" {
                if s.session == nil {
                        return nil, errors.New("no session specified")
                }
                return s.session, nil
        }
        if s.planRunner != nil {
                if planSession := s.planRunner.GetSession(sessionID); planSession != nil {
                        return planSession, nil
                }
        }
        if s.session != nil && s.session.ID == sessionID {
                return s.session, nil
        }
        return nil, fmt.Errorf("session not found: %s", sessionID)
}

// SessionInfo represents session data for the API response.
type SessionInfo struct {
        ID    string       `json:"id"`
        State SessionState `json:"state"`
        // dir is the short display name for the project (last path segment of session directory).
        Dir string `json:"dir"`
        // DirPath is the full filesystem path to the session directory (used for grouping and copy-to-clipboard).
        DirPath      string    `json:"dirPath,omitempty"`
        ProgressPath string    `json:"progressPath,omitempty"`
        PlanPath     string    `json:"planPath,omitempty"`
        Branch       string    `json:"branch,omitempty"`
        Mode         string    `json:"mode,omitempty"`
        StartTime    time.Time `json:"startTime"`
        LastModified time.Time `json:"lastModified"`
}

// handleSessions returns a list of all discovered sessions.
func (s *Server) handleSessions(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
                w.Header().Set("Allow", http.MethodGet)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        // single-session mode - return empty list
        if s.sm == nil {
                w.Header().Set("Content-Type", "application/json")
                _, _ = w.Write([]byte("[]"))
                return
        }

        sessions := s.sm.All()

        // sort by last modified (most recent first)
        sort.Slice(sessions, func(i, j int) bool {
                return sessions[i].GetLastModified().After(sessions[j].GetLastModified())
        })

        // convert to API response format
        infos := make([]SessionInfo, 0, len(sessions))
        for _, session := range sessions {
                meta := session.GetMetadata()
                dirPath := extractDirPath(session.Path)
                infos = append(infos, SessionInfo{
                        ID:           session.ID,
                        State:        session.GetState(),
                        Dir:          extractProjectDir(session.Path),
                        DirPath:      dirPath,
                        ProgressPath: session.Path,
                        PlanPath:     meta.PlanPath,
                        Branch:       meta.Branch,
                        Mode:         meta.Mode,
                        StartTime:    meta.StartTime,
                        LastModified: session.GetLastModified(),
                })
        }

        data, err := json.Marshal(infos)
        if err != nil {
                log.Printf("[WARN] failed to encode sessions: %v", err)
                http.Error(w, "unable to encode sessions", http.StatusInternalServerError)
                return
        }

        w.Header().Set("Content-Type", "application/json")
        _, _ = w.Write(data)
}

// extractProjectDir extracts project directory name from session path.
// handles edge cases where path has no meaningful parent directory.
func extractProjectDir(path string) string {
        dir := filepath.Dir(path)
        name := filepath.Base(dir)

        // handle edge cases: root paths, current directory, relative paths
        if name == "" || name == "." || name == ".." || name == string(filepath.Separator) {
                return "Unknown"
        }
        return name
}

// extractDirPath returns the absolute directory path for a session path.
// returns empty string for relative paths like "." or "..".
func extractDirPath(path string) string {
        if absPath, err := filepath.Abs(path); err == nil {
                return filepath.Dir(absPath)
        }
        dirPath := filepath.Dir(path)
        if dirPath == "." || dirPath == ".." {
                return ""
        }
        return dirPath
}

// StartPlanRequest is the request body for POST /api/plan.
type StartPlanRequest struct {
        Dir         string `json:"dir"`
        Description string `json:"description"`
}

// StartPlanResponse is the response body for POST /api/plan.
type StartPlanResponse struct {
        SessionID string `json:"session_id"`
        Success   bool   `json:"success"`
}

// handleStartPlan handles POST /api/plan to start a new plan creation.
func (s *Server) handleStartPlan(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
                w.Header().Set("Allow", http.MethodPost)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        if s.planRunner == nil {
                http.Error(w, "plan creation not available", http.StatusServiceUnavailable)
                return
        }

        var req StartPlanRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
                http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
                return
        }

        if req.Dir == "" {
                http.Error(w, "directory required", http.StatusBadRequest)
                return
        }

        if req.Description == "" {
                http.Error(w, "description required", http.StatusBadRequest)
                return
        }

        session, err := s.planRunner.StartPlan(req.Dir, req.Description)
        if err != nil {
                log.Printf("[ERROR] failed to start plan: %v", err)
                http.Error(w, "failed to start plan: "+err.Error(), http.StatusBadRequest)
                return
        }

        resp := StartPlanResponse{
                SessionID: session.ID,
                Success:   true,
        }

        w.Header().Set("Content-Type", "application/json")
        if err := json.NewEncoder(w).Encode(resp); err != nil {
                log.Printf("[WARN] failed to encode response: %v", err)
        }
}

// AnswerRequest is the request body for POST /api/answer.
type AnswerRequest struct {
        SessionID  string `json:"session_id"`
        QuestionID string `json:"question_id"`
        Answer     string `json:"answer"`
}

// AnswerResponse is the response body for POST /api/answer.
type AnswerResponse struct {
        Success bool `json:"success"`
}

// handleAnswer handles POST /api/answer to submit an answer to a pending question.
func (s *Server) handleAnswer(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
                w.Header().Set("Allow", http.MethodPost)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        if s.planRunner == nil {
                http.Error(w, "plan creation not available", http.StatusServiceUnavailable)
                return
        }

        var req AnswerRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
                http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
                return
        }

        if req.SessionID == "" || req.QuestionID == "" || req.Answer == "" {
                http.Error(w, "session_id, question_id, and answer required", http.StatusBadRequest)
                return
        }

        session := s.planRunner.GetSession(req.SessionID)
        if session == nil {
                http.Error(w, "session not found: "+req.SessionID, http.StatusNotFound)
                return
        }

        collector := session.GetInputCollector()
        if collector == nil {
                http.Error(w, "no input collector for session", http.StatusBadRequest)
                return
        }

        if err := collector.SubmitAnswer(req.QuestionID, req.Answer); err != nil {
                http.Error(w, "failed to submit answer: "+err.Error(), http.StatusBadRequest)
                return
        }

        resp := AnswerResponse{Success: true}
        w.Header().Set("Content-Type", "application/json")
        if err := json.NewEncoder(w).Encode(resp); err != nil {
                log.Printf("[WARN] failed to encode response: %v", err)
        }
}

// handleCancelSession handles POST /api/sessions/{id}/cancel to cancel a plan creation.
func (s *Server) handleCancelSession(w http.ResponseWriter, r *http.Request, sessionID string) {
        if r.Method != http.MethodPost {
                w.Header().Set("Allow", http.MethodPost)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        if s.planRunner == nil {
                http.Error(w, "plan creation not available", http.StatusServiceUnavailable)
                return
        }

        if err := s.planRunner.CancelPlan(sessionID); err != nil {
                http.Error(w, "failed to cancel plan: "+err.Error(), http.StatusNotFound)
                return
        }

        w.Header().Set("Content-Type", "application/json")
        _, _ = w.Write([]byte(`{"success":true}`))
}

// RecentDirsResponse is the response body for GET /api/recent-dirs.
type RecentDirsResponse struct {
        Dirs   []string `json:"dirs"`
        Locked bool     `json:"locked,omitempty"`
}

func (s *Server) isWatchOnlyMode() bool {
        return s.cfg.PlanName == "(watch mode)" && s.cfg.PlanFile == "" && s.sm != nil
}

// handleRecentDirs handles GET /api/recent-dirs.
// Returns directories from config.ProjectDirs and from existing sessions.
func (s *Server) handleRecentDirs(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
                w.Header().Set("Allow", http.MethodGet)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        if s.isWatchOnlyMode() && !s.cfg.WatchExplicit && s.planRunner != nil && s.planRunner.config != nil {
                dirs := uniqueDirs(s.planRunner.config.WatchDirs)
                resp := RecentDirsResponse{Dirs: dirs, Locked: len(dirs) == 1}
                w.Header().Set("Content-Type", "application/json")
                if err := json.NewEncoder(w).Encode(resp); err != nil {
                        log.Printf("[WARN] failed to encode response: %v", err)
                }
                return
        }

        // use a map to deduplicate directories
        seen := make(map[string]bool)
        var dirs []string

        // add directories from config (these come first, in order)
        if s.planRunner != nil && s.planRunner.config != nil {
                for _, dir := range s.planRunner.config.ProjectDirs {
                        if !seen[dir] {
                                seen[dir] = true
                                dirs = append(dirs, dir)
                        }
                }
        }

        // add directories from existing sessions
        if s.sm != nil {
                for _, session := range s.sm.All() {
                        // extract directory from progress file path
                        dir := filepath.Dir(session.Path)
                        if dir != "" && !seen[dir] {
                                seen[dir] = true
                                dirs = append(dirs, dir)
                        }
                }
        }

        if dirs == nil {
                dirs = []string{}
        }

        resp := RecentDirsResponse{Dirs: dirs}
        w.Header().Set("Content-Type", "application/json")
        if err := json.NewEncoder(w).Encode(resp); err != nil {
                log.Printf("[WARN] failed to encode response: %v", err)
        }
}

// ResumableResponse is the response body for GET /api/resumable.
type ResumableResponse struct {
        Sessions []ResumableSession `json:"sessions"`
}

// handleResumable handles GET /api/resumable to list resumable plan sessions.
func (s *Server) handleResumable(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
                w.Header().Set("Allow", http.MethodGet)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        if s.planRunner == nil {
                http.Error(w, "plan creation not available", http.StatusServiceUnavailable)
                return
        }

        sessions, err := s.planRunner.GetResumableSessions()
        if err != nil {
                log.Printf("[ERROR] failed to get resumable sessions: %v", err)
                http.Error(w, "failed to get resumable sessions: "+err.Error(), http.StatusInternalServerError)
                return
        }

        if sessions == nil {
                sessions = []ResumableSession{}
        }

        resp := ResumableResponse{Sessions: sessions}
        w.Header().Set("Content-Type", "application/json")
        if err := json.NewEncoder(w).Encode(resp); err != nil {
                log.Printf("[WARN] failed to encode response: %v", err)
        }
}

// ResumePlanRequest is the request body for POST /api/plan/resume.
type ResumePlanRequest struct {
        ProgressPath string `json:"progress_path"`
}

// ResumePlanResponse is the response body for POST /api/plan/resume.
type ResumePlanResponse struct {
        SessionID string `json:"session_id"`
        Success   bool   `json:"success"`
}

// handleResumePlan handles POST /api/plan/resume to resume an interrupted plan.
func (s *Server) handleResumePlan(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
                w.Header().Set("Allow", http.MethodPost)
                http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
                return
        }

        if s.planRunner == nil {
                http.Error(w, "plan creation not available", http.StatusServiceUnavailable)
                return
        }

        var req ResumePlanRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
                http.Error(w, "invalid request body: "+err.Error(), http.StatusBadRequest)
                return
        }

        if req.ProgressPath == "" {
                http.Error(w, "progress_path required", http.StatusBadRequest)
                return
        }

        session, err := s.planRunner.ResumePlan(req.ProgressPath)
        if err != nil {
                log.Printf("[ERROR] failed to resume plan: %v", err)
                http.Error(w, "failed to resume plan: "+err.Error(), http.StatusBadRequest)
                return
        }

        resp := ResumePlanResponse{
                SessionID: session.ID,
                Success:   true,
        }

        w.Header().Set("Content-Type", "application/json")
        if err := json.NewEncoder(w).Encode(resp); err != nil {
                log.Printf("[WARN] failed to encode response: %v", err)
        }
}

umputun / ralphex / 21461163438

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous