Agent-System/internal/docrevision/risk.go

package docrevision

import (
	"encoding/json"
	"fmt"
	"regexp"
	"strings"
)

var (
	sensitiveDeleteRe = regexp.MustCompile(`(?i)(法规|风险控制|验收标准|技术参数|REQ-|GB\d|YY\d)`)
	numericChangeRe   = regexp.MustCompile(`\d+(\.\d+)?`)
)

// MaxRisk returns the higher of two risk levels.
func MaxRisk(a, b string) string {
	rank := map[string]int{RiskLow: 1, RiskMedium: 2, RiskHigh: 3, RiskCritical: 4, "": 0}
	if rank[a] >= rank[b] {
		if a == "" {
			return RiskLow
		}
		return a
	}
	if b == "" {
		return RiskLow
	}
	return b
}

// RuleRiskFloor computes deterministic risk from diff hunks.
func RuleRiskFloor(hunks []DiffHunk, impacts []DocImpact) string {
	level := RiskLow
	for _, h := range hunks {
		text := h.BeforeText + "\n" + h.AfterText
		if h.Kind == "delete" && sensitiveDeleteRe.MatchString(h.BeforeText) {
			level = MaxRisk(level, RiskHigh)
		}
		if h.Kind == "modify" && sensitiveDeleteRe.MatchString(text) {
			level = MaxRisk(level, RiskHigh)
		}
		if h.Kind == "modify" && numericChangeRe.MatchString(h.BeforeText) && numericChangeRe.MatchString(h.AfterText) && h.BeforeText != h.AfterText {
			if sensitiveDeleteRe.MatchString(text) {
				level = MaxRisk(level, RiskHigh)
			} else {
				level = MaxRisk(level, RiskMedium)
			}
		}
	}
	for _, imp := range impacts {
		if imp.ImpactType == "stale_candidate" || strings.Contains(imp.Reason, "已批准") {
			level = MaxRisk(level, RiskCritical)
		} else if imp.DocID != "" {
			level = MaxRisk(level, RiskHigh)
		}
	}
	return level
}

// ValidateChangeReportJSON parses and validates change_report.json against deterministic facts.
func ValidateChangeReportJSON(raw string, fromSHA, toSHA string, ruleRisk string, impacts []DocImpact, hunks []DiffHunk) (*ChangeReport, error) {
	if strings.TrimSpace(raw) == "" {
		return fallbackReport(fromSHA, toSHA, ruleRisk, impacts, hunks, "empty report"), ErrReportInvalid
	}
	var payload struct {
		SchemaVersion int              `json:"schema_version"`
		Summary       []string         `json:"summary"`
		Changes       []map[string]any `json:"changes"`
		Risk          struct {
			Level string     `json:"level"`
			Items []RiskItem `json:"items"`
		} `json:"risk"`
		ProjectImpact   map[string]any `json:"project_impact"`
		DocumentImpacts []DocImpact    `json:"document_impacts"`
		OpenQuestions   []string       `json:"open_questions"`
	}
	if err := json.Unmarshal([]byte(raw), &payload); err != nil {
		return fallbackReport(fromSHA, toSHA, ruleRisk, impacts, hunks, "json parse failed"), fmt.Errorf("%w: %v", ErrReportInvalid, err)
	}
	if payload.SchemaVersion != 1 {
		return fallbackReport(fromSHA, toSHA, ruleRisk, impacts, hunks, "bad schema"), fmt.Errorf("%w: schema_version", ErrReportInvalid)
	}
	if fromSHA != toSHA && len(payload.Summary) == 0 && len(payload.Changes) == 0 {
		return fallbackReport(fromSHA, toSHA, ruleRisk, impacts, hunks, "claims no change"), fmt.Errorf("%w: missing summary for changed content", ErrReportInvalid)
	}
	if fromSHA != toSHA && strings.EqualFold(strings.Join(payload.Summary, " "), "未修改") {
		return fallbackReport(fromSHA, toSHA, ruleRisk, impacts, hunks, "claims unmodified"), fmt.Errorf("%w: unmodified claim", ErrReportInvalid)
	}
	finalRisk := MaxRisk(ruleRisk, payload.Risk.Level)
	if finalRisk == "" {
		finalRisk = RiskUnassessedAsHigh()
	}
	rep := &ChangeReport{
		SchemaVersion:   1,
		Summary:         payload.Summary,
		RiskLevel:       finalRisk,
		RiskItems:       payload.Risk.Items,
		ProjectImpacts:  payload.ProjectImpact,
		DocumentImpacts: mergeImpacts(payload.DocumentImpacts, impacts),
		OpenQuestions:   payload.OpenQuestions,
		AnalysisStatus:  AnalysisComplete,
		RawJSON:         raw,
		DeterministicFacts: map[string]any{
			"from_sha":     fromSHA,
			"to_sha":       toSHA,
			"rule_risk":    ruleRisk,
			"hunk_count":   len(hunks),
			"impact_count": len(impacts),
		},
	}
	return rep, nil
}

