feat: Add a fact-checking module that extracts and verifies numeric and phrase claims and analyzes bias.

check_article.py

@@ -200,7 +200,7 @@ def get_user_input():
             empty_count = 0
             lines.append(line)
 
-    return " ".join(lines).strip()
+    return "\n".join(lines).strip()
 
 
 def display_results(result):
@@ -427,7 +427,41 @@ def display_results(result):
                 print(f"    {word:<20} [{bar}]  {weight:.3f}")
             print()
 
-    # 7. Final Verdict
+    # 7. Claim Verification
+    claim_verification = result.get("claim_verification", [])
+    if claim_verification:
+        print("=" * 60)
+        print("  CLAIM VERIFICATION — Per-Claim Check")
+        print("=" * 60)
+        numeric = [cv for cv in claim_verification if cv.get("type") == "numeric"]
+        phrase = [cv for cv in claim_verification if cv.get("type") == "phrase"]
+        VERDICT_ICONS = {"CONFIRMED": "✅", "UNVERIFIED": "⚠️ ", "CONTRADICTED": "❌"}
+
+        if numeric:
+            print(f"  Numeric claims ({len(numeric)}):\n")
+            for cv in numeric:
+                icon = VERDICT_ICONS.get(cv["verdict"], "?")
+                claimed_str = f"{cv['claimed']:,}"
+                found_note = ""
+                if cv["verdict"] == "CONFIRMED" and cv.get("found"):
+                    found_note = f" (source says: {cv['found']:,})"
+                elif cv["verdict"] == "CONTRADICTED" and cv.get("found"):
+                    found_note = f" (source says: {cv['found']:,} instead)"
+                print(f"  {icon} {cv['entity']}: claimed {claimed_str}{found_note}")
+                if cv.get("source"):
+                    print(f"      ↳ {cv['source'][:80]}")
+            print()
+
+        if phrase:
+            print(f"  Phrase claims ({len(phrase)}):\n")
+            for cv in phrase:
+                icon = VERDICT_ICONS.get(cv["verdict"], "?")
+                print(f"  {icon} \"{cv['claim_text']}\"")
+                if cv.get("source"):
+                    print(f"      ↳ {cv['source'][:80]}")
+            print()
+
+    # 8. Final Verdict
     print("=" * 60)
     print(f"  FINAL VERDICT: {final_verdict}")
     if article_date:

checker/external/claim_verifier.py

