feat(ai): Copilot 基因化 Phase 0 Task 1-4 — 迁移 + Entity + 规则引擎

- 4 表迁移: copilot_rules, copilot_insights, copilot_risk_snapshots, copilot_chat_logs
- 4 个 SeaORM Entity 对应新表
- JSONLogic 规则引擎 (evaluate + evaluate_rules) + 5 个单元测试

crates/erp-ai/src/copilot/mod.rs

@@ -0,0 +1 @@
+pub mod rules;

crates/erp-ai/src/copilot/rules.rs

@@ -0,0 +1,201 @@
+use serde_json::Value;
+
+/// 评估 JSONLogic 表达式，支持子集：> >= < <= == != and or ! in var
+/// 对畸形规则表达式返回 false 而非 panic（规则存储在数据库中，不应导致服务崩溃）
+pub fn evaluate(expr: &Value, data: &Value) -> bool {
+    match expr {
+        Value::Object(map) => {
+            if let Some(op) = map.get(">") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let a = resolve_value(&args[0], data);
+                let b = resolve_value(&args[1], data);
+                return compare_f64(&a, &b) == std::cmp::Ordering::Greater;
+            }
+            if let Some(op) = map.get(">=") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let a = resolve_value(&args[0], data);
+                let b = resolve_value(&args[1], data);
+                return matches!(
+                    compare_f64(&a, &b),
+                    std::cmp::Ordering::Greater | std::cmp::Ordering::Equal
+                );
+            }
+            if let Some(op) = map.get("<") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let a = resolve_value(&args[0], data);
+                let b = resolve_value(&args[1], data);
+                return compare_f64(&a, &b) == std::cmp::Ordering::Less;
+            }
+            if let Some(op) = map.get("<=") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let a = resolve_value(&args[0], data);
+                let b = resolve_value(&args[1], data);
+                return matches!(
+                    compare_f64(&a, &b),
+                    std::cmp::Ordering::Less | std::cmp::Ordering::Equal
+                );
+            }
+            if let Some(op) = map.get("==") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let a = resolve_value(&args[0], data);
+                let b = resolve_value(&args[1], data);
+                return a == b;
+            }
+            if let Some(op) = map.get("!=") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let a = resolve_value(&args[0], data);
+                let b = resolve_value(&args[1], data);
+                return a != b;
+            }
+            if let Some(op) = map.get("and") {
+                return match op.as_array() {
+                    Some(arr) => arr.iter().all(|e| evaluate(e, data)),
+                    None => false,
+                };
+            }
+            if let Some(op) = map.get("or") {
+                return match op.as_array() {
+                    Some(arr) => arr.iter().any(|e| evaluate(e, data)),
+                    None => false,
+                };
+            }
+            if let Some(op) = map.get("!") {
+                return !evaluate(op, data);
+            }
+            if let Some(op) = map.get("in") {
+                let args = match op.as_array() {
+                    Some(a) if a.len() == 2 => a,
+                    _ => return false,
+                };
+                let val = resolve_value(&args[0], data);
+                let collection = resolve_value(&args[1], data);
+                return match collection.as_array() {
+                    Some(arr) => arr.contains(&val),
+                    None => false,
+                };
+            }
+            false
+        }
+        Value::Bool(b) => *b,
+        _ => false,
+    }
+}
+
+/// 解析 {"var": "path.to.field"} 引用，支持点分路径
+fn resolve_value(expr: &Value, data: &Value) -> Value {
+    if let Value::Object(map) = expr
+        && let Some(var_path) = map.get("var").and_then(|v| v.as_str())
+    {
+        return var_path.split('.').fold(data.clone(), |acc, key| {
+            acc.get(key).cloned().unwrap_or(Value::Null)
+        });
+    }
+    expr.clone()
+}
+
+fn compare_f64(a: &Value, b: &Value) -> std::cmp::Ordering {
+    let a_num = value_to_f64(a);
+    let b_num = value_to_f64(b);
+    a_num
+        .partial_cmp(&b_num)
+        .unwrap_or(std::cmp::Ordering::Equal)
+}
+
+fn value_to_f64(v: &Value) -> f64 {
+    v.as_f64()
+        .or_else(|| v.as_i64().map(|n| n as f64))
+        .unwrap_or(0.0)
+}
+
+/// 规则数据：(id, name, condition_expr, score, severity, suggestion)
+pub type RuleData = (
+    uuid::Uuid,
+    String,
+    serde_json::Value,
+    i16,
+    String,
+    Option<String>,
+);
+
+/// 匹配结果：(id, name, score, severity, suggestion)
+pub type MatchedRuleData = (uuid::Uuid, String, i16, String, Option<String>);
+
+/// 对患者数据评估所有启用的规则，返回匹配的规则和总分
+pub fn evaluate_rules(rules: &[RuleData], patient_data: &Value) -> Vec<MatchedRuleData> {
+    rules
+        .iter()
+        .filter(|(_, _, cond, _, _, _)| evaluate(cond, patient_data))
+        .map(|(id, name, _, score, severity, suggestion)| {
+            (
+                *id,
+                name.clone(),
+                *score,
+                severity.clone(),
+                suggestion.clone(),
+            )
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_simple_comparison_gt() {
+        let expr = serde_json::json!({ ">": [{"var": "systolic"}, 140] });
+        let data = serde_json::json!({"systolic": 155});
+        assert!(evaluate(&expr, &data));
+    }
+
+    #[test]
+    fn test_simple_comparison_lt() {
+        let expr = serde_json::json!({ "<": [{"var": "egfr"}, 60] });
+        let data = serde_json::json!({"egfr": 45});
+        assert!(evaluate(&expr, &data));
+    }
+
+    #[test]
+    fn test_and_combination() {
+        let expr = serde_json::json!({
+            "and": [
+                { ">=": [{"var": "systolic.prev1"}, 140] },
+                { ">=": [{"var": "systolic.prev2"}, 140] }
+            ]
+        });
+        let data = serde_json::json!({"systolic": {"prev1": 145, "prev2": 150}});
+        assert!(evaluate(&expr, &data));
+    }
+
+    #[test]
+    fn test_change_pct() {
+        let expr = serde_json::json!({ ">": [{"var": "creatinine.change_pct"}, 20] });
+        let data = serde_json::json!({"creatinine": {"change_pct": 25}});
+        assert!(evaluate(&expr, &data));
+    }
+
+    #[test]
+    fn test_not_matching() {
+        let expr = serde_json::json!({ "<": [{"var": "egfr"}, 60] });
+        let data = serde_json::json!({"egfr": 75});
+        assert!(!evaluate(&expr, &data));
+    }
+}