25115074240

Committed 29 Apr 2026 02:30PM UTC coverage: 82.853% (+0.4%) from 82.426%

Build # 25115074240

Build Type

Pull #309

github

Committed by

bronislav

Commit Message

fix: address code review findings

- document {{TASK_HEADER_PATTERNS}} in CLAUDE.md and README.md variable lists
- update CLAUDE.md 'Plan format' key pattern to reflect configurable headers
  and the removal of the package-level taskHeaderPattern regex
- rename TestDefaultPatternsMatchLegacyRegex and rewrite its comment to be
  honest: the template-driven compiler is stricter than the legacy regex
  about whitespace, so the test only covers canonical inputs
- exclude gosec G704 (SSRF taint) in *_test.go files; false positive on
  httptest server URLs in pkg/web/watcher_test.go

Pull Request Pull Request #309: feat: configurable task header patterns

Coverage Stats

367 of 399 new or added lines in 13 files covered. (91.98%)

1 existing line in 1 file now uncovered.

7011 of 8462 relevant lines covered (82.85%)

227.55 hits per line

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

92.28

/pkg/progress/progress.go

// Package progress provides timestamped logging to file and stdout with color support.
package progress

import (
        "fmt"
        "io"
        "os"
        "path/filepath"
        "regexp"
        "strconv"
        "strings"
        "time"
        "unicode"

        "github.com/fatih/color"
        "golang.org/x/term"

        "github.com/umputun/ralphex/pkg/config"
        "github.com/umputun/ralphex/pkg/status"
)

// multiDashRegex collapses multiple consecutive dashes into one.
var multiDashRegex = regexp.MustCompile(`-{2,}`)

// Colors holds all color configuration for output formatting.
// use NewColors to create from config.ColorConfig.
type Colors struct {
        task       *color.Color
        review     *color.Color
        codex      *color.Color
        claudeEval *color.Color
        warn       *color.Color
        err        *color.Color
        signal     *color.Color
        timestamp  *color.Color
        info       *color.Color
        phases     map[status.Phase]*color.Color
}

// NewColors creates Colors from config.ColorConfig.
// all colors must be provided - use config with embedded defaults fallback.
// panics if any color value is invalid (configuration error).
func NewColors(cfg config.ColorConfig) *Colors {
        c := &Colors{phases: make(map[status.Phase]*color.Color)}
        c.task = parseColorOrPanic(cfg.Task, "task")
        c.review = parseColorOrPanic(cfg.Review, "review")
        c.codex = parseColorOrPanic(cfg.Codex, "codex")
        c.claudeEval = parseColorOrPanic(cfg.ClaudeEval, "claude_eval")
        c.warn = parseColorOrPanic(cfg.Warn, "warn")
        c.err = parseColorOrPanic(cfg.Error, "error")
        c.signal = parseColorOrPanic(cfg.Signal, "signal")
        c.timestamp = parseColorOrPanic(cfg.Timestamp, "timestamp")
        c.info = parseColorOrPanic(cfg.Info, "info")

        c.phases[status.PhaseTask] = c.task
        c.phases[status.PhaseReview] = c.review
        c.phases[status.PhaseCodex] = c.codex
        c.phases[status.PhaseClaudeEval] = c.claudeEval
        c.phases[status.PhasePlan] = c.task     // plan phase uses task color (green)
        c.phases[status.PhaseFinalize] = c.task // finalize phase uses task color (green)

        return c
}

// parseColorOrPanic parses RGB string and returns color, panics on invalid input.
func parseColorOrPanic(s, name string) *color.Color {
        parseRGB := func(s string) []int {
                if s == "" {
                        return nil
                }
                parts := strings.Split(s, ",")
                if len(parts) != 3 {
                        return nil
                }

                // parse each component
                r, err := strconv.Atoi(strings.TrimSpace(parts[0]))
                if err != nil || r < 0 || r > 255 {
                        return nil
                }
                g, err := strconv.Atoi(strings.TrimSpace(parts[1]))
                if err != nil || g < 0 || g > 255 {
                        return nil
                }
                b, err := strconv.Atoi(strings.TrimSpace(parts[2]))
                if err != nil || b < 0 || b > 255 {
                        return nil
                }
                return []int{r, g, b}
        }

        rgb := parseRGB(s)
        if rgb == nil {
                panic(fmt.Sprintf("invalid color_%s value: %q", name, s))
        }
        return color.RGB(rgb[0], rgb[1], rgb[2])
}