@@ -0,0 +1,642 @@
+"""Lightweight Claim Verifier
+==============================
+Two modes of claim extraction + verification:
+
+1. NUMERIC CLAIMS  — "Philippines: 299 citizens", "Australia (1,300)"
+   Extracts entity + number pairs from list-format articles and verifies
+   the number against Google News search results.
+
+2. PHRASE CLAIMS   — "BBM natagpuang nagshashabu", "VP arrested"
+   Extracts subject + predicate claims from prose and checks whether
+   Google News supports, contradicts, or cannot verify them.
+
+No new models or paid APIs — fully reuses search_google_news().
+"""
+
+import re
+from checker.external.web_search import search_google_news
+
+
+# ── Shared constants ──────────────────────────────────────────────────────────
+
+# Known political/government acronyms and short names to SKIP as numeric claim entities
+# (they're real names but make bad "amount" entities like "BBM 31" or "PRRD 5219")
+_SKIP_ENTITIES = {
+    # Philippine political figures
+    "BBM",
+    "PRRD",
+    "Duterte",
+    "Marcos",
+    "Sara",
+    "Leni",
+    "Robredo",
+    "Aquino",
+    "Arroyo",
+    "Estrada",
+    "Ramos",
+    "Lacson",
+    "Pacquiao",
+    # Government bodies
+    "PNP",
+    "AFP",
+    "DOH",
+    "DOJ",
+    "COMELEC",
+    "CHR",
+    "DSWD",
+    "CHED",
+    "DEPED",
+    "BIR",
+    "BSP",
+    "SEC",
+    "LTO",
+    "LTFRB",
+    "MMDA",
+    "NBI",
+    "PSA",
+    "OVP",
+    "ICC",
+    "EJK",
+    "DDS",
+    "SWS",
+    "PCSO",
+    "PAGCOR",
+    # Common English words that pass capitalization but are not entities
+    "They",
+    "Their",
+    "We",
+    "Our",
+    "Its",
+    "One",
+    "Two",
+    "Three",
+    "Four",
+    "Five",
+    "Six",
+    "Seven",
+    "Eight",
+    "Nine",
+    "Ten",
+    "While",
+    "After",
+    "Before",
+    "During",
+    "Despite",
+    "When",
+    "Yes",
+    "No",
+    "Some",
+    "But",
+    "For",
+    "And",
+    "The",
+    "With",
+    "From",
+    "Also",
+    "Just",
+    "Over",
+    "Into",
+    "Being",
+    # Month / day names (e.g. "March 9" should not become March:9)
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
+    # Action/gerund words occasionally capitalized
+    "Chartering",
+    "Carrying",
+    "Bringing",
+    "Taking",
+    "Sending",
+    # Flight / registry prefixes
+    "PR",
+    "RP",
+    "VP",
+    "UN",
+    "US",
+    "EU",
+    "UK",
+    "PH",
+}
+
+# Minimum character length for a valid numeric-claim entity
+_MIN_ENTITY_LEN = 4
+
+# Filler stop words for search query building
+_STOP = {
+    "the",
+    "and",
+    "for",
+    "that",
+    "this",
+    "with",
+    "from",
+    "are",
+    "was",
+    "were",
+    "been",
+    "has",
+    "have",
+    "had",
+    "but",
+    "not",
+    "its",
+    "his",
+    "her",
+    "they",
+    "them",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "can",
+    "who",
+    "which",
+    "what",
+    "when",
+    "where",
+    "how",
+    "all",
+    "each",
+    "than",
+    "then",
+    "too",
+    "very",
+    "just",
+    "about",
+    "over",
+    "after",
+    "before",
+    "also",
+    "into",
+    "out",
+    "being",
+    "any",
+    "more",
+    "some",
+    "only",
+    "other",
+    "now",
+    "our",
+    "your",
+    "their",
+    "said",
+    "says",
+    "Yes",
+    "No",
+    "Some",
+}
+
+
+# ── Numeric claim extraction ──────────────────────────────────────────────────
+
+_NUMBER_RE = re.compile(
+    r"(?:"
+    r"(?P<k>\d[\d,]*)\s*[kK]"  # e.g. "10k" or "10K"
+    r"|"
+    r"(?P<n>\d[\d,]*)"  # e.g. "1,300" or "299" — must start with a digit
+    r")"
+)
+
+_ENTITY_RE = re.compile(r"\b([A-Z][a-zA-Z]+(?: [A-Z][a-zA-Z]+)*)\b")
+
+# Minimum character length for a valid numeric-claim entity
+_MIN_ENTITY_LEN = 4
+
+# Currency symbol characters — numbers immediately after these are costs, not counts
+_CURRENCY_CHARS = "₱$€£¥"
+
+# Regex to detect whether text looks like a numbered list (at least 3 list items)
+_LIST_MARKER_RE = re.compile(r"""(?m)^\s*\d+[.):]\s+[A-Z]""", re.MULTILINE)
+
+
+def _is_list_article(text: str) -> bool:
+    """Return True when text contains ≥3 numbered list items — a sign it's a structured list."""
+    return len(_LIST_MARKER_RE.findall(text)) >= 3
+
+
+# Regex to strip leading list markers like "1." "2)" "12." from a line
+_LIST_PREFIX_RE = re.compile(r"^\d+[.):]\s*")
+
+
+def _parse_number(match) -> int | None:
+    """Convert a _NUMBER_RE match to int. Returns None on bad input."""
+    if match.group("k"):
+        raw = match.group("k").replace(",", "")
+    else:
+        raw = (match.group("n") or "").replace(",", "")
+    if not raw.isdigit():
+        return None
+    return int(raw) * (1000 if match.group("k") else 1)
+
+
+# Numbers that are clearly not counts
+_MAX_PLAUSIBLE_COUNT = 10_000_000
+_MIN_PLAUSIBLE_COUNT = 2
+
+
+def extract_numeric_claims(text: str) -> list[dict]:
+    """Extract (entity, number) factual claims from list-format articles.
+
+    Only runs on list-format text (detected by numbered markers like 1. 2. 3.).
+    For prose articles, returns [] immediately to avoid false positives.
+
+    Key filters applied:
+    - Strips list-marker prefixes ("1.", "2)") so they aren't counted as numbers
+    - Skips numbers preceded by currency symbols (₱, $, €)
+    - Skips numbers from "N-day" / "N-year" patterns
+    - Skips 4-digit non-comma numbers (serial/flight codes)
+    - Skips years (1800-2100)
+    - Tight proximity (≤ 80 chars) between entity and number
+
+    Returns list of {"entity", "number", "context"} dicts.
+    """
+    # Only process list-format articles
+    if not _is_list_article(text):
+        return []
+
+    claims: list[dict] = []
+    seen: set[tuple] = set()
+
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        # Strip leading list marker so "2. Bangladesh" doesn't yield number 2
+        line = _LIST_PREFIX_RE.sub("", line)
+
+        for num_match in _NUMBER_RE.finditer(line):
+            number = _parse_number(num_match)
+            if number is None:
+                continue
+            # Skip implausible counts
+            if number < _MIN_PLAUSIBLE_COUNT or number > _MAX_PLAUSIBLE_COUNT:
+                continue
+            # Skip years
+            if 1800 <= number <= 2100:
+                continue
+            # Skip 4-digit numbers without commas (likely serial/flight codes)
+            if 1000 <= number <= 9999 and "," not in num_match.group():
+                continue
+            # Skip numbers immediately preceded by a currency symbol
+            num_start = num_match.start()
+            if num_start > 0 and line[num_start - 1] in _CURRENCY_CHARS:
+                continue
+            # Skip numbers that are part of "N-day", "N-year", "N-hour" patterns
+            num_end = num_match.end()
+            if num_end < len(line) and line[num_end] == "-":
+                continue
+
+            num_pos = num_match.start()
+            best_entity = None
+            best_dist = float("inf")
+
+            for ent_match in _ENTITY_RE.finditer(line):
+                entity = ent_match.group(1)
+                if entity in _SKIP_ENTITIES or len(entity) < _MIN_ENTITY_LEN:
+                    continue
+                # Skip all-caps single words that look like acronyms
+                if entity.isupper() and len(entity) <= 6:
+                    continue
+                # Skip multi-word entities where any component is a skip word
+                if any(w in _SKIP_ENTITIES for w in entity.split()):
+                    continue
+                dist = abs(ent_match.start() - num_pos)
+                if dist < best_dist:
+                    best_dist = dist
+                    best_entity = entity
+
+            # Tighter proximity (80 chars) to avoid cross-item contamination
+            if best_entity and best_dist <= 80:
+                key = (best_entity.lower(), number)
+                if key not in seen:
+                    seen.add(key)
+                    claims.append(
+                        {"entity": best_entity, "number": number, "context": line}
+                    )
+
+    return claims
+
+
+# ── Phrase claim extraction ───────────────────────────────────────────────────
+
+# Subject indicators for phrase claims: names/proper nouns before an action verb
+# e.g. "BBM natagpuan", "VP arrested", "Marcos nagresign"
+_PHRASE_SUBJECT_RE = re.compile(
+    r"(?:"
+    r"([A-Z][a-zA-Z]{2,}(?:\s+[A-Z][a-zA-Z]{2,})?)"  # Proper name, e.g. "Claire Castro"
+    r"|"
+    r"([A-Z]{2,6})"  # Acronym subject, e.g. "BBM", "VP", "PRRD"
+    r")"
+)
+
+# Action/predicate keywords that signal a factual claim worth verifying
+_PREDICATE_SIGNALS = [
+    # Filipino
+    "natagpuan",
+    "nahuli",
+    "napatay",
+    "naaksidente",
+    "nagresign",
+    "nagbitiw",
+    "naaresto",
+    "inaresto",
+    "nakulong",
+    "naiwanan",
+    "nahulog",
+    "nadiskubre",
+    "nag-amin",
+    "umamin",
+    "sinabi",
+    "idineklara",
+    "inihayag",
+    "ipinag-utos",
+    "nagpunta",
+    "pumunta",
+    "namatay",
+    "nasugatan",
+    "nabiktima",
+    "nagtakas",
+    "tumakas",
+    "nagnanakaw",
+    "nagnakaw",
+    "nagshabu",
+    "nagshashabu",
+    "sumusuporta",
+    "sumuporta",
+    "nagpapatay",
+    "nagpapatunay",
+    "nagpaliwanag",
+    "nagsabi",
+    "nagsalita",
+    "nagbitiw",
+    "natanggal",
+    "tinanggal",
+    # English
+    "arrested",
+    "killed",
+    "fired",
+    "resigned",
+    "fled",
+    "admitted",
+    "denied",
+    "confirmed",
+    "announced",
+    "signed",
+    "ordered",
+    "suspended",
+    "indicted",
+    "charged",
+    "convicted",
+    "acquitted",
+    "appointed",
+    "promoted",
+    "demoted",
+    "caught",
+    "found",
+    "discovered",
+    "revealed",
+    "exposed",
+    "accused",
+]
+
+
+def extract_phrase_claims(text: str) -> list[dict]:
+    """Extract subject + predicate phrase claims from prose text.
+
+    Detects patterns like:
+        "BBM natagpuang nagshashabu"
+        "VP arrested at NAIA"
+        "Claire Castro nagresign"
+
+    Returns list of {"subject", "predicate", "claim_text", "context"} dicts.
+    """
+    claims: list[dict] = []
+    seen: set[str] = set()
+    text_lower = text.lower()
+
+    for pred in _PREDICATE_SIGNALS:
+        # Find all occurrences of this predicate in the text
+        for m in re.finditer(re.escape(pred), text_lower):
+            pred_pos = m.start()
+
+            # Look for a subject (proper noun or acronym) within 60 chars before the predicate
+            window_start = max(0, pred_pos - 60)
+            window = text[window_start:pred_pos]
+
+            # Find the closest proper noun/acronym to the predicate
+            best_subject = None
+            for sm in _PHRASE_SUBJECT_RE.finditer(window):
+                candidate = sm.group(1) or sm.group(2)
+                if candidate and candidate not in _STOP and len(candidate) >= 2:
+                    best_subject = candidate  # keep the last one (closest to predicate)
+
+            if best_subject:
+                # Get context line
+                line_start = text.rfind("\n", 0, pred_pos) + 1
+                line_end = text.find("\n", pred_pos)
+                context = text[
+                    line_start : line_end if line_end != -1 else len(text)
+                ].strip()
+
+                # Build the claim string for display and searching
+                claim_text = f"{best_subject} {pred}"
+                key = claim_text.lower()
+                if key not in seen:
+                    seen.add(key)
+                    claims.append(
+                        {
+                            "subject": best_subject,
+                            "predicate": pred,
+                            "claim_text": claim_text,
+                            "context": context,
+                        }
+                    )
+
+    return claims
+
+
+# ── Verification ──────────────────────────────────────────────────────────────
+
+
+def _numbers_in_text(text: str) -> list[int]:
+    """Pull all integer counts from a string (skips years)."""
+    nums = []
+    for m in _NUMBER_RE.finditer(text):
+        n = _parse_number(m)
+        if n is None:
+            continue
+        if 1800 <= n <= 2100:
+            continue
+        nums.append(n)
+    return nums
+
+
+def _numbers_close(a: int, b: int, tolerance: float = 0.15) -> bool:
+    if max(a, b) == 0:
+        return True
+    return abs(a - b) / max(a, b) <= tolerance
+
+
+def verify_numeric_claims(
+    claims: list[dict],
+    topic_context: str = "",
+    max_results: int = 3,
+) -> list[dict]:
+    """Verify numeric claims against Google News.
+
+    Returns list of {"entity", "claimed", "verdict", "found", "source"} dicts.
+    Verdict: "CONFIRMED" | "UNVERIFIED" | "CONTRADICTED"
+    """
+    results = []
+    for claim in claims:
+        entity = claim["entity"]
+        claimed = claim["number"]
+
+        context_words = [
+            w for w in topic_context.split() if w.lower() not in _STOP and len(w) > 2
+        ]
+        query = f"{entity} {' '.join(context_words[:6])}".strip()
+
+        articles = search_google_news(query, max_results=max_results)
+
+        verdict = "UNVERIFIED"
+        found_number: int | None = None
+        source_headline = ""
+
+        for article in articles:
+            headline = article.get("title", "")
+            all_nums = _numbers_in_text(headline)
+            for n in all_nums:
+                if _numbers_close(claimed, n):
+                    verdict = "CONFIRMED"
+                    found_number = n
+                    source_headline = headline
+                    break
+                elif verdict != "CONFIRMED":
+                    verdict = "CONTRADICTED"
+                    found_number = n
+                    source_headline = headline
+            if verdict == "CONFIRMED":
+                break
+
+        results.append(
+            {
+                "entity": entity,
+                "claimed": claimed,
+                "verdict": verdict,
+                "found": found_number,
+                "source": source_headline,
+                "type": "numeric",
+            }
+        )
+    return results
+
+
+def verify_phrase_claims(
+    claims: list[dict],
+    max_results: int = 3,
+) -> list[dict]:
+    """Verify phrase claims against Google News.
+
+    Searches for the subject + predicate and checks if results support the claim.
+    Returns list of {"claim_text", "verdict", "source"} dicts.
+    Verdict: "CONFIRMED" | "UNVERIFIED" | "CONTRADICTED"
+    """
+    results = []
+    for claim in claims:
+        query = claim["claim_text"]
+        articles = search_google_news(query, max_results=max_results)
+
+        verdict = "UNVERIFIED"
+        source_headline = ""
+
+        if articles:
+            # Simple heuristic: if ANY result title contains the subject
+            # AND shows up, the event has some coverage
+            subject_lower = claim["subject"].lower()
+            pred_lower = claim["predicate"].lower()
+
+            for article in articles:
+                title_lower = article.get("title", "").lower()
+                # Strong match: both subject and a related keyword appear
+                if subject_lower in title_lower:
+                    # Check for contradiction signals
+                    contradiction_signals = [
+                        "false",
+                        "fake",
+                        "hindi totoo",
+                        "walang katotohanan",
+                        "hindi umano",
+                        "denied",
+                        "denies",
+                        "not true",
+                        "debunked",
+                        "fact check",
+                        "walang patunay",
+                    ]
+                    if any(sig in title_lower for sig in contradiction_signals):
+                        verdict = "CONTRADICTED"
+                        source_headline = article.get("title", "")
+                        break
+                    else:
+                        verdict = "CONFIRMED"
+                        source_headline = article.get("title", "")
+                        break
+
+        results.append(
+            {
+                "claim_text": claim["claim_text"],
+                "context": claim.get("context", ""),
+                "verdict": verdict,
+                "source": source_headline,
+                "type": "phrase",
+            }
+        )
+    return results
+
+
+# ── Convenience wrapper ───────────────────────────────────────────────────────
+
+
+def check_claims(text: str, topic_context: str = "") -> list[dict]:
+    """One-shot: extract and verify both numeric and phrase claims from text.
+
+    - Numeric claims (entity + number): best for list-format articles
+    - Phrase claims (subject + action): best for prose / social media posts
+
+    Returns combined list of verified claim dicts.
+    Each dict has a "type" key: "numeric" or "phrase".
+    Returns [] if no claims detected.
+    """
+    all_results = []
+
+    # 1. Numeric claims (e.g. repatriation lists)
+    numeric_claims = extract_numeric_claims(text)
+    if numeric_claims:
+        all_results.extend(
+            verify_numeric_claims(numeric_claims, topic_context=topic_context)
+        )
+
+    # 2. Phrase claims (e.g. "BBM natagpuang nagshashabu")
+    phrase_claims = extract_phrase_claims(text)
+    if phrase_claims:
+        all_results.extend(verify_phrase_claims(phrase_claims))
+
+    return all_results

