bps-kit 1.0.1 → 1.0.2

package/templates/vault/last30days/scripts/lib/schema.py

@@ -0,0 +1,336 @@
+"""Data schemas for last30days skill."""
+
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional
+from datetime import datetime, timezone
+
+
+@dataclass
+class Engagement:
+    """Engagement metrics."""
+    # Reddit fields
+    score: Optional[int] = None
+    num_comments: Optional[int] = None
+    upvote_ratio: Optional[float] = None
+
+    # X fields
+    likes: Optional[int] = None
+    reposts: Optional[int] = None
+    replies: Optional[int] = None
+    quotes: Optional[int] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = {}
+        if self.score is not None:
+            d['score'] = self.score
+        if self.num_comments is not None:
+            d['num_comments'] = self.num_comments
+        if self.upvote_ratio is not None:
+            d['upvote_ratio'] = self.upvote_ratio
+        if self.likes is not None:
+            d['likes'] = self.likes
+        if self.reposts is not None:
+            d['reposts'] = self.reposts
+        if self.replies is not None:
+            d['replies'] = self.replies
+        if self.quotes is not None:
+            d['quotes'] = self.quotes
+        return d if d else None
+
+
+@dataclass
+class Comment:
+    """Reddit comment."""
+    score: int
+    date: Optional[str]
+    author: str
+    excerpt: str
+    url: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'score': self.score,
+            'date': self.date,
+            'author': self.author,
+            'excerpt': self.excerpt,
+            'url': self.url,
+        }
+
+
+@dataclass
+class SubScores:
+    """Component scores."""
+    relevance: int = 0
+    recency: int = 0
+    engagement: int = 0
+
+    def to_dict(self) -> Dict[str, int]:
+        return {
+            'relevance': self.relevance,
+            'recency': self.recency,
+            'engagement': self.engagement,
+        }
+
+
+@dataclass
+class RedditItem:
+    """Normalized Reddit item."""
+    id: str
+    title: str
+    url: str
+    subreddit: str
+    date: Optional[str] = None
+    date_confidence: str = "low"
+    engagement: Optional[Engagement] = None
+    top_comments: List[Comment] = field(default_factory=list)
+    comment_insights: List[str] = field(default_factory=list)
+    relevance: float = 0.5
+    why_relevant: str = ""
+    subs: SubScores = field(default_factory=SubScores)
+    score: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'title': self.title,
+            'url': self.url,
+            'subreddit': self.subreddit,
+            'date': self.date,
+            'date_confidence': self.date_confidence,
+            'engagement': self.engagement.to_dict() if self.engagement else None,
+            'top_comments': [c.to_dict() for c in self.top_comments],
+            'comment_insights': self.comment_insights,
+            'relevance': self.relevance,
+            'why_relevant': self.why_relevant,
+            'subs': self.subs.to_dict(),
+            'score': self.score,
+        }
+
+
+@dataclass
+class XItem:
+    """Normalized X item."""
+    id: str
+    text: str
+    url: str
+    author_handle: str
+    date: Optional[str] = None
+    date_confidence: str = "low"
+    engagement: Optional[Engagement] = None
+    relevance: float = 0.5
+    why_relevant: str = ""
+    subs: SubScores = field(default_factory=SubScores)
+    score: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'text': self.text,
+            'url': self.url,
+            'author_handle': self.author_handle,
+            'date': self.date,
+            'date_confidence': self.date_confidence,
+            'engagement': self.engagement.to_dict() if self.engagement else None,
+            'relevance': self.relevance,
+            'why_relevant': self.why_relevant,
+            'subs': self.subs.to_dict(),
+            'score': self.score,
+        }
+
+
+@dataclass
+class WebSearchItem:
+    """Normalized web search item (no engagement metrics)."""
+    id: str
+    title: str
+    url: str
+    source_domain: str  # e.g., "medium.com", "github.com"
+    snippet: str
+    date: Optional[str] = None
+    date_confidence: str = "low"
+    relevance: float = 0.5
+    why_relevant: str = ""
+    subs: SubScores = field(default_factory=SubScores)
+    score: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'title': self.title,
+            'url': self.url,
+            'source_domain': self.source_domain,
+            'snippet': self.snippet,
+            'date': self.date,
+            'date_confidence': self.date_confidence,
+            'relevance': self.relevance,
+            'why_relevant': self.why_relevant,
+            'subs': self.subs.to_dict(),
+            'score': self.score,
+        }
+
+
+@dataclass
+class Report:
+    """Full research report."""
+    topic: str
+    range_from: str
+    range_to: str
+    generated_at: str
+    mode: str  # 'reddit-only', 'x-only', 'both', 'web-only', etc.
+    openai_model_used: Optional[str] = None
+    xai_model_used: Optional[str] = None
+    reddit: List[RedditItem] = field(default_factory=list)
+    x: List[XItem] = field(default_factory=list)
+    web: List[WebSearchItem] = field(default_factory=list)
+    best_practices: List[str] = field(default_factory=list)
+    prompt_pack: List[str] = field(default_factory=list)
+    context_snippet_md: str = ""
+    # Status tracking
+    reddit_error: Optional[str] = None
+    x_error: Optional[str] = None
+    web_error: Optional[str] = None
+    # Cache info
+    from_cache: bool = False
+    cache_age_hours: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = {
+            'topic': self.topic,
+            'range': {
+                'from': self.range_from,
+                'to': self.range_to,
+            },
+            'generated_at': self.generated_at,
+            'mode': self.mode,
+            'openai_model_used': self.openai_model_used,
+            'xai_model_used': self.xai_model_used,
+            'reddit': [r.to_dict() for r in self.reddit],
+            'x': [x.to_dict() for x in self.x],
+            'web': [w.to_dict() for w in self.web],
+            'best_practices': self.best_practices,
+            'prompt_pack': self.prompt_pack,
+            'context_snippet_md': self.context_snippet_md,
+        }
+        if self.reddit_error:
+            d['reddit_error'] = self.reddit_error
+        if self.x_error:
+            d['x_error'] = self.x_error
+        if self.web_error:
+            d['web_error'] = self.web_error
+        if self.from_cache:
+            d['from_cache'] = self.from_cache
+        if self.cache_age_hours is not None:
+            d['cache_age_hours'] = self.cache_age_hours
+        return d
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Report":
+        """Create Report from serialized dict (handles cache format)."""
+        # Handle range field conversion
+        range_data = data.get('range', {})
+        range_from = range_data.get('from', data.get('range_from', ''))
+        range_to = range_data.get('to', data.get('range_to', ''))
+
+        # Reconstruct Reddit items
+        reddit_items = []
+        for r in data.get('reddit', []):
+            eng = None
+            if r.get('engagement'):
+                eng = Engagement(**r['engagement'])
+            comments = [Comment(**c) for c in r.get('top_comments', [])]
+            subs = SubScores(**r.get('subs', {})) if r.get('subs') else SubScores()
+            reddit_items.append(RedditItem(
+                id=r['id'],
+                title=r['title'],
+                url=r['url'],
+                subreddit=r['subreddit'],
+                date=r.get('date'),
+                date_confidence=r.get('date_confidence', 'low'),
+                engagement=eng,
+                top_comments=comments,
+                comment_insights=r.get('comment_insights', []),
+                relevance=r.get('relevance', 0.5),
+                why_relevant=r.get('why_relevant', ''),
+                subs=subs,
+                score=r.get('score', 0),
+            ))
+
+        # Reconstruct X items
+        x_items = []
+        for x in data.get('x', []):
+            eng = None
+            if x.get('engagement'):
+                eng = Engagement(**x['engagement'])
+            subs = SubScores(**x.get('subs', {})) if x.get('subs') else SubScores()
+            x_items.append(XItem(
+                id=x['id'],
+                text=x['text'],
+                url=x['url'],
+                author_handle=x['author_handle'],
+                date=x.get('date'),
+                date_confidence=x.get('date_confidence', 'low'),
+                engagement=eng,
+                relevance=x.get('relevance', 0.5),
+                why_relevant=x.get('why_relevant', ''),
+                subs=subs,
+                score=x.get('score', 0),
+            ))
+
+        # Reconstruct Web items
+        web_items = []
+        for w in data.get('web', []):
+            subs = SubScores(**w.get('subs', {})) if w.get('subs') else SubScores()
+            web_items.append(WebSearchItem(
+                id=w['id'],
+                title=w['title'],
+                url=w['url'],
+                source_domain=w.get('source_domain', ''),
+                snippet=w.get('snippet', ''),
+                date=w.get('date'),
+                date_confidence=w.get('date_confidence', 'low'),
+                relevance=w.get('relevance', 0.5),
+                why_relevant=w.get('why_relevant', ''),
+                subs=subs,
+                score=w.get('score', 0),
+            ))
+
+        return cls(
+            topic=data['topic'],
+            range_from=range_from,
+            range_to=range_to,
+            generated_at=data['generated_at'],
+            mode=data['mode'],
+            openai_model_used=data.get('openai_model_used'),
+            xai_model_used=data.get('xai_model_used'),
+            reddit=reddit_items,
+            x=x_items,
+            web=web_items,
+            best_practices=data.get('best_practices', []),
+            prompt_pack=data.get('prompt_pack', []),
+            context_snippet_md=data.get('context_snippet_md', ''),
+            reddit_error=data.get('reddit_error'),
+            x_error=data.get('x_error'),
+            web_error=data.get('web_error'),
+            from_cache=data.get('from_cache', False),
+            cache_age_hours=data.get('cache_age_hours'),
+        )
+
+
+def create_report(
+    topic: str,
+    from_date: str,
+    to_date: str,
+    mode: str,
+    openai_model: Optional[str] = None,
+    xai_model: Optional[str] = None,
+) -> Report:
+    """Create a new report with metadata."""
+    return Report(
+        topic=topic,
+        range_from=from_date,
+        range_to=to_date,
+        generated_at=datetime.now(timezone.utc).isoformat(),
+        mode=mode,
+        openai_model_used=openai_model,
+        xai_model_used=xai_model,
+    )