// Info returns the info color for informational messages.
func (c *Colors) Info() *color.Color { return c.info }

// ForPhase returns the color for the given execution phase.
func (c *Colors) ForPhase(p status.Phase) *color.Color {
        if clr, ok := c.phases[p]; ok {
                return clr
        }
        return c.task // fallback to task color for unknown/empty phase
}

// Timestamp returns the timestamp color.
func (c *Colors) Timestamp() *color.Color { return c.timestamp }

// Warn returns the warning color.
func (c *Colors) Warn() *color.Color { return c.warn }

// Error returns the error color.
func (c *Colors) Error() *color.Color { return c.err }

// Signal returns the signal color.
func (c *Colors) Signal() *color.Color { return c.signal }

// Logger writes timestamped output to both file and stdout.
type Logger struct {
        file      *os.File
        stdout    io.Writer
        startTime time.Time
        holder    *status.PhaseHolder
        colors    *Colors
        runErr    error // set via SetFailed to record non-success outcome for the footer
}

// Config holds logger configuration.
type Config struct {
        PlanFile           string   // plan filename (used to derive progress filename)
        PlanDescription    string   // plan description for plan mode (used for filename)
        Mode               string   // execution mode: full, review, codex-only, plan
        Branch             string   // current git branch
        NoColor            bool     // disable color output (sets color.NoColor globally)
        TaskHeaderPatterns []string // task-header templates for this run; written into the header so multi-repo dashboards can parse watched sessions' plans with the correct templates
}

// NewLogger creates a logger writing to both a progress file and stdout.
// if the progress file already ends with a "Completed:" footer (successful run),
// it is truncated and a fresh header is written. if the file ended with a "Failed:"
// footer or has no footer (interrupted/failed run), the existing log is preserved
// and a restart separator is written so history carries across retries (issue #288).
// colors must be provided (created via NewColors from config).
// holder is the shared PhaseHolder for reading the current execution phase.
func NewLogger(cfg Config, colors *Colors, holder *status.PhaseHolder) (*Logger, error) {
        // set global color setting
        if cfg.NoColor {
                color.NoColor = true
        }

        progressPath := progressFilename(cfg.PlanFile, cfg.PlanDescription, cfg.Mode)

        // resolve to absolute path so Logger.Path() works from any CWD (e.g. after worktree chdir)
        if absPath, absErr := filepath.Abs(progressPath); absErr == nil {
                progressPath = absPath
        }

        // ensure progress files are tracked by creating parent dir
        if dir := filepath.Dir(progressPath); dir != "." {
                if err := os.MkdirAll(dir, 0o750); err != nil {
                        return nil, fmt.Errorf("create progress dir: %w", err)
                }
        }

        f, err := os.OpenFile(progressPath, os.O_APPEND|os.O_CREATE|os.O_RDWR, 0o600) //nolint:gosec // path derived from plan filename
        if err != nil {
                return nil, fmt.Errorf("open progress file: %w", err)
        }

        // acquire exclusive lock on progress file to signal active session.
        // the lock is held for the duration of execution and released on Close().
        // lock MUST be acquired before stat to avoid TOCTOU race:
        // without this ordering, a concurrent process could stat size==0, block on lock,
        // then write a full header instead of restart separator after another process already wrote content.
        if lockErr := lockFile(f); lockErr != nil {
                f.Close()
                return nil, fmt.Errorf("acquire file lock: %w", lockErr)
        }
        registerActiveLock(f.Name())

        cleanup := func() {
                _ = unlockFile(f)
                unregisterActiveLock(f.Name())
                f.Close()
        }

        // check if file already has content (restart case) — safe after lock acquisition
        fi, err := f.Stat()
        if err != nil {
                cleanup()
                return nil, fmt.Errorf("stat progress file: %w", err)
        }

        restart := fi.Size() > 0

        // if the file has a completion footer from a previous run, truncate and start fresh.
        // this prevents mixing unrelated content when the same plan filename is reused.
        // the file lock is held here, so path and fd refer to the same inode; path-based
        // truncation is safe. os.Truncate (path-based) is used instead of f.Truncate
        // (fd-based) because on Windows a fd opened with O_APPEND does not have the
        // FILE_WRITE_DATA permission required for fd-based truncation ("access is denied").
        if restart && isProgressCompleted(f, fi.Size()) {
                if tErr := os.Truncate(f.Name(), 0); tErr != nil {
                        cleanup()
                        return nil, fmt.Errorf("truncate completed progress file: %w", tErr)
                }
                restart = false
        }

        l := &Logger{
                file:      f,
                stdout:    os.Stdout,
                startTime: time.Now(),
                holder:    holder,
                colors:    colors,
        }

        if restart {
                // write restart separator (matches sectionRegex in web parser).
                // re-emit the current run's TaskHeaderPatterns so a dashboard reading
                // this file after the restart picks up the NEW patterns rather than
                // the possibly-stale or absent value from the original header. the
                // web parser skips TaskHeaderPatterns lines, so this does not show up
                // as content in the event stream.
                l.writeFile("\n\n--- restarted at %s ---\n", time.Now().Format("2006-01-02 15:04:05"))
                if patterns := sanitizePatterns(cfg.TaskHeaderPatterns); len(patterns) > 0 {
                        l.writeFile("TaskHeaderPatterns: %s\n", strings.Join(patterns, ","))
                }
                l.writeFile("\n")
        } else {
                l.writeHeader(cfg)
        }

        return l, nil
}