checker/fact_checker.py

@@ -24,6 +24,7 @@ from checker.internal.core import (
     get_minilm_model,
 )
 from checker.external.core import ExternalChecker
+from checker.external.claim_verifier import check_claims
 from scipy.sparse import hstack, csr_matrix
 
 
@@ -62,6 +63,7 @@ class FactChecker:
                 - "article_date": str or None — earliest published date found
                 - "lime_explanation": list[tuple[str, float]] — LIME word weights
                 - "misinformation_type": str — classified type of misinformation (if any)
+                - "claim_verification": list[dict] — per-claim verdicts (entity, claimed, verdict, found, source)
         """
         # 1. Internal check (ML model + bias)
         internal_result = self.internal.check(text)
@@ -94,6 +96,12 @@ class FactChecker:
         lime_samples = int(os.environ.get("LIME_SAMPLES", 100))
         lime_explanation = self.explain(text, num_samples=lime_samples)
 
+        # 8. Lightweight claim verification (regex + existing Google News search)
+        # Builds a topic context string from the first web result title (if any)
+        web_results = external_result.get("web_results", [])
+        topic_context = web_results[0]["title"] if web_results else ""
+        claim_verification = check_claims(text, topic_context=topic_context)
+
         return {
             "internal": internal_result,
             "external": external_result,
@@ -108,6 +116,7 @@ class FactChecker:
             },
             "lime_explanation": lime_explanation,
             "misinformation_type": misinfo_type,
+            "claim_verification": claim_verification,
         }
 
     def explain(self, text, num_samples=100):

checker/internal/bias_analyzer.py

@@ -1173,6 +1173,11 @@ def _detect_obfuscation(text):
     ]
     if len(suspicious_caps) >= 3:
         signals.append(f"excessive ALL-CAPS: {suspicious_caps[:5]}")
+    # Heavy ALL-CAPS (≥ 8 non-acronym caps words) alone is a strong social-media
+    # obfuscation signal — real journalism never shouts entire sentences in caps.
+    # Boost explicit_score so the flag triggers even without ∆/leet/@ substitutions.
+    if len(suspicious_caps) >= 8:
+        explicit_score += 2
 
     score = explicit_score + len(signals) - (1 if explicit_score > 0 else 0)
     # ^ explicit hits already added to score; subtract 1 to avoid counting their