Render fixed Markdown reports and shared completion counts

internal/core/reporting/markdown.go

@@ -0,0 +1,180 @@
+package reporting
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"gitea.maximumdirect.net/eric/audita/internal/core/redaction"
+)
+
+// CompletionLine is the brief successful CLI summary. It uses the same counts
+// as both YAML documents and remains independent of file-output selection.
+func CompletionLine(snapshot Snapshot) string {
+	return fmt.Sprintf("Completed: %d corrections applied; %d work units with errors; %d recoveries.",
+		count(snapshot.Summary.CorrectionsApplied), count(snapshot.Summary.WorkUnitsWithErrors), count(snapshot.Summary.Recoveries))
+}
+
+func count(value *int) int {
+	if value == nil {
+		return 0
+	}
+	return *value
+}
+
+// Markdown renders a fixed-layout human report from one processing snapshot.
+func Markdown(snapshot Snapshot, secrets ...string) []byte {
+	r := redaction.New(secrets)
+	safe := func(value string) string { return escapeMarkdown(r.String(value)) }
+	var b strings.Builder
+	fmt.Fprintf(&b, "# Audita report: %s\n\n", safe(snapshot.RunID))
+	fmt.Fprintf(&b, "Status: %s\n\n", safe(snapshot.Status))
+	fmt.Fprintf(&b, "Corrections applied: %d  \n", count(snapshot.Summary.CorrectionsApplied))
+	fmt.Fprintf(&b, "Work units: %s total; %s completed; %s interrupted; %s not started  \n",
+		showCount(snapshot.Summary.WorkUnitsTotal), showCount(snapshot.Summary.WorkUnitsCompleted),
+		showCount(snapshot.Summary.WorkUnitsInterrupted), showCount(snapshot.Summary.WorkUnitsNotStarted))
+	fmt.Fprintf(&b, "Errors: %s work units; %s run errors  \n", showCount(snapshot.Summary.WorkUnitsWithErrors), showCount(snapshot.Summary.RunErrors))
+	fmt.Fprintf(&b, "Recoveries: %s of %s model operations  \n", showCount(snapshot.Summary.Recoveries), showCount(snapshot.Summary.LLMOperations))
+	fmt.Fprintf(&b, "Proposal responses: %s; with filtering: %s\n\n",
+		showCount(snapshot.Summary.ProposalResponses), showCount(snapshot.Summary.ProposalResponsesWithFiltering))
+	fmt.Fprintf(&b, "Transcript input: %s  \n", safe(snapshot.TranscriptPath))
+	fmt.Fprintf(&b, "Glossary input: %s  \n", safe(snapshot.GlossaryPath))
+	output := snapshot.OutputPath
+	if output == "" {
+		output = "stdout"
+	}
+	fmt.Fprintf(&b, "Transcript output: %s\n\n", safe(output))
+
+	fmt.Fprintln(&b, "## Work-unit errors")
+	fmt.Fprintln(&b)
+	writeMatrix(&b, snapshot, safe, false)
+	fmt.Fprintln(&b)
+	fmt.Fprintln(&b, "## Recoveries")
+	fmt.Fprintln(&b)
+	writeMatrix(&b, snapshot, safe, true)
+	fmt.Fprintln(&b)
+	fmt.Fprintln(&b, "Legend: `—` = not started; `n*` = interrupted with n recorded errors or recoveries. Completed error cells are 0 or 1.")
+	fmt.Fprintln(&b)
+	writeReasons(&b, "Error reasons", errorReasons(snapshot.Errors), safe)
+	writeReasons(&b, "Recovery reasons", recoveryReasons(snapshot.Recoveries), safe)
+	fmt.Fprintln(&b, "A recovery can have multiple reasons; reason counts need not sum to the recovery total.")
+	fmt.Fprintln(&b)
+	fmt.Fprintln(&b, "Details: `errors.yml` and `recoveries.yml`.")
+	return []byte(b.String())
+}
+
+func showCount(value *int) string {
+	if value == nil {
+		return "unknown"
+	}
+	return fmt.Sprint(*value)
+}
+
+func writeMatrix(b *strings.Builder, snapshot Snapshot, safe func(string) string, recovery bool) {
+	if len(snapshot.StageNames) == 0 || len(snapshot.WorkUnits) == 0 {
+		fmt.Fprintln(b, "No work units.")
+		return
+	}
+	columns := snapshot.StageNames
+	fmt.Fprint(b, "| Chunk |")
+	for _, name := range columns {
+		fmt.Fprintf(b, " %s |", safe(name))
+	}
+	fmt.Fprint(b, "\n| --- |")
+	for range columns {
+		fmt.Fprint(b, " ---: |")
+	}
+	fmt.Fprintln(b)
+	byChunk := make(map[int]map[int]WorkUnit)
+	chunkMeta := make(map[int]WorkUnit)
+	keys := make([]int, 0)
+	for _, unit := range snapshot.WorkUnits {
+		if byChunk[unit.ChunkIndex] == nil {
+			byChunk[unit.ChunkIndex] = make(map[int]WorkUnit)
+			keys = append(keys, unit.ChunkIndex)
+		}
+		byChunk[unit.ChunkIndex][unit.StageIndex] = unit
+		chunkMeta[unit.ChunkIndex] = unit
+	}
+	sort.Ints(keys)
+	for _, chunk := range keys {
+		meta := chunkMeta[chunk]
+		fmt.Fprintf(b, "| Chunk %d (segments %d–%d) |", chunk+1, meta.StartSegmentID, meta.EndSegmentID)
+		for stage := range columns {
+			unit, exists := byChunk[chunk][stage]
+			cell := "—"
+			if exists && unit.State != "not_started" {
+				n := unit.ErrorCount
+				if recovery {
+					n = unit.RecoveryCount
+				}
+				cell = fmt.Sprint(n)
+				if unit.State == "interrupted" {
+					cell += "*"
+				}
+			}
+			fmt.Fprintf(b, " %s |", cell)
+		}
+		fmt.Fprintln(b)
+	}
+}
+
+func writeReasons(b *strings.Builder, title string, counts map[string]int, safe func(string) string) {
+	fmt.Fprintf(b, "### %s\n\n", title)
+	if len(counts) == 0 {
+		fmt.Fprintln(b, "None.")
+		fmt.Fprintln(b)
+		return
+	}
+	keys := make([]string, 0, len(counts))
+	for key := range counts {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		fmt.Fprintf(b, "- `%s`: %d\n", safe(key), counts[key])
+	}
+	fmt.Fprintln(b)
+}
+
+func errorReasons(records []ErrorRecord) map[string]int {
+	counts := make(map[string]int)
+	for _, record := range records {
+		seen := make(map[string]bool)
+		if record.Scope == "run" {
+			seen[record.Reason] = true
+		}
+		for _, failure := range record.Failures {
+			seen[failure.Reason] = true
+		}
+		for reason := range seen {
+			if reason != "" {
+				counts[reason]++
+			}
+		}
+	}
+	return counts
+}
+
+func recoveryReasons(records []RecoveryRecord) map[string]int {
+	counts := make(map[string]int)
+	for _, record := range records {
+		seen := make(map[string]bool)
+		for _, reason := range record.Reasons {
+			seen[reason] = true
+		}
+		for reason := range seen {
+			counts[reason]++
+		}
+	}
+	return counts
+}
+
+func escapeMarkdown(value string) string {
+	value = strings.ReplaceAll(value, "\\", "\\\\")
+	value = strings.ReplaceAll(value, "|", "\\|")
+	value = strings.ReplaceAll(value, "`", "\\`")
+	value = strings.ReplaceAll(value, "\r\n", "\n")
+	value = strings.ReplaceAll(value, "\r", "\n")
+	return strings.ReplaceAll(value, "\n", "<br>")
+}