// writeHeader writes the initial progress log header for a new file.
func (l *Logger) writeHeader(cfg Config) {
        planStr := cfg.PlanFile
        if planStr == "" {
                planStr = "(no plan - review only)"
        }
        l.writeFile("# Ralphex Progress Log\n")
        l.writeFile("Plan: %s\n", planStr)
        l.writeFile("Branch: %s\n", cfg.Branch)
        l.writeFile("Mode: %s\n", cfg.Mode)
        l.writeFile("Started: %s\n", time.Now().Format("2006-01-02 15:04:05"))
        // record per-run task_header_patterns so a dashboard watching this progress
        // file from another process with different config can parse the plan the
        // same way the executor did. commas inside a template would break the
        // comma-separated parse on read, so each template is rejected if it
        // contains a comma — project templates never legitimately need one.
        if patterns := sanitizePatterns(cfg.TaskHeaderPatterns); len(patterns) > 0 {
                l.writeFile("TaskHeaderPatterns: %s\n", strings.Join(patterns, ","))
        }
        l.writeFile("%s\n\n", separatorLine)
}

// sanitizePatterns returns patterns with leading/trailing whitespace trimmed and
// entries containing commas or newlines dropped, since those would corrupt the
// comma-separated single-line header encoding.
func sanitizePatterns(patterns []string) []string {
        out := make([]string, 0, len(patterns))
        for _, p := range patterns {
                p = strings.TrimSpace(p)
                if p == "" {
                        continue
                }
                if strings.ContainsAny(p, ",\n\r") {
                        continue
                }
                out = append(out, p)
        }
        return out
}

// Path returns the progress file path.
func (l *Logger) Path() string {
        if l.file == nil {
                return ""
        }
        return l.file.Name()
}

// timestampFormat is the format for timestamps: YY-MM-DD HH:MM:SS
const timestampFormat = "06-01-02 15:04:05"

// separatorLine is the 60-dash separator used in the header and completion footer.
// isProgressCompleted relies on this exact value to detect completed files.
var separatorLine = strings.Repeat("-", 60)