package/templates/vault/last30days/scripts/lib/score.py

@@ -0,0 +1,311 @@
+"""Popularity-aware scoring for last30days skill."""
+
+import math
+from typing import List, Optional, Union
+
+from . import dates, schema
+
+# Score weights for Reddit/X (has engagement)
+WEIGHT_RELEVANCE = 0.45
+WEIGHT_RECENCY = 0.25
+WEIGHT_ENGAGEMENT = 0.30
+
+# WebSearch weights (no engagement, reweighted to 100%)
+WEBSEARCH_WEIGHT_RELEVANCE = 0.55
+WEBSEARCH_WEIGHT_RECENCY = 0.45
+WEBSEARCH_SOURCE_PENALTY = 15  # Points deducted for lacking engagement
+
+# WebSearch date confidence adjustments
+WEBSEARCH_VERIFIED_BONUS = 10   # Bonus for URL-verified recent date (high confidence)
+WEBSEARCH_NO_DATE_PENALTY = 20  # Heavy penalty for no date signals (low confidence)
+
+# Default engagement score for unknown
+DEFAULT_ENGAGEMENT = 35
+UNKNOWN_ENGAGEMENT_PENALTY = 10
+
+
+def log1p_safe(x: Optional[int]) -> float:
+    """Safe log1p that handles None and negative values."""
+    if x is None or x < 0:
+        return 0.0
+    return math.log1p(x)
+
+
+def compute_reddit_engagement_raw(engagement: Optional[schema.Engagement]) -> Optional[float]:
+    """Compute raw engagement score for Reddit item.
+
+    Formula: 0.55*log1p(score) + 0.40*log1p(num_comments) + 0.05*(upvote_ratio*10)
+    """
+    if engagement is None:
+        return None
+
+    if engagement.score is None and engagement.num_comments is None:
+        return None
+
+    score = log1p_safe(engagement.score)
+    comments = log1p_safe(engagement.num_comments)
+    ratio = (engagement.upvote_ratio or 0.5) * 10
+
+    return 0.55 * score + 0.40 * comments + 0.05 * ratio
+
+
+def compute_x_engagement_raw(engagement: Optional[schema.Engagement]) -> Optional[float]:
+    """Compute raw engagement score for X item.
+
+    Formula: 0.55*log1p(likes) + 0.25*log1p(reposts) + 0.15*log1p(replies) + 0.05*log1p(quotes)
+    """
+    if engagement is None:
+        return None
+
+    if engagement.likes is None and engagement.reposts is None:
+        return None
+
+    likes = log1p_safe(engagement.likes)
+    reposts = log1p_safe(engagement.reposts)
+    replies = log1p_safe(engagement.replies)
+    quotes = log1p_safe(engagement.quotes)
+
+    return 0.55 * likes + 0.25 * reposts + 0.15 * replies + 0.05 * quotes
+
+
+def normalize_to_100(values: List[float], default: float = 50) -> List[float]:
+    """Normalize a list of values to 0-100 scale.
+
+    Args:
+        values: Raw values (None values are preserved)
+        default: Default value for None entries
+
+    Returns:
+        Normalized values
+    """
+    # Filter out None
+    valid = [v for v in values if v is not None]
+    if not valid:
+        return [default if v is None else 50 for v in values]
+
+    min_val = min(valid)
+    max_val = max(valid)
+    range_val = max_val - min_val
+
+    if range_val == 0:
+        return [50 if v is None else 50 for v in values]
+
+    result = []
+    for v in values:
+        if v is None:
+            result.append(None)
+        else:
+            normalized = ((v - min_val) / range_val) * 100
+            result.append(normalized)
+
+    return result
+
+
+def score_reddit_items(items: List[schema.RedditItem]) -> List[schema.RedditItem]:
+    """Compute scores for Reddit items.
+
+    Args:
+        items: List of Reddit items
+
+    Returns:
+        Items with updated scores
+    """
+    if not items:
+        return items
+
+    # Compute raw engagement scores
+    eng_raw = [compute_reddit_engagement_raw(item.engagement) for item in items]
+
+    # Normalize engagement to 0-100
+    eng_normalized = normalize_to_100(eng_raw)
+
+    for i, item in enumerate(items):
+        # Relevance subscore (model-provided, convert to 0-100)
+        rel_score = int(item.relevance * 100)
+
+        # Recency subscore
+        rec_score = dates.recency_score(item.date)
+
+        # Engagement subscore
+        if eng_normalized[i] is not None:
+            eng_score = int(eng_normalized[i])
+        else:
+            eng_score = DEFAULT_ENGAGEMENT
+
+        # Store subscores
+        item.subs = schema.SubScores(
+            relevance=rel_score,
+            recency=rec_score,
+            engagement=eng_score,
+        )
+
+        # Compute overall score
+        overall = (
+            WEIGHT_RELEVANCE * rel_score +
+            WEIGHT_RECENCY * rec_score +
+            WEIGHT_ENGAGEMENT * eng_score
+        )
+
+        # Apply penalty for unknown engagement
+        if eng_raw[i] is None:
+            overall -= UNKNOWN_ENGAGEMENT_PENALTY
+
+        # Apply penalty for low date confidence
+        if item.date_confidence == "low":
+            overall -= 10
+        elif item.date_confidence == "med":
+            overall -= 5
+
+        item.score = max(0, min(100, int(overall)))
+
+    return items
+
+
+def score_x_items(items: List[schema.XItem]) -> List[schema.XItem]:
+    """Compute scores for X items.
+
+    Args:
+        items: List of X items
+
+    Returns:
+        Items with updated scores
+    """
+    if not items:
+        return items
+
+    # Compute raw engagement scores
+    eng_raw = [compute_x_engagement_raw(item.engagement) for item in items]
+
+    # Normalize engagement to 0-100
+    eng_normalized = normalize_to_100(eng_raw)
+
+    for i, item in enumerate(items):
+        # Relevance subscore (model-provided, convert to 0-100)
+        rel_score = int(item.relevance * 100)
+
+        # Recency subscore
+        rec_score = dates.recency_score(item.date)
+
+        # Engagement subscore
+        if eng_normalized[i] is not None:
+            eng_score = int(eng_normalized[i])
+        else:
+            eng_score = DEFAULT_ENGAGEMENT
+
+        # Store subscores
+        item.subs = schema.SubScores(
+            relevance=rel_score,
+            recency=rec_score,
+            engagement=eng_score,
+        )
+
+        # Compute overall score
+        overall = (
+            WEIGHT_RELEVANCE * rel_score +
+            WEIGHT_RECENCY * rec_score +
+            WEIGHT_ENGAGEMENT * eng_score
+        )
+
+        # Apply penalty for unknown engagement
+        if eng_raw[i] is None:
+            overall -= UNKNOWN_ENGAGEMENT_PENALTY
+
+        # Apply penalty for low date confidence
+        if item.date_confidence == "low":
+            overall -= 10
+        elif item.date_confidence == "med":
+            overall -= 5
+
+        item.score = max(0, min(100, int(overall)))
+
+    return items
+
+
+def score_websearch_items(items: List[schema.WebSearchItem]) -> List[schema.WebSearchItem]:
+    """Compute scores for WebSearch items WITHOUT engagement metrics.
+
+    Uses reweighted formula: 55% relevance + 45% recency - 15pt source penalty.
+    This ensures WebSearch items rank below comparable Reddit/X items.
+
+    Date confidence adjustments:
+    - High confidence (URL-verified date): +10 bonus
+    - Med confidence (snippet-extracted date): no change
+    - Low confidence (no date signals): -20 penalty
+
+    Args:
+        items: List of WebSearch items
+
+    Returns:
+        Items with updated scores
+    """
+    if not items:
+        return items
+
+    for item in items:
+        # Relevance subscore (model-provided, convert to 0-100)
+        rel_score = int(item.relevance * 100)
+
+        # Recency subscore
+        rec_score = dates.recency_score(item.date)
+
+        # Store subscores (engagement is 0 for WebSearch - no data)
+        item.subs = schema.SubScores(
+            relevance=rel_score,
+            recency=rec_score,
+            engagement=0,  # Explicitly zero - no engagement data available
+        )
+
+        # Compute overall score using WebSearch weights
+        overall = (
+            WEBSEARCH_WEIGHT_RELEVANCE * rel_score +
+            WEBSEARCH_WEIGHT_RECENCY * rec_score
+        )
+
+        # Apply source penalty (WebSearch < Reddit/X for same relevance/recency)
+        overall -= WEBSEARCH_SOURCE_PENALTY
+
+        # Apply date confidence adjustments
+        # High confidence (URL-verified): reward with bonus
+        # Med confidence (snippet-extracted): neutral
+        # Low confidence (no date signals): heavy penalty
+        if item.date_confidence == "high":
+            overall += WEBSEARCH_VERIFIED_BONUS  # Reward verified recent dates
+        elif item.date_confidence == "low":
+            overall -= WEBSEARCH_NO_DATE_PENALTY  # Heavy penalty for unknown
+
+        item.score = max(0, min(100, int(overall)))
+
+    return items
+
+
+def sort_items(items: List[Union[schema.RedditItem, schema.XItem, schema.WebSearchItem]]) -> List:
+    """Sort items by score (descending), then date, then source priority.
+
+    Args:
+        items: List of items to sort
+
+    Returns:
+        Sorted items
+    """
+    def sort_key(item):
+        # Primary: score descending (negate for descending)
+        score = -item.score
+
+        # Secondary: date descending (recent first)
+        date = item.date or "0000-00-00"
+        date_key = -int(date.replace("-", ""))
+
+        # Tertiary: source priority (Reddit > X > WebSearch)
+        if isinstance(item, schema.RedditItem):
+            source_priority = 0
+        elif isinstance(item, schema.XItem):
+            source_priority = 1
+        else:  # WebSearchItem
+            source_priority = 2
+
+        # Quaternary: title/text for stability
+        text = getattr(item, "title", "") or getattr(item, "text", "")
+
+        return (score, date_key, source_priority, text)
+
+    return sorted(items, key=sort_key)