fix: remove extra brackets to text containing ANSI escape seqences

addresses issue #449

Author: F1bonacc1

issues/issue_449/process-compose.yaml

@@ -0,0 +1,5 @@
+processes:
+  repro:
+    command: ./repro.py
+  but:
+    command: "echo this will print [butThisWont] and this also should: [with spaces]"

issues/issue_449/repro.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+
+print(
+    "\033[2m2026-01-01T00:00:00Z\033[0m"
+    " [\033[32m\033[1minfo     \033[0m]"
+    " \033[1msome log message\033[0m"
+    " [\033[34mmyapp\033[0m]"
+    " \033[36mkey\033[0m=\033[35mvalue\033[0m"
+)

src/tui/log-viewer.go

@@ -19,6 +19,10 @@ var (
 	// ANSI escape sequence patterns
 	// Clear entire screen sequences
 	clearScreenPattern = regexp.MustCompile(`\x1b\[2J|\x1bc|\x1b\[H\x1b\[2J`)
+	// tviewTagPattern matches patterns that tview's parseTag actually interprets
+	// as style/region tags. Unlike tview.Escape's regex, this excludes spaces,
+	// underscores, and other characters that parseTag rejects.
+	tviewTagPattern = regexp.MustCompile(`(\[[a-zA-Z0-9#:\-"]+\[*)\]`)
 )
 
 type truncator interface {
@@ -72,7 +76,7 @@ func (l *LogView) WriteString(line string) (n int, err error) {
 			// Remove the clear sequence and process remaining text
 			line = clearScreenPattern.ReplaceAllString(line, "")
 		}
-		return l.buffer.WriteString(tview.Escape(line + "\n"))
+		return l.buffer.WriteString(escapeForAnsiWriter(line) + "\n")
 	}
 	if strings.Contains(strings.ToLower(line), "error") {
 		return fmt.Fprintf(l.buffer, "[deeppink]%s[-:-:-]\n", tview.Escape(line))
@@ -81,6 +85,23 @@ func (l *LogView) WriteString(line string) (n int, err error) {
 	}
 }
 
+
+// escapeForAnsiWriter escapes tview-style tags in text that also contains ANSI
+// escape sequences. tview.Escape cannot be used here for two reasons:
+//  1. Its regex matches across ANSI/literal boundaries (e.g. "\x1b[0m]" contains
+//     "[0m]" which tview.Escape corrupts to "[0m[]").
+//  2. Its regex is broader than tview's actual parser — it escapes patterns with
+//     spaces and underscores that parseTag would never interpret as tags.
+//
+// This function protects ANSI CSI introducers (\x1b[) with a placeholder, then
+// applies a tighter escape regex that only matches what tview actually parses.
+func escapeForAnsiWriter(line string) string {
+	const placeholder = "\x1a" // SUB control char, not expected in log output
+	protected := strings.ReplaceAll(line, "\x1b[", placeholder)
+	protected = tviewTagPattern.ReplaceAllString(protected, "$1[]")
+	return strings.ReplaceAll(protected, placeholder, "\x1b[")
+}
+
 func (l *LogView) tryPrettyPrintJson(line string) string {
 	trimmed := strings.TrimSpace(line)
 	if len(trimmed) < 2 || (trimmed[0] != '{' && trimmed[0] != '[') {

src/tui/log-viewer_test.go

@@ -0,0 +1,83 @@
+package tui
+
+import (
+	"testing"
+)
+
+func TestEscapeForAnsiWriter(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{
+			name:  "plain text unchanged",
+			input: "hello world",
+			want:  "hello world",
+		},
+		{
+			name:  "ANSI reset before literal bracket not corrupted",
+			input: "\x1b[0m] after",
+			want:  "\x1b[0m] after",
+		},
+		{
+			name:  "literal tview-like tag is escaped",
+			input: "[ButThisWont] visible",
+			want:  "[ButThisWont[] visible",
+		},
+		{
+			name:  "structured log with ANSI colors and brackets",
+			input: "\x1b[2m2026-01-01T00:00:00Z\x1b[0m [\x1b[32m\x1b[1minfo     \x1b[0m] \x1b[1msome log message\x1b[0m [\x1b[34mmyapp\x1b[0m] \x1b[36mkey\x1b[0m=\x1b[35mvalue\x1b[0m",
+			want:  "\x1b[2m2026-01-01T00:00:00Z\x1b[0m [\x1b[32m\x1b[1minfo     \x1b[0m] \x1b[1msome log message\x1b[0m [\x1b[34mmyapp\x1b[0m] \x1b[36mkey\x1b[0m=\x1b[35mvalue\x1b[0m",
+		},
+		{
+			name:  "ANSI sequences preserved",
+			input: "\x1b[31mred\x1b[0m",
+			want:  "\x1b[31mred\x1b[0m",
+		},
+		{
+			name:  "multiple literal tags escaped",
+			input: "[red] and [blue]",
+			want:  "[red[] and [blue[]",
+		},
+		{
+			name:  "brackets with spaces not escaped",
+			input: "[not a tag because of spaces]",
+			want:  "[not a tag because of spaces]",
+		},
+		{
+			name:  "ANSI color followed immediately by literal tag",
+			input: "\x1b[0m[SomeTag]",
+			want:  "\x1b[0m[SomeTag[]",
+		},
+		{
+			name:  "hex color tag escaped",
+			input: "[#ff0000]text",
+			want:  "[#ff0000[]text",
+		},
+		{
+			name:  "reset tag escaped",
+			input: "[-]reset",
+			want:  "[-[]reset",
+		},
+		{
+			name:  "compound style tag escaped",
+			input: "[red:-:b]bold red",
+			want:  "[red:-:b[]bold red",
+		},
+		{
+			name:  "brackets with underscores not escaped",
+			input: "[some_var]",
+			want:  "[some_var]",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := escapeForAnsiWriter(tt.input)
+			if got != tt.want {
+				t.Errorf("escapeForAnsiWriter(%q)\n got  %q\n want %q", tt.input, got, tt.want)
+			}
+		})
+	}
+}