update krknai prompt and markdown-to-HTML conversion

Author: minlei98

go.mod

@@ -110,6 +110,7 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/golang/glog v1.2.4 // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/gomarkdown/markdown v0.0.0-20260217112301-37c66b85d6ab // indirect
 	github.com/google/gnostic-models v0.6.9 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/go-querystring v1.1.0 // indirect

go.sum

@@ -151,6 +151,8 @@ github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUv
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/gomarkdown/markdown v0.0.0-20260217112301-37c66b85d6ab h1:VYNivV7P8IRHUam2swVUNkhIdp0LRRFKe4hXNnoZKTc=
+github.com/gomarkdown/markdown v0.0.0-20260217112301-37c66b85d6ab/go.mod h1:JDGcbDT52eL4fju3sZ4TeHGsQwhG9nbDV21aMyhwPoA=
 github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw=
 github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=

internal/analysisengine/engine.go

@@ -29,6 +29,8 @@ type ClusterInfo struct {
 	Region        string
 	CloudProvider string
 	Version       string
+	Type          string // e.g. "rosa", "osd", "aro"
+	Hypershift    bool
 }
 
 // Config holds configuration for the analysis engine.

internal/prompts/prompts.go

@@ -71,6 +71,12 @@ func (ps *PromptStore) loadTemplates(filesystem fs.FS) error {
 	})
 }
 
+// RegisterTemplates loads additional templates from the given filesystem,
+// overwriting any existing templates with the same ID.
+func (ps *PromptStore) RegisterTemplates(templatesFS fs.FS) error {
+	return ps.loadTemplates(templatesFS)
+}
+
 func (ps *PromptStore) GetTemplate(id string) (*PromptTemplate, error) {
 	template, exists := ps.templates[id]
 	if !exists {

internal/prompts/prompts_test.go

@@ -12,6 +12,9 @@ func TestNewPromptStore(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, store)
 	assert.Greater(t, len(store.templates), 0, "Should have loaded some templates")
+
+	_, err = store.GetTemplate("default")
+	assert.NoError(t, err, "default template should be loaded")
 }
 
 func TestGetTemplate(t *testing.T) {

pkg/krknai/analysisengine/engine.go

@@ -9,6 +9,9 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/gomarkdown/markdown"
+	mdhtml "github.com/gomarkdown/markdown/html"
+	"github.com/gomarkdown/markdown/parser"
 	"github.com/openshift/osde2e/internal/analysisengine"
 	"github.com/openshift/osde2e/internal/llm"
 	"github.com/openshift/osde2e/internal/llm/tools"
@@ -18,21 +21,23 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-//go:embed prompts/krknai.yaml
-var krknaiTemplatesFS embed.FS
+//go:embed prompts/*
+var krknPrompts embed.FS
 
 const (
 	analysisDirName = "llm-analysis"
 	summaryFileName = "summary.yaml"
 
-	// krknAIPromptTemplate is the prompt template ID for krkn-ai analysis.
 	krknAIPromptTemplate = "krknai"
+	htmlTemplatePath     = "prompts/report.html"
 )
 
 // Config holds configuration for the krkn-ai analysis engine.
 type Config struct {
 	analysisengine.BaseConfig
-	TopScenariosCount int // Number of top scenarios to include (default: 10)
+	TopScenariosCount int                         // Number of top scenarios to include (default: 10)
+	ReportFormat      string                      // "json" (default), "markdown", or "html"
+	ClusterInfo       *analysisengine.ClusterInfo // Cluster metadata from CLI flags
 }
 
 // Engine analyzes krkn-ai chaos test results using LLM.
@@ -60,14 +65,17 @@ func New(ctx context.Context, config *Config) (*Engine, error) {
 		agg.WithTopScenariosCount(config.TopScenariosCount)
 	}
 
-	templatesFS, err := fs.Sub(krknaiTemplatesFS, "prompts")
+	promptStore, err := prompts.NewPromptStore(prompts.DefaultTemplates())
 	if err != nil {
-		return nil, fmt.Errorf("failed to access embedded prompts: %w", err)
+		return nil, fmt.Errorf("failed to initialize prompt store: %w", err)
 	}
 
-	promptStore, err := prompts.NewPromptStore(templatesFS)
+	localFS, err := fs.Sub(krknPrompts, "prompts")
 	if err != nil {
-		return nil, fmt.Errorf("failed to initialize prompt store: %w", err)
+		return nil, fmt.Errorf("failed to load krkn-ai prompt templates: %w", err)
+	}
+	if err := promptStore.RegisterTemplates(localFS); err != nil {
+		return nil, fmt.Errorf("failed to register krkn-ai prompt templates: %w", err)
 	}
 
 	client, err := llm.NewGeminiClient(ctx, config.APIKey)
@@ -108,6 +116,9 @@ func (e *Engine) Run(ctx context.Context) (*analysisengine.Result, error) {
 		"LogArtifacts":      data.LogArtifacts,
 		"ConfigSummary":     data.ConfigSummary,
 	}
+	if e.config.ClusterInfo != nil {
+		vars["ClusterInfo"] = e.config.ClusterInfo
+	}
 
 	// Render prompt using prompt store
 	userPrompt, llmConfig, err := e.promptStore.RenderPrompt(krknAIPromptTemplate, vars)
@@ -134,10 +145,19 @@ func (e *Engine) Run(ctx context.Context) (*analysisengine.Result, error) {
 		return nil, fmt.Errorf("LLM analysis failed: %w", err)
 	}
 
+	content := result.Content
+	if e.config.ReportFormat == "html" {
+		var err error
+		content, err = markdownToHTML(content)
+		if err != nil {
+			return nil, fmt.Errorf("failed to convert markdown to HTML: %w", err)
+		}
+	}
+
 	// Build analysis result
 	analysisResult := &analysisengine.Result{
 		Status:  "completed",
-		Content: result.Content,
+		Content: content,
 		Prompt:  userPrompt,
 		Metadata: map[string]any{
 			"analysis_type":        "krknai",
@@ -159,7 +179,7 @@ func (e *Engine) Run(ctx context.Context) (*analysisengine.Result, error) {
 	}
 
 	// Write summary to results directory
-	if err := e.writeSummary(analysisResult, data); err != nil {
+	if err := e.writeSummary(analysisResult, data, e.config.ClusterInfo); err != nil {
 		return nil, fmt.Errorf("failed to write analysis summary: %w", err)
 	}
 
@@ -172,7 +192,7 @@ func (e *Engine) Run(ctx context.Context) (*analysisengine.Result, error) {
 }
 
 // writeSummary writes the analysis result to a YAML summary file.
-func (e *Engine) writeSummary(result *analysisengine.Result, data *krknAggregator.KrknAIData) error {
+func (e *Engine) writeSummary(result *analysisengine.Result, data *krknAggregator.KrknAIData, clusterInfo *analysisengine.ClusterInfo) error {
 	analysisDir := filepath.Join(e.config.ArtifactsDir, analysisDirName)
 	if err := os.MkdirAll(analysisDir, 0o755); err != nil {
 		return fmt.Errorf("failed to create analysis directory: %w", err)
@@ -181,6 +201,7 @@ func (e *Engine) writeSummary(result *analysisengine.Result, data *krknAggregato
 	summary := map[string]any{
 		"timestamp":     time.Now().Format(time.RFC3339),
 		"analysis_type": "krknai",
+		"cluster_info":  clusterInfo,
 		"run_summary": map[string]any{
 			"total_scenarios":      data.Summary.TotalScenarioCount,
 			"successful_scenarios": data.Summary.SuccessfulScenarioCount,
@@ -212,6 +233,17 @@ func (e *Engine) writeSummary(result *analysisengine.Result, data *krknAggregato
 	return nil
 }
 
+func markdownToHTML(content string) (string, error) {
+	htmlTemplate, err := krknPrompts.ReadFile(htmlTemplatePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read HTML template: %w", err)
+	}
+	p := parser.NewWithExtensions(parser.CommonExtensions | parser.AutoHeadingIDs)
+	renderer := mdhtml.NewRenderer(mdhtml.RendererOptions{Flags: mdhtml.CommonFlags | mdhtml.HrefTargetBlank})
+	body := markdown.ToHTML([]byte(content), p, renderer)
+	return fmt.Sprintf(string(htmlTemplate), string(body)), nil
+}
+
 // sendNotifications sends analysis results to configured reporters.
 func (e *Engine) sendNotifications(ctx context.Context, result *analysisengine.Result) {
 	reporterResult := &reporter.AnalysisResult{

pkg/krknai/analysisengine/engine_test.go

@@ -50,13 +50,177 @@ func TestNew_ValidConfig(t *testing.T) {
 	assert.Contains(t, err.Error(), "results directory is required")
 }
 
-func TestEmbeddedPromptTemplate(t *testing.T) {
-	// Verify the embedded prompt template loads correctly
-	data, err := krknaiTemplatesFS.ReadFile("prompts/krknai.yaml")
+func TestPromptTemplatesAvailable(t *testing.T) {
+	store := newTestPromptStore(t)
+
+	tmpl, err := store.GetTemplate("krknai")
+	require.NoError(t, err)
+	assert.Contains(t, tmpl.SystemPrompt, "chaos engineering")
+	assert.Contains(t, tmpl.UserPrompt, "Summary")
+
+	assert.Contains(t, tmpl.SystemPrompt, "markdown")
+	assert.Contains(t, tmpl.SystemPrompt, "genetic algorithm")
+}
+
+func TestRenderKrknAIPrompt(t *testing.T) {
+	store := newTestPromptStore(t)
+
+	variables := map[string]any{
+		"ClusterInfo": &analysisengine.ClusterInfo{
+			ID:         "abc-123",
+			Name:       "test-rosa-cluster",
+			Version:    "4.17.3",
+			Type:       "rosa-hcp",
+			Provider:   "aws",
+			Region:     "us-east-1",
+			Hypershift: true,
+		},
+		"Summary": map[string]any{
+			"TotalScenarioCount":      30,
+			"SuccessfulScenarioCount": 27,
+			"FailedScenarioCount":     3,
+			"Generations":             3,
+			"MaxFitnessScore":         8.75,
+			"AvgFitnessScore":         4.32,
+			"ScenarioTypes":           []string{"node-cpu-hog", "node-memory-hog", "pod-scenarios"},
+		},
+		"TopScenarios": []map[string]any{
+			{
+				"Scenario":                     "node-cpu-hog",
+				"GenerationID":                 2,
+				"ScenarioID":                   15,
+				"FitnessScore":                 8.75,
+				"HealthCheckResponseTimeScore": 6.50,
+				"HealthCheckFailureScore":      2.25,
+				"KrknFailureScore":             0.0,
+				"Parameters":                   "node_selector: node-role.kubernetes.io/worker",
+			},
+		},
+		"FailedScenarios": []map[string]any{
+			{
+				"Scenario":         "dns-outage",
+				"GenerationID":     1,
+				"ScenarioID":       7,
+				"KrknFailureScore": -1.0,
+				"Parameters":       "namespace: openshift-dns",
+			},
+		},
+		"HealthCheckReport": []map[string]any{
+			{
+				"ScenarioID":          15,
+				"ComponentName":       "console",
+				"MinResponseTime":     12.5,
+				"MaxResponseTime":     850.3,
+				"AverageResponseTime": 245.7,
+				"SuccessCount":        48,
+				"FailureCount":        2,
+			},
+		},
+		"LogArtifacts": []map[string]any{
+			{"Source": "/results/reports/all.csv", "LineCount": 31},
+			{"Source": "/results/krkn-ai.yaml", "LineCount": 85},
+		},
+		"ConfigSummary": "generations: 3\npopulation_size: 10\n",
+	}
+
+	userPrompt, config, err := store.RenderPrompt("krknai", variables)
+	require.NoError(t, err)
+	require.NotNil(t, config)
+
+	assert.Contains(t, userPrompt, "id=abc-123")
+	assert.Contains(t, userPrompt, "name=test-rosa-cluster")
+	assert.Contains(t, userPrompt, "version=4.17.3")
+	assert.Contains(t, userPrompt, "type=rosa-hcp")
+	assert.Contains(t, userPrompt, "hypershift=true")
+
+	assert.Contains(t, userPrompt, "30 scenarios")
+	assert.Contains(t, userPrompt, "27 ok")
+	assert.Contains(t, userPrompt, "3 failed")
+	assert.Contains(t, userPrompt, "max=8.75")
+	assert.Contains(t, userPrompt, "fitness=8.75")
+	assert.Contains(t, userPrompt, "node_selector: node-role.kubernetes.io/worker")
+	assert.Contains(t, userPrompt, "dns-outage")
+	assert.Contains(t, userPrompt, "console")
+	assert.Contains(t, userPrompt, "avg=245.70ms")
+	assert.Contains(t, userPrompt, "/results/reports/all.csv (31L)")
+	assert.Contains(t, userPrompt, "generations: 3")
+
+	assert.NotNil(t, config.SystemInstruction)
+	assert.Contains(t, *config.SystemInstruction, "chaos engineering analyst")
+	assert.Contains(t, *config.SystemInstruction, "genetic algorithm")
+}
+
+func TestRun_MarkdownReportFormat(t *testing.T) {
+	tempDir := t.TempDir()
+	reportsDir := filepath.Join(tempDir, "reports")
+	require.NoError(t, os.MkdirAll(reportsDir, 0o755))
+
+	createTestResultFiles(t, tempDir, reportsDir)
+
+	ctx := context.Background()
+	agg := krknAggregator.NewKrknAIAggregator(ctx)
+	promptStore := newTestPromptStore(t)
+
+	mockClient := &mockLLMClient{
+		response: &llm.AnalysisResult{
+			Content: "# Krkn-AI Chaos Test Report\n\n## Executive Summary\nCluster shows moderate resilience.",
+		},
+	}
+
+	engine := &Engine{
+		config: &Config{
+			BaseConfig:   analysisengine.BaseConfig{ArtifactsDir: tempDir, APIKey: "fake-key"},
+			ReportFormat: "markdown",
+		},
+		aggregator:       agg,
+		promptStore:      promptStore,
+		llmClient:        mockClient,
+		reporterRegistry: newTestReporterRegistry(),
+	}
+
+	result, err := engine.Run(ctx)
 	require.NoError(t, err)
-	assert.Contains(t, string(data), "system_prompt")
-	assert.Contains(t, string(data), "user_prompt")
-	assert.Contains(t, string(data), "chaos engineering")
+	require.NotNil(t, result)
+	assert.Contains(t, result.Content, "Chaos Test Report")
+}
+
+func TestRun_HTMLReportFormat(t *testing.T) {
+	tempDir := t.TempDir()
+	reportsDir := filepath.Join(tempDir, "reports")
+	require.NoError(t, os.MkdirAll(reportsDir, 0o755))
+
+	createTestResultFiles(t, tempDir, reportsDir)
+
+	ctx := context.Background()
+	agg := krknAggregator.NewKrknAIAggregator(ctx)
+	promptStore := newTestPromptStore(t)
+
+	mockClient := &mockLLMClient{
+		response: &llm.AnalysisResult{
+			Content: "# Krkn-AI Chaos Test Report\n\n## Executive Summary\nCluster shows **moderate** resilience.\n\n| Metric | Value |\n|--------|-------|\n| Total | 5 |\n",
+		},
+	}
+
+	engine := &Engine{
+		config: &Config{
+			BaseConfig:   analysisengine.BaseConfig{ArtifactsDir: tempDir, APIKey: "fake-key"},
+			ReportFormat: "html",
+		},
+		aggregator:       agg,
+		promptStore:      promptStore,
+		llmClient:        mockClient,
+		reporterRegistry: newTestReporterRegistry(),
+	}
+
+	result, err := engine.Run(ctx)
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	assert.Contains(t, result.Content, "<!DOCTYPE html>")
+	assert.Contains(t, result.Content, "<h1")
+	assert.Contains(t, result.Content, "<table>")
+	assert.Contains(t, result.Content, "<strong>moderate</strong>")
+	assert.NotContains(t, result.Content, "## Executive Summary")
 }
 
 func TestWriteSummary(t *testing.T) {
@@ -96,7 +260,7 @@ func TestWriteSummary(t *testing.T) {
 		},
 	}
 
-	err := engine.writeSummary(result, data)
+	err := engine.writeSummary(result, data, nil)
 	require.NoError(t, err)
 
 	// Verify summary file exists
@@ -224,13 +388,16 @@ func TestRun_MissingResults(t *testing.T) {
 	assert.Contains(t, err.Error(), "failed to collect krkn-ai results")
 }
 
-// newTestPromptStore creates a prompt store using the embedded krkn-ai templates.
+// newTestPromptStore creates a prompt store using the central prompt templates.
 func newTestPromptStore(t *testing.T) *prompts.PromptStore {
 	t.Helper()
-	templatesFS, err := fs.Sub(krknaiTemplatesFS, "prompts")
+	store, err := prompts.NewPromptStore(prompts.DefaultTemplates())
 	require.NoError(t, err)
-	store, err := prompts.NewPromptStore(templatesFS)
+
+	localFS, err := fs.Sub(krknPrompts, "prompts")
 	require.NoError(t, err)
+	require.NoError(t, store.RegisterTemplates(localFS))
+
 	return store
 }