Motor de Decisão com IA

// Cálculo do ajuste histórico
if successRate > 0.8 {
    adjustment += 0.10
} else if successRate < 0.4 {
    adjustment -= 0.10
}

// Exemplo: 7 issues ativas
// Ajuste = -(7 - 3) * 0.02 = -0.08
activeIssues := countActiveIssues(namespace)
if activeIssues > 3 {
    adjustment -= float64(activeIssues - 3) * 0.02
}

type CircuitBreaker struct {
    failures    []time.Time
    window      time.Duration  // 1 hora
    threshold   int            // 3 falhas
    isOpen      bool
    mu          sync.Mutex
}

func (cb *CircuitBreaker) RecordFailure() {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    now := time.Now()
    cb.failures = append(cb.failures, now)

    // Remove falhas fora da janela
    cutoff := now.Add(-cb.window)
    var recent []time.Time
    for _, f := range cb.failures {
        if f.After(cutoff) {
            recent = append(recent, f)
        }
    }
    cb.failures = recent

    if len(cb.failures) >= cb.threshold {
        cb.isOpen = true
    }
}

func (cb *CircuitBreaker) IsOpen() bool {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    return cb.isOpen
}

SHA256(signalType | resourceKind | severity)

apiVersion: v1
kind: ConfigMap
metadata:
  name: chatcli-pattern-store
  namespace: chatcli-system
  labels:
    app.kubernetes.io/component: pattern-store
    platform.chatcli.io/managed-by: decision-engine
data:
  patterns.json: |
    {
      "a3f8c2...": {
        "signalType": "CrashLoopBackOff",
        "resourceKind": "Deployment",
        "severity": "high",
        "totalOccurrences": 12,
        "successfulResolutions": 10,
        "lastResolution": {
          "action": "Rollback",
          "timestamp": "2026-03-18T14:30:00Z",
          "durationSeconds": 45
        },
        "averageResolutionTime": "38s"
      }
    }

ConfidenceBoost = successRate * 0.15

func (r *RCAEnricher) DetectDeploymentChange(ctx context.Context,
    deployment *appsv1.Deployment) (*DeploymentChange, error) {

    // Lista ReplicaSets do deployment
    rsList, _ := r.client.AppsV1().ReplicaSets(deployment.Namespace).List(ctx,
        metav1.ListOptions{
            LabelSelector: labels.SelectorFromSet(deployment.Spec.Selector.MatchLabels).String(),
        })

    // Compara revisões (annotation deployment.kubernetes.io/revision)
    current, previous := findCurrentAndPrevious(rsList.Items)

    if current != nil && previous != nil {
        return &DeploymentChange{
            RevisionBefore: previous.Annotations["deployment.kubernetes.io/revision"],
            RevisionAfter:  current.Annotations["deployment.kubernetes.io/revision"],
            ImageBefore:    previous.Spec.Template.Spec.Containers[0].Image,
            ImageAfter:     current.Spec.Template.Spec.Containers[0].Image,
            Timestamp:      current.CreationTimestamp.Time,
        }, nil
    }
    return nil, nil
}

rcaEnrichment:
  deploymentChange:
    detected: true
    revisionBefore: "5"
    revisionAfter: "6"
    imageBefore: "api-server:v2.3.1"
    imageAfter: "api-server:v2.4.0"
    timestamp: "2026-03-19T10:15:00Z"

rcaEnrichment:
  configChanges:
    - resource: "ConfigMap/api-config"
      field: "database.maxConnections"
      timestamp: "2026-03-19T10:12:00Z"
      reason: "Updated via kubectl"

rcaEnrichment:
  relatedIssues:
    - name: issue-high-latency-redis
      severity: medium
      signalType: HighLatency
      resource: deployment/redis-cache
    - name: issue-memory-pressure-node2
      severity: high
      signalType: MemoryPressure
      resource: node/worker-2