// writeTimestamped writes a message to both file and stdout with timestamp and optional prefix.
func (l *Logger) writeTimestamped(prefix string, clr *color.Color, msg string) {
        timestamp := time.Now().Format(timestampFormat)
        l.writeFile("[%s] %s%s\n", timestamp, prefix, msg)

        tsStr := l.colors.Timestamp().Sprintf("[%s]", timestamp)
        coloredMsg := clr.Sprintf("%s%s", prefix, msg)
        l.writeStdout("%s %s\n", tsStr, coloredMsg)
}

// Print writes a timestamped message to both file and stdout.
func (l *Logger) Print(format string, args ...any) {
        l.writeTimestamped("", l.colors.ForPhase(l.holder.Get()), fmt.Sprintf(format, args...))
}

// PrintRaw writes without timestamp (for streaming output).
func (l *Logger) PrintRaw(format string, args ...any) {
        msg := fmt.Sprintf(format, args...)
        l.writeFile("%s", msg)
        l.writeStdout("%s", msg)
}

// PrintSection writes a section header without timestamp in yellow.
// format: "\n--- {label} ---\n"
func (l *Logger) PrintSection(section status.Section) {
        header := fmt.Sprintf("\n--- %s ---\n", section.Label)
        l.writeFile("%s", header)
        l.writeStdout("%s", l.colors.Warn().Sprint(header))
}

// getTerminalWidth returns terminal width, using COLUMNS env var or syscall.
// Defaults to 80 if detection fails. Returns content width (total - 22 for timestamp prefix
// and safety margin to prevent terminal-level mid-word wrapping).
func (l *Logger) getTerminalWidth() int {
        const (
                minWidth       = 40
                prefixReserved = 22 // 20 for "[YY-MM-DD HH:MM:SS] " + 2 safety margin for list indent
        )

        // try COLUMNS env var first
        if cols := os.Getenv("COLUMNS"); cols != "" {
                if w, err := strconv.Atoi(cols); err == nil && w > 0 {
                        contentWidth := w - prefixReserved
                        if contentWidth < minWidth {
                                return minWidth
                        }
                        return contentWidth
                }
        }

        // try terminal syscall
        if w, _, err := term.GetSize(int(os.Stdout.Fd())); err == nil && w > 0 {
                contentWidth := w - prefixReserved
                if contentWidth < minWidth {
                        return minWidth
                }
                return contentWidth
        }

        return 80 - prefixReserved // default 80 columns minus prefix
}

// wrapText wraps text to specified width, breaking on word boundaries.
// words longer than width are placed on their own line (terminal may wrap them).
// leading whitespace is preserved on the first line and subtracted from available width.
func (l *Logger) wrapText(text string, width int) string {
        if width <= 0 || len(text) <= width {
                return text
        }

        // preserve leading whitespace
        trimmed := strings.TrimLeft(text, " \t")
        indent := text[:len(text)-len(trimmed)]
        effectiveWidth := width - len(indent)
        if effectiveWidth <= 0 {
                return text
        }

        var result strings.Builder
        words := strings.Fields(trimmed)
        lineLen := 0
        currentWidth := effectiveWidth // first line uses reduced width for indent

        if indent != "" {
                result.WriteString(indent)
        }

        for i, word := range words {
                wordLen := len(word)

                if i == 0 {
                        result.WriteString(word)
                        lineLen = wordLen
                        continue
                }

                // check if word fits on current line
                if lineLen+1+wordLen <= currentWidth {
                        result.WriteString(" ")
                        result.WriteString(word)
                        lineLen += 1 + wordLen
                } else {
                        // continuation lines use full width (no indent)
                        result.WriteString("\n")
                        result.WriteString(word)
                        lineLen = wordLen
                        currentWidth = width
                }
        }

        return result.String()
}

