Negative Banlist Priming

class BanlistOptimizer:
    """Convert banlists to positive principles"""
    
    BAN_CATEGORIES = {
        "uncertainty": {
            "banned_phrases": [
                "I don't know", "I'm not sure", "I can't answer",
                "I'm uncertain", "I have no idea"
            ],
            "positive_principle": "When uncertain: 'Let me find that for you' and look it up."
        },
        "limitations": {
            "banned_phrases": [
                "I can't help", "That's not possible", 
                "There's nothing I can do", "You'll have to call back"
            ],
            "positive_principle": "When blocked: 'Here's what I can do...' and offer an alternative."
        },
        "deflection": {
            "banned_phrases": [
                "That's not my department", "You need to talk to someone else",
                "That's above my pay grade"
            ],
            "positive_principle": "When out of scope: 'Let me connect you with the right team.'"
        },
        "identity": {
            "banned_phrases": [
                "I'm just an AI", "As an AI assistant", 
                "I'm a language model", "I don't have feelings"
            ],
            "positive_principle": "Stay in character. Respond as [persona name] would."
        }
    }
    
    MAX_EXPLICIT_BANS = 5
    
    def analyze_banlist(self, prompt: str) -> dict:
        """Analyze banlist in prompt for anti-patterns"""
        # Find "never say" type patterns
        never_patterns = re.findall(
            r"(?:never|don't|do not) (?:say|mention|use) [\"']([^\"']+)[\"']",
            prompt, 
            re.IGNORECASE
        )
        
        issues = []
        
        if len(never_patterns) > self.MAX_EXPLICIT_BANS:
            issues.append({
                "type": "banlist_too_long",
                "count": len(never_patterns),
                "max": self.MAX_EXPLICIT_BANS,
                "recommendation": "Convert to positive principles"
            })
        
        # Check for competitor names in bans
        # (These will get primed)
        for phrase in never_patterns:
            if any(char.isupper() for char in phrase[1:]):  # Likely proper noun
                issues.append({
                    "type": "proper_noun_in_ban",
                    "phrase": phrase,
                    "recommendation": "Remove from prompt entirely"
                })
        
        return {
            "banned_phrases": never_patterns,
            "count": len(never_patterns),
            "issues": issues,
            "risk_level": self.assess_risk(len(never_patterns))
        }
    
    def assess_risk(self, ban_count: int) -> str:
        if ban_count <= 5:
            return "low"
        elif ban_count <= 20:
            return "medium"
        else:
            return "high"
    
    def convert_to_principles(self, banned_phrases: list) -> list:
        """Convert banned phrases to positive principles"""
        principles = []
        unmatched = []
        
        for phrase in banned_phrases:
            matched = False
            for category, config in self.BAN_CATEGORIES.items():
                if any(bp.lower() in phrase.lower() 
                       for bp in config["banned_phrases"]):
                    if config["positive_principle"] not in principles:
                        principles.append(config["positive_principle"])
                    matched = True
                    break
            
            if not matched:
                unmatched.append(phrase)
        
        return {
            "principles": principles,
            "unmatched_bans": unmatched[:3]  # Keep max 3 explicit bans
        }
    
    def generate_optimized_section(self, original_banlist: list) -> str:
        """Generate optimized prompt section"""
        result = self.convert_to_principles(original_banlist)
        
        output = "## COMMUNICATION GUIDELINES\n\n"
        
        for principle in result["principles"]:
            output += f"- {principle}\n"
        
        if result["unmatched_bans"]:
            output += "\nAvoid: " + ", ".join(result["unmatched_bans"][:3])
        
        return output


class BanlistMonitor:
    """Monitor effectiveness of bans in production"""
    
    def __init__(self, banned_phrases: list):
        self.banned = [p.lower() for p in banned_phrases]
        self.occurrences = []
    
    def check_output(self, output: str, context: dict) -> dict:
        """Check if output contains banned phrases"""
        output_lower = output.lower()
        found = []
        
        for phrase in self.banned:
            if phrase in output_lower:
                found.append(phrase)
                self.occurrences.append({
                    "phrase": phrase,
                    "output": output,
                    "context": context,
                    "timestamp": datetime.now()
                })
        
        return {
            "contains_banned": len(found) > 0,
            "banned_phrases": found
        }
    
    def get_ban_effectiveness(self) -> dict:
        """Analyze how effective bans are"""
        if not self.occurrences:
            return {"effective": True, "occurrences": 0}
        
        # Group by phrase
        by_phrase = {}
        for occ in self.occurrences:
            phrase = occ["phrase"]
            by_phrase[phrase] = by_phrase.get(phrase, 0) + 1
        
        # Identify worst offenders
        sorted_phrases = sorted(
            by_phrase.items(), 
            key=lambda x: x[1], 
            reverse=True
        )
        
        return {
            "effective": len(self.occurrences) < 10,
            "total_occurrences": len(self.occurrences),
            "by_phrase": dict(sorted_phrases[:10]),
            "recommendation": "Convert to positive principles" 
                             if len(self.occurrences) > 5 else "Current approach working"
        }

instructions: |
  ## COMMUNICATION STYLE (use positive principles)
  
  CORRECT APPROACH - Positive principles:
  
  When uncertain: "Let me find that for you" → then look it up
  When blocked: "Here's what I can do..." → offer alternative  
  When out of scope: "Let me connect you to the right team"
  
  Stay in character as [Persona Name].
  
  WRONG APPROACH - Avoid long banlists like: