knowledge-governance/internal/qaopsquality/projection.go

package qaopsquality

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"knowledge-governance/internal/dobotaiops"
	"regexp"
	"strings"
	"unicode/utf8"
)

var hashPattern = regexp.MustCompile(`^[a-f0-9]{64}$`)
var noncePattern = regexp.MustCompile(`^[A-Za-z0-9_-]{16,128}$`)

func validText(s string, max int) bool {
	return utf8.ValidString(s) && utf8.RuneCountInString(s) <= max && !strings.ContainsRune(s, 0)
}
func validID(s string) bool { return strings.TrimSpace(s) != "" && validText(s, 256) }
func canonical(raw json.RawMessage) (json.RawMessage, error) {
	if len(raw) == 0 {
		return json.RawMessage("null"), nil
	}
	decoder := json.NewDecoder(bytes.NewReader(raw))
	decoder.UseNumber()
	var v any
	if decoder.Decode(&v) != nil {
		return nil, ErrInvalid
	}
	var extra any
	if decoder.Decode(&extra) != io.EOF {
		return nil, ErrInvalid
	}
	out, err := json.Marshal(v)
	return out, err
}
func EvidenceFor(record dobotaiops.Record) (Evidence, error) {
	if !validID(record.ID) {
		return Evidence{}, ErrInvalid
	}
	refs, err := canonical(record.References)
	if err != nil {
		return Evidence{}, ErrInvalid
	}
	media, err := canonical(record.Media)
	if err != nil {
		return Evidence{}, ErrInvalid
	}
	// Keep only assessment inputs, never personnel or mutable feedback/organisation.
	payload, err := json.Marshal(struct {
		Version    string          `json:"version"`
		ID         string          `json:"id"`
		Status     string          `json:"status"`
		Question   string          `json:"question"`
		Answer     string          `json:"answer"`
		References json.RawMessage `json:"references"`
		Media      json.RawMessage `json:"media"`
	}{"dobotai-2.0-dingtalk-quality-v1", record.ID, record.Status, record.Question, record.Answer, refs, media})
	if err != nil || len(payload) > 8<<20 {
		return Evidence{}, ErrInvalid
	}
	sum := sha256.Sum256(payload)
	hash := hex.EncodeToString(sum[:])
	if record.QualityInputHash != "" {
		if !hashPattern.MatchString(record.QualityInputHash) {
			return Evidence{}, ErrInvalid
		}
		hash = record.QualityInputHash
	}
	return Evidence{Hash: hash, Payload: payload, Record: record, Result: dobotaiops.CheckAnswerCoverage(record.Answer)}, nil
}
func Validate(r SaveRequest) error {
	if !hashPattern.MatchString(r.InputHash) || r.InputEpoch < 1 || r.BaseRevision < 0 || !noncePattern.MatchString(r.Nonce) || strings.TrimSpace(r.Reason) == "" || !validText(r.Reason, 4000) {
		return ErrInvalid
	}
	f := r.Fields
	validCoverage := false
	for _, s := range []string{"covered", "uncovered", "partial", "pending", "excluded"} {
		validCoverage = validCoverage || f.Coverage == s
	}
	if !validCoverage || (f.Correctness != "correct" && f.Correctness != "incorrect" && f.Correctness != "pending") {
		return ErrInvalid
	}
	if (f.Correctness == "pending") != (f.Coverage == "uncovered") {
		return ErrInvalid
	}
	if !validText(f.ProductCategory, 128) || !validText(f.ProblemType, 128) || !validText(f.RootCause, 2000) || !validText(f.ExclusionReason, 2000) {
		return ErrInvalid
	}
	if f.Correctness == "correct" && f.RootCause != "" || f.Coverage == "excluded" && strings.TrimSpace(f.ExclusionReason) == "" || f.Coverage != "excluded" && f.ExclusionReason != "" {
		return ErrInvalid
	}
	return nil
}
func Project(hash string, epoch, revision int64, automatic Check, review *Review) View {
	view := View{InputHash: hash, InputEpoch: epoch, Revision: revision, State: "unreviewed", Automatic: automatic, LatestReview: review, Effective: Fields{Coverage: automatic.Result.Verdict}}
	if review == nil {
		return view
	}
	view.State = "stale"
	if review.InputEpoch == epoch && review.InputHash == hash {
		view.State = "reviewed"
		view.Effective = review.Fields
	}
	return view
}
func Summarize(views map[string]View) Summary {
	result := Summary{Total: len(views), Rates: ComputeRates(views)}
	for _, v := range views {
		switch v.State {
		case "reviewed":
			result.Reviewed++
			if v.Effective.Coverage == "pending" || v.Effective.Correctness == "pending" {
				result.PendingConfirmation++
			}
		case "stale":
			result.Stale++
		default:
			result.Unreviewed++
		}
		if v.Automatic.Result.Verdict == "uncovered" {
			result.RuleUncovered++
		}
	}
	return result
}