// PrintAligned writes text with timestamp on each line, suppressing empty lines.
func (l *Logger) PrintAligned(text string) {
        if text == "" {
                return
        }

        // trim trailing newlines to avoid extra blank lines
        text = strings.TrimRight(text, "\n")
        if text == "" {
                return
        }

        phaseColor := l.colors.ForPhase(l.holder.Get())

        // wrap text to terminal width
        width := l.getTerminalWidth()

        // split into lines, apply list indent BEFORE wrapping (so indent is included in width calc),
        // then wrap each long line
        var lines []string
        for line := range strings.SplitSeq(text, "\n") {
                // apply list indent before wrapping so it's accounted for in width calculation
                formatted := l.formatListItem(line)
                if len(formatted) > width {
                        wrapped := l.wrapText(formatted, width)
                        for wrappedLine := range strings.SplitSeq(wrapped, "\n") {
                                lines = append(lines, wrappedLine)
                        }
                } else {
                        lines = append(lines, formatted)
                }
        }

        for _, line := range lines {
                if line == "" {
                        continue // skip empty lines
                }

                displayLine := line

                // timestamp each line
                timestamp := time.Now().Format(timestampFormat)
                tsPrefix := l.colors.Timestamp().Sprintf("[%s]", timestamp)
                l.writeFile("[%s] %s\n", timestamp, displayLine)

                // use red for signal lines
                lineColor := phaseColor

                // format signal lines nicely
                if sig := l.extractSignal(line); sig != "" {
                        displayLine = sig
                        lineColor = l.colors.Signal()
                }

                l.writeStdout("%s %s\n", tsPrefix, lineColor.Sprint(displayLine))
        }
}

// extractSignal extracts signal name from <<<RALPHEX:SIGNAL_NAME>>> format.
// returns empty string if no signal found.
func (l *Logger) extractSignal(line string) string {
        const prefix = "<<<RALPHEX:"
        const suffix = ">>>"

        start := strings.Index(line, prefix)
        if start == -1 {
                return ""
        }

        end := strings.Index(line[start:], suffix)
        if end == -1 {
                return ""
        }

        return line[start+len(prefix) : start+end]
}

// formatListItem adds 2-space indent for list items (numbered or bulleted).
// detects patterns like "1. ", "12. ", "- ", "* " at line start.
func (l *Logger) formatListItem(line string) string {
        trimmed := strings.TrimLeft(line, " \t")
        if trimmed == line { // no leading whitespace
                if l.isListItem(trimmed) {
                        return "  " + line
                }
        }
        return line
}

// isListItem returns true if line starts with a list marker.
func (l *Logger) isListItem(line string) bool {
        // check for "- " or "* " (bullet lists)
        if strings.HasPrefix(line, "- ") || strings.HasPrefix(line, "* ") {
                return true
        }
        // check for numbered lists like "1. ", "12. ", "123. "
        for i, r := range line {
                if r >= '0' && r <= '9' {
                        continue
                }
                if r == '.' && i > 0 && i < len(line)-1 && line[i+1] == ' ' {
                        return true
                }
                break
        }
        return false
}

// Error writes an error message in red.
func (l *Logger) Error(format string, args ...any) {
        l.writeTimestamped("ERROR: ", l.colors.Error(), fmt.Sprintf(format, args...))
}

// Warn writes a warning message in yellow.
func (l *Logger) Warn(format string, args ...any) {
        l.writeTimestamped("WARN: ", l.colors.Warn(), fmt.Sprintf(format, args...))
}

// LogQuestion logs a question and its options for plan creation mode.
// format: QUESTION: <question>\n OPTIONS: <opt1>, <opt2>, ...
func (l *Logger) LogQuestion(question string, options []string) {
        timestamp := time.Now().Format(timestampFormat)

        l.writeFile("[%s] QUESTION: %s\n", timestamp, question)
        l.writeFile("[%s] OPTIONS: %s\n", timestamp, strings.Join(options, ", "))

        tsStr := l.colors.Timestamp().Sprintf("[%s]", timestamp)
        questionStr := l.colors.Info().Sprintf("QUESTION: %s", question)
        optionsStr := l.colors.Info().Sprintf("OPTIONS: %s", strings.Join(options, ", "))
        l.writeStdout("%s %s\n", tsStr, questionStr)
        l.writeStdout("%s %s\n", tsStr, optionsStr)
}

