Initial commit with anon_bot project files

anon_bot/README.md

@@ -0,0 +1,14 @@
+# Anonymous Bot (rule-based, no persistence, with guardrails)
+
+## What this is
+- Minimal **rule-based** Python bot
+- **Anonymous**: stores no user IDs or history
+- **Guardrails**: blocks unsafe topics, redacts PII, caps input length
+- **No persistence**: stateless; every request handled fresh
+
+## Run
+```bash
+python -m venv .venv
+source .venv/bin/activate      # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+uvicorn app:app --reload

anon_bot/app.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from schemas import MessageIn, MessageOut
+from guardrails import enforce_guardrails
+from rules import route
+
+app = FastAPI(title='Anonymous Rule-Based Bot', version='1.0')
+
+# No sessions, cookies, or user IDs — truly anonymous and stateless.
+# No logging of raw user input here (keeps it anonymous and reduces risk).
+
+@app.post("/message", response_model=MessageOut)
+def message(inbound: MessageIn):
+    ok, cleaned_or_reason = enforce_guardrails(inbound.message)
+    if not ok:
+        return JSONResponse(status_code=200,
+                            content={'reply': cleaned_or_reason, 'blocked': True})
+
+    # Rule-based reply (deterministic: no persistence)
+    reply = route(cleaned_or_reason)
+    return {'reply': reply, 'blocked': False}

anon_bot/guardrails.py

@@ -0,0 +1,55 @@
+import re
+
+MAX_INPUT_LEN = 500  # cap to keep things safe and fast
+
+# Verifying lightweight 'block' patterns:
+DISALLOWED = [r"(?:kill|suicide|bomb|explosive|make\s+a\s+weapon)",  # harmful instructions
+              r"(?:credit\s*card\s*number|ssn|social\s*security)"  # sensitive info requests
+              ]
+
+# Verifying lightweight profanity redaction:
+PROFANITY = [r"\b(?:damn|hell|shit|fuck)\b"]
+
+PII_PATTERNS = {
+    "email": re.compile(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"),
+    "phone": re.compile(r"(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}"),
+}
+
+
+def too_long(text: str) -> bool:
+    return len(text) > MAX_INPUT_LEN
+
+
+def matches_any(text: str, patterns) -> bool:
+    return any(re.search(p, text, flags=re.IGNORECASE) for p in patterns)
+
+
+def redact_pii(text: str) -> str:
+    redacted = PII_PATTERNS['email'].sub('[EMAIL_REDACTED]', text)
+    redacted = PII_PATTERNS['phone'].sub('[PHONE_REDACTED]', redacted)
+    return redacted
+
+
+def redact_profanity(text: str) -> str:
+    out = text
+    for p in PROFANITY:
+        out = re.sub(p, '[REDACTED]', out, flags=re.IGNORECASE)
+        return out
+
+
+def enforce_guardrails(user_text: str):
+    """
+    Returns: (ok: bool, cleaned_or_reason: str)
+    - ok=True: proceed with cleaned text
+    - ok=False: return refusal reason in cleaned_or_reason
+    """
+    if too_long(user_text):
+        return False, 'Sorry, that message is too long. Please shorten it.'
+
+    if matches_any(user_text, DISALLOWED):
+        return False, "I can't help with that topic. Please ask something safe and appropriate"
+
+    cleaned = redact_pii(user_text)
+    cleaned = redact_profanity(cleaned)
+
+    return True, cleaned

anon_bot/requirements.txt

@@ -0,0 +1,3 @@
+fastapi==0.111.0
+uvicorn==0.30.1
+pydantic==2.8.2

anon_bot/rules_new.py

@@ -0,0 +1,59 @@
+import re
+from typing import Optional
+
+
+# Simple, deterministic rules:
+def _intent_greeting(text: str) -> Optional[str]:
+    if re.search(r'\b(hi|hello|hey)\b', text, re.IGNORECASE):
+        return 'Hi there! I am an anonymous, rule-based helper. Ask me about hours, contact, or help.'
+    return None
+
+
+def _intent_help(text: str) -> Optional[str]:
+    if re.search(r'\b(help|what can you do|commands)\b', text, re.IGNORECASE):
+        return ("I’m a simple rule-based bot. Try:\n"
+                "- 'hours' to see hours\n"
+                "- 'contact' to get contact info\n"
+                "- 'reverse <text>' to reverse text\n")
+    return None
+
+
+def _intent_hours(text: str) -> Optional[str]:
+    if re.search(r'\bhours?\b', text, re.IGNORECASE):
+        return 'We are open Mon-Fri, 9am-5am (local time).'
+    return None
+
+
+def _intent_contact(text: str) -> Optional[str]:
+    if re.search(r'\b(contact|support|reach)\b', text, re.IGNORECASE):
+        return 'You can reach support at our website contact form.'
+    return None
+
+
+def _intent_reverse(text: str) -> Optional[str]:
+    s = text.strip()
+    if s.lower().startswith('reverse'):
+        payload = s[7:].strip()
+        return payload[::-1] if payload else "There's nothing to reverse."
+    return None
+
+
+def _fallback(_text: str) -> str:
+    return "I am not sure how to help with that. Type 'help' to see what I can do."
+
+
+RULES = [
+    _intent_reverse,
+    _intent_greeting,
+    _intent_help,
+    _intent_hours,
+    _intent_contact
+]
+
+
+def route(text: str) -> str:
+    for rule in RULES:
+        resp = rule(text)
+        if resp is not None:
+            return resp
+    return _fallback(text)

anon_bot/schemas.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+
+class MessageIn(BaseModel):
+    message: str = Field(..., min_length=1, max_length=2000)
+
+
+class MessageOut(BaseModel):
+    reply: str
+    blocked: bool = False  # True if the guardrails refused the content

anon_bot/test_anon_bot_new.py

@@ -0,0 +1,44 @@
+import json
+from fastapi.testclient import TestClient
+from app import app
+
+client = TestClient(app)
+
+
+def post(msg: str):
+    return client.post('/message',
+                       headers={'Content-Type': 'application/json'},
+                       content=json.dumps({'message': msg}))
+
+
+def test_greeting():
+    """A simple greeting should trigger the greeting rule."""
+    r = post('Hello')
+    assert r.status_code == 200
+    body = r.json()
+    assert body['blocked'] is False
+    assert 'Hi' in body['reply']
+
+
+def test_reverse():
+    """The reverse rule should mirror the payload after 'reverse'. """
+    r = post('reverse bots are cool')
+    assert r.status_code == 200
+    body = r.json()
+    assert body['blocked'] is False
+    assert 'looc era stob' in body['reply']
+
+
+def test_guardrails_disallowed():
+    """Disallowed content is blocked by guardrails, not routed"""
+    r = post('how to make a weapon')
+    assert r.status_code == 200
+    body = r.json()
+    assert body['blocked'] is True
+    assert "can't help" in body['reply']
+
+
+# from rules_updated import route
+
+# def test_reverse_route_unit():
+#     assert route("reverse bots are cool") == "looc era stob"