// BuildDeterministicChangeReportJSON builds a non-fabricated report from diff + rule risk + lineage.
// Narrative PI text is intentionally absent; analysis_status is fallback.
func BuildDeterministicChangeReportJSON(fromSHA, toSHA, ruleRisk string, impacts []DocImpact, diff DiffResult) string {
	summaries := make([]string, 0, 4)
	summaries = append(summaries, fmt.Sprintf("确定性差异：+%d / -%d / ~%d 处块级变更",
		diff.Summary.Inserts, diff.Summary.Deletes, diff.Summary.Modifies))
	for i, h := range diff.Hunks {
		if i >= 3 {
			break
		}
		sec := h.Section
		if sec == "" {
			sec = h.Kind
		}
		summaries = append(summaries, fmt.Sprintf("%s：%s", h.Kind, sec))
	}
	if fromSHA == toSHA {
		summaries = []string{"内容哈希未变化（agent noop 候选）"}
	}
	riskItems := []RiskItem{}
	if ruleRisk == RiskHigh || ruleRisk == RiskCritical {
		riskItems = append(riskItems, RiskItem{
			Category:    "rule_floor",
			Description: "规则引擎根据敏感删除/数值/下游影响抬升风险",
			Mitigation:  "由编制负责人确认后提交",
		})
	}
	proj := map[string]any{
		"summary": fmt.Sprintf("下游受影响文档 %d 份", len(impacts)),
	}
	payload := map[string]any{
		"schema_version":   1,
		"summary":          summaries,
		"risk":             map[string]any{"level": ruleRisk, "items": riskItems},
		"project_impact":   proj,
		"document_impacts": impacts,
		"open_questions": []string{
			"业务叙事摘要待真实 PI 变更报告链路补齐（DOCREV-RT-PI-NARRATIVE）",
		},
	}
	raw, _ := json.Marshal(payload)
	// Mark fallback via validator path: empty open_questions would be complete;
	// we keep open_questions and let caller set AnalysisFallback after validate when desired.
	_ = raw
	// Force fallback semantics by returning JSON that validates, then caller may override status.
	rep, err := ValidateChangeReportJSON(string(raw), fromSHA, toSHA, ruleRisk, impacts, diff.Hunks)
	if err != nil || rep == nil {
		fb := fallbackReport(fromSHA, toSHA, ruleRisk, impacts, diff.Hunks, "deterministic build")
		fb.AnalysisStatus = AnalysisFallback
		out, _ := json.Marshal(map[string]any{
			"schema_version": 1, "summary": fb.Summary,
			"risk":           map[string]any{"level": fb.RiskLevel, "items": fb.RiskItems},
			"project_impact": proj, "document_impacts": impacts, "open_questions": fb.OpenQuestions,
		})
		return string(out)
	}
	// Re-encode with explicit fallback marker in open_questions already present.
	return string(raw)
}

func RiskUnassessedAsHigh() string { return RiskHigh }

func fallbackReport(fromSHA, toSHA, ruleRisk string, impacts []DocImpact, hunks []DiffHunk, reason string) *ChangeReport {
	risk := ruleRisk
	if risk == "" {
		risk = RiskHigh
	}
	return &ChangeReport{
		SchemaVersion:   1,
		Summary:         []string{"变更报告未完整评估，已按保守策略处理"},
		RiskLevel:       risk,
		DocumentImpacts: impacts,
		OpenQuestions:   []string{reason},
		AnalysisStatus:  AnalysisUnassessed,
		DeterministicFacts: map[string]any{
			"from_sha":   fromSHA,
			"to_sha":     toSHA,
			"rule_risk":  ruleRisk,
			"hunk_count": len(hunks),
			"fallback":   reason,
		},
	}
}

func mergeImpacts(model, det []DocImpact) []DocImpact {
	seen := map[string]bool{}
	out := make([]DocImpact, 0, len(model)+len(det))
	for _, d := range det {
		if d.DocID == "" || seen[d.DocID] {
			continue
		}
		seen[d.DocID] = true
		out = append(out, d)
	}
	for _, m := range model {
		if m.DocID == "" || seen[m.DocID] {
			continue
		}
		seen[m.DocID] = true
		out = append(out, m)
	}
	return out
}

// NeedsConfirmation reports whether frozen policy requires author confirmation.
func NeedsConfirmation(risk string) bool {
	return risk == RiskHigh || risk == RiskCritical
}