// LogAnswer logs the user's answer for plan creation mode.
// format: ANSWER: <answer>
func (l *Logger) LogAnswer(answer string) {
        l.writeTimestamped("ANSWER: ", l.colors.Info(), answer)
}

// LogDraftReview logs the user's draft review action and optional feedback.
// format: DRAFT REVIEW: <action>
// if feedback is non-empty: FEEDBACK: <feedback>
func (l *Logger) LogDraftReview(action, feedback string) {
        timestamp := time.Now().Format(timestampFormat)

        l.writeFile("[%s] DRAFT REVIEW: %s\n", timestamp, action)

        tsStr := l.colors.Timestamp().Sprintf("[%s]", timestamp)
        actionStr := l.colors.Info().Sprintf("DRAFT REVIEW: %s", action)
        l.writeStdout("%s %s\n", tsStr, actionStr)

        if feedback != "" {
                l.writeFile("[%s] FEEDBACK: %s\n", timestamp, feedback)
                feedbackStr := l.colors.Info().Sprintf("FEEDBACK: %s", feedback)
                l.writeStdout("%s %s\n", tsStr, feedbackStr)
        }
}

// LogDiffStats writes git diff stats to the progress file (file-only, no stdout).
// format: [timestamp] DIFFSTATS: files=F additions=A deletions=D
func (l *Logger) LogDiffStats(files, additions, deletions int) {
        if l.file == nil || files <= 0 {
                return
        }
        timestamp := time.Now().Format(timestampFormat)
        l.writeFile("[%s] DIFFSTATS: files=%d additions=%d deletions=%d\n",
                timestamp, files, additions, deletions)
}

// Elapsed returns formatted elapsed time since start.
// for durations >= 1 hour, truncates to minutes (e.g. "1h23m"); otherwise to seconds (e.g. "5m30s").
func (l *Logger) Elapsed() string {
        d := time.Since(l.startTime)
        if d >= time.Hour {
                return strings.TrimSuffix(d.Truncate(time.Minute).String(), "0s")
        }
        return d.Truncate(time.Second).String()
}

// SetFailed marks the logger as failed with the given reason. On Close, a "Failed:"
// footer is written instead of "Completed:", so the restart path appends to the file
// (preserving history) rather than truncating. Safe to call multiple times; the most
// recent call wins (passing nil clears any previous failure state).
func (l *Logger) SetFailed(reason error) {
        l.runErr = reason
}

// Close writes footer, releases the file lock, and closes the progress file.
// Writes "Completed:" footer on success, or "Failed: ... - <reason>" if SetFailed
// was called with a non-nil error.
func (l *Logger) Close() error {
        if l.file == nil {
                return nil
        }

        l.writeFile("\n%s\n", separatorLine)
        ts := time.Now().Format("2006-01-02 15:04:05")
        if l.runErr == nil {
                l.writeFile("Completed: %s (%s)\n", ts, l.Elapsed())
        } else {
                reason := sanitizeFailureReason(l.runErr.Error())
                l.writeFile("Failed: %s (%s) - %s\n", ts, l.Elapsed(), reason)
        }

        // release file lock before closing
        _ = unlockFile(l.file)
        unregisterActiveLock(l.file.Name())

        if err := l.file.Close(); err != nil {
                return fmt.Errorf("close progress file: %w", err)
        }
        return nil
}

// maxFailureReasonRunes caps the failure reason written into the footer.
// Rune-based cap avoids splitting multibyte sequences at the boundary.
const maxFailureReasonRunes = 200

// sanitizeFailureReason prepares an error string for single-line footer output.
// Replaces Unicode control chars (unicode.IsControl, covers ASCII C0 + C1 ranges)
// and line/paragraph separators (U+2028, U+2029) with a single space, collapses
// consecutive whitespace via strings.Fields, and rune-aware truncates to
// maxFailureReasonRunes. Critical for isProgressCompleted integrity: the reason
// must not contain "\n<separatorLine>\nCompleted:" which would false-positive
// the tail scan.
func sanitizeFailureReason(s string) string {
        mapped := strings.Map(func(r rune) rune {
                if unicode.IsControl(r) || r == '\u2028' || r == '\u2029' {
                        return ' '
                }
                return r
        }, s)
        out := strings.Join(strings.Fields(mapped), " ")
        if runes := []rune(out); len(runes) > maxFailureReasonRunes {
                out = string(runes[:maxFailureReasonRunes]) + "..."
        }
        if out == "" {
                return "unknown error"
        }
        return out
}