rcaEnrichment:
  dependencyStatus:
    - service: database-svc
      endpointsReady: 3
      endpointsTotal: 3
      healthy: true
    - service: redis-svc
      endpointsReady: 0
      endpointsTotal: 2
      healthy: false
      reason: "Nenhum endpoint pronto"

rcaEnrichment:
  timeCorrelation:
    deploymentChange:
      minutesBefore: 3
      message: "Deploy mudou 3 min antes do incidente"
      correlationStrength: "strong"
    configChange:
      minutesBefore: 12
      message: "ConfigMap atualizado 12 min antes do incidente"
      correlationStrength: "moderate"

rcaEnrichment:
  possibleCauses:
    - rank: 1
      cause: "Nova versão da imagem (v2.4.0) introduziu memory leak"
      confidence: 0.85
      evidence:
        - "Deploy ocorreu 3 min antes do primeiro OOMKilled"
        - "Imagem mudou de v2.3.1 para v2.4.0"
        - "Padrão similar resolvido com rollback há 5 dias"
    - rank: 2
      cause: "Memory limit insuficiente para carga atual"
      confidence: 0.45
      evidence:
        - "Uso de memória crescente nas últimas 2 horas"
        - "Sem mudança recente nos limits"
    - rank: 3
      cause: "Dependência redis-svc degradada causando retry storm"
      confidence: 0.30
      evidence:
        - "redis-svc com 0/2 endpoints prontos"
        - "Correlação temporal fraca"

func (cd *ConvergenceDetector) IsConverged(observations []string) bool {
    if len(observations) < 3 {
        return false
    }
    last3 := observations[len(observations)-3:]
    return last3[0] == last3[1] && last3[1] == last3[2]
}

func (cd *ConvergenceDetector) IsOscillating(observations []string) bool {
    if len(observations) < 4 {
        return false
    }
    last4 := observations[len(observations)-4:]
    // Padrão A→B→A→B
    return last4[0] == last4[2] && last4[1] == last4[3] && last4[0] != last4[1]
}

func (cd *ConvergenceDetector) ShouldStop(
    observations []string,
    startTime time.Time,
    consecutiveFailures int,
) (bool, string) {
    // 1. Convergência
    if cd.IsConverged(observations) {
        return true, "Sistema convergiu (3 observações idênticas)"
    }

    // 2. Oscilação
    if cd.IsOscillating(observations) {
        return true, "Oscilação detectada (padrão A→B→A→B)"
    }

    // 3. Timeout (10 minutos)
    if time.Since(startTime) > 10*time.Minute {
        return true, "Timeout do loop agêntico (10 min)"
    }

    // 4. Falhas consecutivas
    if consecutiveFailures >= 5 {
        return true, "5 falhas consecutivas"
    }

    return false, ""
}

func (cd *ConvergenceDetector) EstimateProgress(
    currentStep int,
    maxSteps int,
    lastObservation string,
    targetState string,
) float64 {
    // Progresso base pelo número de steps
    stepProgress := float64(currentStep) / float64(maxSteps)

    // Ajuste se a observação indica melhoria
    if strings.Contains(lastObservation, "healthy") ||
       strings.Contains(lastObservation, "running") {
        return math.Min(1.0, stepProgress + 0.2)
    }

    return stepProgress
}

# Exemplo de alerta Prometheus
groups:
  - name: decision-engine
    rules:
      - alert: CircuitBreakerOpen
        expr: decision_engine_circuit_breaker_state == 1
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Circuit breaker do motor de decisão aberto"
          description: "3+ falhas de remediação na última hora. Auto-remediação bloqueada."
      - alert: LowPatternMatchRate
        expr: >
          rate(decision_engine_pattern_matches_total[1h])
          / rate(decision_engine_evaluations_total[1h]) < 0.1
        for: 24h
        labels:
          severity: info
        annotations:
          summary: "Baixa taxa de correspondência de padrões"
          description: "Menos de 10% dos incidentes têm padrão conhecido. Considere revisar runbooks."