Files
knowledge-governance/internal/qaopsquality/projection.go
T
姚章浩 828c2c5fa0
build / build (push) Successful in 1m6s
feat(qa-ops): 按确认口径补齐质量比例与分母明细
使用完整筛选范围的当前有效结论计算覆盖率和正确率,人工优先,失效与对应待确认/未评估/不计入排除;零分母返回null,界面展示原始分子分母和排除构成,前端拒绝不守恒或比例不一致的响应。

验证:make verify退出码0,Go658及前端257通过,91项声明可选集成跳过;隔离PG、三包竞态及合成/真实只读源浏览器验证通过。无新增迁移,不接AI模型,不改绩效,不写源库;本批未推送或部署,8088运行版保持0.1.21。
2026-10-18 02:00:31 +08:00

126 lines
4.0 KiB
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 !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
}