func (l *Logger) writeFile(format string, args ...any) {
        if l.file != nil {
                fmt.Fprintf(l.file, format, args...)
        }
}

func (l *Logger) writeStdout(format string, args ...any) {
        fmt.Fprintf(l.stdout, format, args...)
}

// isProgressCompleted reports whether the progress file ends with a successful "Completed:"
// footer written by Close(). "Failed:" footers are intentionally excluded so failed/aborted
// runs preserve history on restart (issue #288).
// reads the last ~256 bytes from the provided file descriptor and checks for the dash separator
// followed by "Completed:" — the exact pattern Close() writes on success.
// uses the already-locked fd to avoid TOCTOU path-vs-inode mismatch.
// returns false for zero-size files or read errors.
func isProgressCompleted(f *os.File, size int64) bool {
        if size == 0 {
                return false
        }

        // read the last 256 bytes (or less if file is smaller)
        const tailSize int64 = 256
        offset := max(0, size-tailSize)

        buf := make([]byte, tailSize)
        n, err := f.ReadAt(buf, offset)
        if err != nil && n == 0 {
                return false
        }

        // match the exact pattern written by Close(): 60-dash separator followed by "Completed:".
        // a plain "Completed:" check would false-positive on Claude output containing that text.
        return strings.Contains(string(buf[:n]), separatorLine+"\nCompleted:")
}

// progressDir is the directory for progress files within the project.
const progressDir = ".ralphex/progress"

// progressFilename returns progress file path based on plan and mode.
func progressFilename(planFile, planDescription, mode string) string {
        // plan mode uses sanitized plan description
        if mode == "plan" && planDescription != "" {
                sanitized := sanitizePlanName(planDescription)
                return filepath.Join(progressDir, fmt.Sprintf("progress-plan-%s.txt", sanitized))
        }

        if planFile != "" {
                stem := strings.TrimSuffix(filepath.Base(planFile), ".md")
                switch mode {
                case "codex-only":
                        return filepath.Join(progressDir, fmt.Sprintf("progress-%s-codex.txt", stem))
                case "review":
                        return filepath.Join(progressDir, fmt.Sprintf("progress-%s-review.txt", stem))
                default:
                        return filepath.Join(progressDir, fmt.Sprintf("progress-%s.txt", stem))
                }
        }

        switch mode {
        case "codex-only":
                return filepath.Join(progressDir, "progress-codex.txt")
        case "review":
                return filepath.Join(progressDir, "progress-review.txt")
        case "plan":
                return filepath.Join(progressDir, "progress-plan.txt")
        default:
                return filepath.Join(progressDir, "progress.txt")
        }
}

// sanitizePlanName converts plan description to a safe filename component.
// replaces spaces with dashes, removes special characters, and limits length.
func sanitizePlanName(desc string) string {
        // lowercase and replace spaces with dashes
        result := strings.ToLower(desc)
        result = strings.ReplaceAll(result, " ", "-")

        // keep only alphanumeric and dashes
        var clean strings.Builder
        for _, r := range result {
                if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '-' {
                        clean.WriteRune(r)
                }
        }
        result = clean.String()

        // collapse multiple dashes
        result = multiDashRegex.ReplaceAllString(result, "-")

        // trim leading/trailing dashes
        result = strings.Trim(result, "-")

        // limit length to 50 characters
        if len(result) > 50 {
                result = result[:50]
                // don't end with a dash
                result = strings.TrimRight(result, "-")
        }

        if result == "" {
                return "unnamed"
        }
        return result
}

umputun / ralphex / 25115074240

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