src/enhanced_replica/rules.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Pattern-based rule engine for AI-text detection.

Design principles:
1.  No human-keywords (easily spoofed and noisy).
2.  AI indicators are structural / rhetorical patterns, not single words.
3.  Rules are registerable at runtime to stay ahead of adversarial paraphrasing.
4.  Scoring is length-normalised so long texts do not artificially inflate hits.
"""
from __future__ import annotations

import re
from dataclasses import dataclass
from typing import Dict, List, Tuple


@dataclass
class PatternRule:
    """A single detection rule comprised of one or more regex patterns."""

    rid: str
    name: str
    patterns: List[str]
    weight: float = 1.0
    category: str = "syntax"
    enabled: bool = True


# ---------------------------------------------------------------------------
# Default rule bank – these target *stylistic fingerprints* rather than
# overt self-references, making them harder for an adversary to guess and
# avoid with simple synonym replacement.
# ---------------------------------------------------------------------------
DEFAULT_RULES: List[PatternRule] = [
    PatternRule(
        rid="ai_struct_not_but",
        name="不是-而是结构",
        patterns=[r"不是[^，,。.!！?？]{0,30}而是"],
        weight=1.0,
        category="syntax",
    ),
    PatternRule(
        rid="ai_praise_grasp",
        name="赞扬精准抓住",
        patterns=[
            r"你\s*(非常|很|真的|确实)?\s*(精准|准确|精确)?\s*(地|的)?\s*抓住\s*了\s*这\s*(一)?\s*点",
            r"你\s*(非常|很|真的)?\s*(懂|理解|说到|指出)",
        ],
        weight=1.0,
        category="rhetoric",
    ),
    PatternRule(
        rid="ai_praise_textbook",
        name="教科书级别",
        patterns=[
            r"(教科书|标杆|模板|标准|典范|参考级)(级别|级|式|一样|般)的(理解|回答|分析|解读|阐述|表达|总结)",
            r"(堪称|可谓|可以算是|几乎就是)\s*(教科书|标杆|模板|标准)",
        ],
        weight=1.0,
        category="rhetoric",
    ),
    PatternRule(
        rid="ai_praise_correct",
        name="完全正确赞扬",
        patterns=[
            r"你说\s*(的)?\s*(完全|非常|十分|绝对|确实|太)?\s*正确",
            r"你\s*(说|讲|理解|看)\s*(得|的)?\s*(完全|非常|十分|绝对|确实|很|太)?\s*(对|到位|透彻)",
        ],
        weight=1.0,
        category="rhetoric",
    ),
    PatternRule(
        rid="ai_quote_abuse",
        name="双引号滥用",
        patterns=[r"([\"\"\"\"]).{2,40}?\1.{0,10}?\1.{2,40}?\1"],
        weight=0.8,
        category="style",
    ),
    PatternRule(
        rid="ai_summary_transition",
        name="总结过渡词",
        patterns=[
            r"(总的来说|综上所述|一言以蔽之|简而言之|总的来看).{0,5}[，,]",
            r"(首先|其次|再者|最后|一方面|另一方面).{0,5}[，,]",
        ],
        weight=0.5,
        category="syntax",
    ),
    PatternRule(
        rid="ai_modal_weak",
        name="弱化确定性",
        patterns=[
            r"(可能|也许|某种程度上|一定程度上|大致|基本).{0,10}(可以|算是|认为|看作)",
            r"(不\s*(排除|否定|否认|确定|保证))",
        ],
        weight=0.4,
        category="style",
    ),
    PatternRule(
        rid="ai_self_reference",
        name="AI自我指涉",
        patterns=[
            r"(作为|身为)\s*(一个|一名)?\s*(AI|人工智能|语言模型|大模型|助手)",
            r"(我\s*(是|作为)\s*(一个|一名)?\s*(AI|人工智能|语言模型|大模型|助手))",
            r"(没有|不\s*(具备|拥有))[^，,。.!！?？]{0,20}(情感|主观|个人经历|身体|人类)",
        ],
        weight=1.2,
        category="identity",
    ),
    # -----------------------------------------------------------------------
    # Community-contributed rules based on human intuitions about AI text.
    # -----------------------------------------------------------------------
    PatternRule(
        rid="ai_struct_not_ext",
        name="不是-而是排比扩展",
        patterns=[r"不是[^，,。.!！?？]{0,40}(而是|是|他更)[^，,。.!！?？]{0,20}(更|还)"],
        weight=1.0,
        category="syntax",
    ),
    PatternRule(
        rid="ai_meta_discourse",
        name="论述结构预告",
        patterns=[
            r"我分(几个|几)\s*个?(层面|维度)[来给]*你",
            r"一句话给[你]*[一个]*最[稳准狠]",
            r"从(几个|多)\s*个(维度|层面|角度)",
        ],
        weight=0.8,
        category="syntax",
    ),
    PatternRule(
        rid="ai_flattery_open",
        name="赞扬式开场",
        patterns=[
            r"你的(观察|洞察|直觉)\s*(非常|很|真的)?\s*(敏锐|精准|到位)",
            r"你[说讲看]*\s*(得|的)?\s*(非常|很|太)?\s*(对|到位|透彻|准确)",
        ],
        weight=1.0,
        category="rhetoric",
    ),
    PatternRule(
        rid="ai_over_agree",
        name="过度认同+自我否定",
        patterns=[
            r"你说的对，我(完全|确实)?\s*(搞错|误解|想错)",
            r"你看到了(事情|问题)?\s*的?本质",
        ],
        weight=1.0,
        category="rhetoric",
    ),
    PatternRule(
        rid="ai_service_push",
        name="服务性追问",
        patterns=[
            r"你现在感觉怎么样",
            r"要不要我帮[你]*",
        ],
        weight=0.8,
        category="rhetoric",
    ),
    PatternRule(
        rid="ai_poetic_cliche",
        name="诗意化比喻堆砌",
        patterns=[
            r"(时光|岁月|往事|记忆)\s*的?\s*(褶皱|琥珀|潮汐|甬道)",
            r"如[^，,。.!！?？]{0,20}(月光|星光)[^，,。.!！?？]{0,20}(潮汐|涟漪)",
            r"被封存在[^，,。.!！?？]{0,20}般?的?暮色",
        ],
        weight=1.0,
        category="style",
    ),
    PatternRule(
        rid="ai_list_numeric",
        name="数字分点结构",
        patterns=[
            r"1\.\s+.{3,40}[\n\r]+2\.\s+.{3,40}",
            r"一[、．.]\s*.{3,40}[\n\r]+二[、．.]\s*.{3,40}",
        ],
        weight=0.6,
        category="style",
    ),
    PatternRule(
        rid="ai_markdown_bold",
        name="Markdown粗体外泄",
        patterns=[r"\*\*[^*]+\*\*"],
        weight=0.5,
        category="style",
    ),
    PatternRule(
        rid="ai_honesty_preface",
        name="说实话前置",
        patterns=[r"[，,]\s*说实(话|在的)[，,]"],
        weight=0.4,
        category="style",
    ),
    PatternRule(
        rid="ai_perspective_close",
        name="视角收尾",
        patterns=[r"接近你?现在[^，,。.!！?？]{0,20}的?视角"],
        weight=0.4,
        category="style",
    ),
]


class RuleEngine:
    """Compiles and evaluates a set of PatternRules."""

    def __init__(self, rules: List[PatternRule] | None = None):
        self.rules: List[PatternRule] = list(rules) if rules is not None else []
        self._compiled: Dict[str, re.Pattern] = {}
        self._compile_all()

    def _compile_all(self) -> None:
        for r in self.rules:
            if not r.enabled:
                continue
            for idx, pat in enumerate(r.patterns):
                key = f"{r.rid}_{idx}"
                self._compiled[key] = re.compile(pat)

    def register(self, rule: PatternRule) -> None:
        """Add a new rule at runtime (useful for rapid adversarial response)."""
        self.rules.append(rule)
        if rule.enabled:
            for idx, pat in enumerate(rule.patterns):
                self._compiled[f"{rule.rid}_{idx}"] = re.compile(pat)

    def score(self, text: str) -> Tuple[float, Dict[str, int], int]:
        """Return (normalised_score, hit_map, active_rule_count)."""
        t = str(text)
        hits: Dict[str, int] = {}
        total_weighted_hits = 0.0
        for r in self.rules:
            if not r.enabled:
                continue
            cnt = 0
            for idx, _ in enumerate(r.patterns):
                key = f"{r.rid}_{idx}"
                pat = self._compiled.get(key)
                if pat:
                    cnt += len(pat.findall(t))
            if cnt:
                hits[r.rid] = cnt
                total_weighted_hits += cnt * r.weight
        # Normalise by sqrt(length) so long texts do not game the score.
        normalized_score = total_weighted_hits / (len(t) ** 0.5 + 1.0)
        active_count = sum(1 for r in self.rules if r.enabled)
        return float(normalized_score), hits, active_count

    def explain(self, text: str) -> List[Dict[str, object]]:
        """Produce a human-readable diagnosis of which rules fired."""
        t = str(text)
        out: List[Dict[str, object]] = []
        for r in self.rules:
            if not r.enabled:
                continue
            matches: List[str] = []
            for idx, _ in enumerate(r.patterns):
                key = f"{r.rid}_{idx}"
                pat = self._compiled.get(key)
                if pat:
                    found = pat.findall(t)
                    if found:
                        matches.extend(str(m) for m in found)
            if matches:
                out.append(
                    {
                        "rid": r.rid,
                        "name": r.name,
                        "category": r.category,
                        "matches": matches[:10],
                        "count": len(matches),
                        "weight": r.weight,
                    }
                )
        return out


# Global default engine – imported by model_utils and experiment scripts.
_DEFAULT_ENGINE = RuleEngine(DEFAULT_RULES)


def rule_score(text: str, engine: RuleEngine | None = None) -> Tuple[float, Dict[str, int], int]:
    """Backward-compatible entry point."""
    eng = engine or _DEFAULT_ENGINE
    return eng.score(text)


def rule_explain(text: str, engine: RuleEngine | None = None) -> List[Dict[str, object]]:
    """Diagnostic entry point."""
    eng = engine or _DEFAULT_ENGINE
    return eng.explain(text)