add screenshot

Signed-off-by: Siri Chongasamethaworn <siri@omise.co>

Author: KongZ

README.md

@@ -114,6 +114,14 @@ KubeAI Chatbot is built with safety as a priority:
 - **Immutable Secrets**: The bot is hard-coded to refuse any request involving `kubectl secrets`. This prevention happens at both the LLM prompt level and the tool execution validator.
 - **Confirmation Flow**: By default, `AUTOMATIC_MODIFY_RESOURCES` is set to `false`. The bot will generate resource-modifying commands but will not execute them, instead providing the command for you to run manually.
 
+## 📸 Screenshots
+
+|                             |                             |
+| :-------------------------: | :-------------------------: |
+| ![1](docs/screenshot_1.png) | ![2](docs/screenshot_2.png) |
+| ![3](docs/screenshot_3.png) | ![4](docs/screenshot_4.png) |
+| ![5](docs/screenshot_5.png) |                             |
+
 ## 📜 Credits & Licensing
 
 This project is a derivative work based on [kubectl-ai](https://github.com/GoogleCloudPlatform/kubectl-ai), originally developed by Google LLC.

docs/screenshot_1.png

@@ -434,7 +434,8 @@ func (s *SlackUI) generateBlocks(text string, includeContext bool) []slack.Block
 func (s *SlackUI) markdownToBlocks(text string) []slack.Block {
 	var blocks []slack.Block
 
-	// First, normalize tables that might be on a single line
+	// First, normalize inline headers and tables
+	text = s.normalizeInlineHeaders(text)
 	text = s.normalizeInlineTables(text)
 
 	lines := strings.Split(text, "\n")
@@ -597,6 +598,148 @@ func (s *SlackUI) parseMarkdownTable(lines []string) ([]string, [][]string) {
 	return headers, rows
 }
 
+// normalizeInlineHeaders adds line breaks after markdown headers that are followed by text without a newline.
+// Example: "### HeaderText here" becomes "### Header\nText here"
+func (s *SlackUI) normalizeInlineHeaders(text string) string {
+	lines := strings.Split(text, "\n")
+	var result []string
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+
+		// Check if line starts with markdown header
+		if strings.HasPrefix(trimmed, "###") {
+			// Find where the header text ends (after the header marker and any spaces/emojis)
+			headerStart := strings.Index(line, "###") + 3
+			restOfLine := line[headerStart:]
+
+			// Skip initial spaces
+			restOfLine = strings.TrimLeft(restOfLine, " ")
+
+			// Check if there's text after the header that should be on a new line
+			// Look for patterns like: "### 💡 HeaderTextWithoutSpace" or "### Header TextHere"
+			// We want to split after the first "word" (which might include emojis)
+
+			// Find the first lowercase letter after uppercase/emoji sequence
+			// This indicates where the header ends and content begins
+			headerEnd := -1
+			inHeaderText := false
+
+			for i, r := range restOfLine {
+				// Skip emojis and spaces at the start
+				if i < 10 && (r >= 0x1F300 || r == ' ') {
+					continue
+				}
+
+				// If we see an uppercase letter or start of word, we're in header
+				if !inHeaderText && (r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z') {
+					inHeaderText = true
+					continue
+				}
+
+				// If we're in header text and see a capital letter followed by lowercase
+				// or see text that looks like start of a sentence, that's where to split
+				if inHeaderText && i > 0 {
+					// Check for patterns like "PodI" -> split before "I"
+					prevRune := rune(restOfLine[i-1])
+					if (prevRune >= 'a' && prevRune <= 'z') && (r >= 'A' && r <= 'Z') {
+						// Lowercase followed by uppercase - likely start of new word
+						headerEnd = i
+						break
+					}
+				}
+			}
+
+			if headerEnd > 0 {
+				headerText := strings.TrimSpace(restOfLine[:headerEnd])
+				contentText := strings.TrimSpace(restOfLine[headerEnd:])
+				result = append(result, "### "+headerText)
+				if contentText != "" {
+					result = append(result, contentText)
+				}
+			} else {
+				result = append(result, line)
+			}
+		} else if strings.HasPrefix(trimmed, "##") {
+			// Similar logic for ## headers
+			headerStart := strings.Index(line, "##") + 2
+			restOfLine := line[headerStart:]
+			restOfLine = strings.TrimLeft(restOfLine, " ")
+
+			headerEnd := -1
+			inHeaderText := false
+
+			for i, r := range restOfLine {
+				if i < 10 && (r >= 0x1F300 || r == ' ') {
+					continue
+				}
+				if !inHeaderText && (r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z') {
+					inHeaderText = true
+					continue
+				}
+				if inHeaderText && i > 0 {
+					prevRune := rune(restOfLine[i-1])
+					if (prevRune >= 'a' && prevRune <= 'z') && (r >= 'A' && r <= 'Z') {
+						headerEnd = i
+						break
+					}
+				}
+			}
+
+			if headerEnd > 0 {
+				headerText := strings.TrimSpace(restOfLine[:headerEnd])
+				contentText := strings.TrimSpace(restOfLine[headerEnd:])
+				result = append(result, "## "+headerText)
+				if contentText != "" {
+					result = append(result, contentText)
+				}
+			} else {
+				result = append(result, line)
+			}
+		} else if strings.HasPrefix(trimmed, "#") && !strings.HasPrefix(trimmed, "##") {
+			// Similar logic for # headers
+			headerStart := strings.Index(line, "#") + 1
+			restOfLine := line[headerStart:]
+			restOfLine = strings.TrimLeft(restOfLine, " ")
+
+			headerEnd := -1
+			inHeaderText := false
+
+			for i, r := range restOfLine {
+				if i < 10 && (r >= 0x1F300 || r == ' ') {
+					continue
+				}
+				if !inHeaderText && (r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z') {
+					inHeaderText = true
+					continue
+				}
+				if inHeaderText && i > 0 {
+					prevRune := rune(restOfLine[i-1])
+					if (prevRune >= 'a' && prevRune <= 'z') && (r >= 'A' && r <= 'Z') {
+						headerEnd = i
+						break
+					}
+				}
+			}
+
+			if headerEnd > 0 {
+				headerText := strings.TrimSpace(restOfLine[:headerEnd])
+				contentText := strings.TrimSpace(restOfLine[headerEnd:])
+				result = append(result, "# "+headerText)
+				if contentText != "" {
+					result = append(result, contentText)
+				}
+			} else {
+				result = append(result, line)
+			}
+		} else {
+			result = append(result, line)
+		}
+	}
+
+	return strings.Join(result, "\n")
+}
+
 // normalizeInlineTables converts inline tables (tables without line breaks) to multi-line format
 func (s *SlackUI) normalizeInlineTables(text string) string {
 	// Pattern: | col1 | col2 || :--- | :--- || row1 | row2 |

docs/screenshot_2.png

@@ -675,3 +675,45 @@ func TestNewTableBlockLimits(t *testing.T) {
 		})
 	}
 }
+
+// TestNormalizeInlineHeaders verifies that markdown headers without line breaks after them
+// are correctly normalized to have the content on a separate line.
+func TestNormalizeInlineHeaders(t *testing.T) {
+	s := &SlackUI{}
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "header with emoji and inline text",
+			input:    "### 💡 Comparison with Working PodI noticed that your other pod",
+			expected: "### 💡 Comparison with Working Pod\nI noticed that your other pod",
+		},
+		{
+			name:     "header with emoji and inline text (different pattern)",
+			input:    "### 🚀 RecommendationTo fix this, you should",
+			expected: "### 🚀 Recommendation\nTo fix this, you should",
+		},
+		{
+			name:     "normal header with line break",
+			input:    "### Header Text\n\nSome content",
+			expected: "### Header Text\n\nSome content",
+		},
+		{
+			name:     "header without inline text",
+			input:    "### Just a Header",
+			expected: "### Just a Header",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := s.normalizeInlineHeaders(tt.input)
+			if result != tt.expected {
+				t.Errorf("normalizeInlineHeaders() failed\nInput:\n%s\n\nExpected:\n%s\n\nGot:\n%s", tt.input, tt.expected, result)
+			}
+		})
+	}
+}