gitcast 1.0.0__py3-none-any.whl

storage/logger.py

@@ -0,0 +1,208 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from uuid import UUID
+
+from storage.supabase_client import get_client
+
+
+def _is_supabase_user(user_id: Optional[str]) -> bool:
+    try:
+        UUID(str(user_id))
+        return True
+    except (TypeError, ValueError):
+        return False
+
+
+def _normalize_entry(entry: dict) -> dict:
+    timestamp = entry.get("timestamp") or entry.get("created_at") or ""
+    tweet_url = entry.get("tweet_url", "") or ""
+    return {
+        **entry,
+        "id": str(entry.get("id", "")),
+        "timestamp": timestamp,
+        "posted_verified": bool(entry.get("posted_verified", False)),
+        "posted_declined": bool(entry.get("declined", False)),
+        "post_url": tweet_url,
+        "verified_at": entry.get("verified_at", "") or "",
+        "metrics": {
+            "impressions": int(entry.get("impressions") or 0),
+            "likes": int(entry.get("likes") or 0),
+            "comments": int(entry.get("comments") or 0),
+            "reposts": int(entry.get("reposts") or 0),
+            "hashtags": entry.get("hashtags") or [],
+            "platform": entry.get("platform") or "",
+            "days_after_post": int(entry.get("days_after_post") or 0),
+            "measured_at": entry.get("metrics_saved_at") or "",
+        } if entry.get("metrics_saved") else {},
+    }
+
+
+def save_posts(posts: list, user_id: Optional[str] = None) -> None:
+    print("[Logger] save_posts is deprecated for Supabase storage")
+
+
+def log_post(
+    post_text: str,
+    format_key: str,
+    screenshot_path: str,
+    tweet_url: str = "",
+    tweet_id: str = "",
+    fallback: bool = False,
+    timestamp: str = "",
+    user_id: Optional[str] = None,
+    provider_used: str = "",
+) -> Optional[str]:
+    if not user_id:
+        raise ValueError("user_id is required")
+    if not _is_supabase_user(user_id):
+        print("[Logger] Local user detected; skipping Supabase post log")
+        return None
+
+    payload = {
+        "user_id": user_id,
+        "post_text": post_text,
+        "format_key": format_key,
+        "provider_used": provider_used or ("fallback" if fallback else ""),
+        "platform": "twitter",
+        "tweet_url": tweet_url,
+        "tweet_id": tweet_id,
+    }
+    if timestamp:
+        payload["timestamp"] = timestamp
+
+    try:
+        response = get_client().table("posts").insert(payload).execute()
+        row = response.data[0] if response.data else {}
+        print("[Logger] Post metadata logged to Supabase")
+        return row.get("id")
+    except Exception as e:
+        print(f"[Logger] Failed to log post metadata: {e}")
+        return None
+
+
+def load_posts(user_id: str) -> list:
+    if not _is_supabase_user(user_id):
+        return []
+
+    try:
+        response = (
+            get_client()
+            .table("posts")
+            .select("*")
+            .eq("user_id", user_id)
+            .order("timestamp", desc=True)
+            .execute()
+        )
+        return [_normalize_entry(entry) for entry in (response.data or [])]
+    except Exception as e:
+        print(f"[Logger] Failed to load posts: {e}")
+        return []
+
+
+def verify_post(post_id: str, post_url: str = "", user_id: Optional[str] = None) -> dict:
+    if not user_id:
+        return {"success": False, "error": "user_id is required"}
+    if not _is_supabase_user(user_id):
+        return {"success": False, "error": "local history is not backed by Supabase"}
+
+    payload = {
+        "posted_verified": True,
+        "declined": False,
+        "verified_at": datetime.now().isoformat(),
+    }
+    if post_url:
+        payload["tweet_url"] = post_url
+
+    response = (
+        get_client()
+        .table("posts")
+        .update(payload)
+        .eq("id", post_id)
+        .eq("user_id", user_id)
+        .execute()
+    )
+    if response.data:
+        return {"success": True, "post_id": post_id}
+    return {"success": False, "error": "post not found"}
+
+
+def decline_post(post_id: str, user_id: Optional[str] = None) -> dict:
+    if not user_id:
+        return {"success": False, "error": "user_id is required"}
+    if not _is_supabase_user(user_id):
+        return {"success": False, "error": "local history is not backed by Supabase"}
+
+    response = (
+        get_client()
+        .table("posts")
+        .update({"declined": True})
+        .eq("id", post_id)
+        .eq("user_id", user_id)
+        .execute()
+    )
+    if response.data:
+        return {"success": True, "post_id": post_id}
+    return {"success": False, "error": "post not found"}
+
+
+def get_unverified_posts(user_id: str) -> list:
+    posts = [
+        entry for entry in load_posts(user_id)
+        if not entry.get("posted_verified") and not entry.get("posted_declined")
+    ]
+    return sorted(posts, key=lambda item: item.get("timestamp", ""), reverse=True)
+
+
+def get_streak(user_id: str) -> dict:
+    posts = [post for post in load_posts(user_id) if not post.get("posted_declined")]
+    if not posts:
+        return {"current_streak": 0, "best_streak": 0, "total_posts": 0, "last_post_date": ""}
+
+    post_dates = set()
+    for entry in posts:
+        try:
+            post_dates.add(datetime.fromisoformat(str(entry["timestamp"]).replace("Z", "+00:00")).date())
+        except (KeyError, ValueError):
+            continue
+
+    if not post_dates:
+        return {"current_streak": 0, "best_streak": 0, "total_posts": len(posts), "last_post_date": ""}
+
+    sorted_dates = sorted(post_dates, reverse=True)
+    last_post_date = sorted_dates[0]
+    today = datetime.now().date()
+    if last_post_date < today - timedelta(days=1):
+        return {
+            "current_streak": 0,
+            "best_streak": 0,
+            "total_posts": len(posts),
+            "last_post_date": str(last_post_date),
+        }
+
+    streak = 1
+    for i in range(1, len(sorted_dates)):
+        if sorted_dates[i] == sorted_dates[i - 1] - timedelta(days=1):
+            streak += 1
+        else:
+            break
+
+    best_streak = 1
+    running = 1
+    for i in range(1, len(sorted_dates)):
+        if sorted_dates[i] == sorted_dates[i - 1] - timedelta(days=1):
+            running += 1
+        else:
+            best_streak = max(best_streak, running)
+            running = 1
+    best_streak = max(best_streak, running)
+
+    return {
+        "current_streak": streak,
+        "best_streak": best_streak,
+        "total_posts": len(posts),
+        "last_post_date": str(last_post_date),
+    }
+
+
+if __name__ == "__main__":
+    print("[Logger] Supabase logger module loaded")

storage/metrics.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from storage.supabase_client import get_client
+
+
+def _is_supabase_user(user_id: Optional[str]) -> bool:
+    try:
+        UUID(str(user_id))
+        return True
+    except (TypeError, ValueError):
+        return False
+
+
+def _normalise_metrics(post_id: str, metrics: dict) -> dict:
+    return {
+        "post_id": post_id,
+        "impressions": int(metrics.get("impressions", 0)),
+        "likes": int(metrics.get("likes", 0)),
+        "comments": int(metrics.get("comments", 0)),
+        "reposts": int(metrics.get("reposts", 0)),
+        "hashtags": [str(tag).strip()[:40] for tag in metrics.get("hashtags", []) if str(tag).strip()][:10],
+        "platform": str(metrics.get("platform", "")).strip()[:40],
+        "measured_at": metrics.get("measured_at") or datetime.now().isoformat(),
+        "days_after_post": int(metrics.get("days_after_post", 1)),
+    }
+
+
+def save_metrics(post_id: str, metrics: dict, user_id: Optional[str] = None) -> dict:
+    if not user_id:
+        return {"success": False, "error": "user_id is required"}
+    if not _is_supabase_user(user_id):
+        return {"success": False, "error": "local metrics are not backed by Supabase"}
+
+    entry = _normalise_metrics(post_id, metrics)
+    payload = {
+        "impressions": entry["impressions"],
+        "likes": entry["likes"],
+        "comments": entry["comments"],
+        "reposts": entry["reposts"],
+        "hashtags": entry["hashtags"],
+        "platform": entry["platform"] or "twitter",
+        "days_after_post": entry["days_after_post"],
+        "metrics_saved": True,
+        "metrics_saved_at": entry["measured_at"],
+    }
+    response = (
+        get_client()
+        .table("posts")
+        .update(payload)
+        .eq("id", post_id)
+        .eq("user_id", user_id)
+        .execute()
+    )
+    if not response.data:
+        return {"success": False, "error": "post not found"}
+    return {"success": True}
+
+
+def get_all_metrics(user_id: Optional[str] = None) -> list:
+    if not user_id or not _is_supabase_user(user_id):
+        return []
+
+    response = (
+        get_client()
+        .table("posts")
+        .select("id,impressions,likes,comments,reposts,hashtags,platform,metrics_saved_at,days_after_post")
+        .eq("user_id", user_id)
+        .eq("metrics_saved", True)
+        .execute()
+    )
+    entries = []
+    for row in response.data or []:
+        entries.append({
+            "post_id": row["id"],
+            "impressions": row.get("impressions") or 0,
+            "likes": row.get("likes") or 0,
+            "comments": row.get("comments") or 0,
+            "reposts": row.get("reposts") or 0,
+            "hashtags": row.get("hashtags") or [],
+            "platform": row.get("platform") or "",
+            "measured_at": row.get("metrics_saved_at") or "",
+            "days_after_post": row.get("days_after_post") or 0,
+        })
+    return entries
+
+
+def get_metrics(post_id: str, user_id: Optional[str] = None) -> dict:
+    if not user_id or not _is_supabase_user(user_id):
+        return {}
+
+    response = (
+        get_client()
+        .table("posts")
+        .select("id,impressions,likes,comments,reposts,hashtags,platform,metrics_saved_at,days_after_post")
+        .eq("id", post_id)
+        .eq("user_id", user_id)
+        .eq("metrics_saved", True)
+        .execute()
+    )
+    if not response.data:
+        return {}
+    row = response.data[0]
+    return {
+        "post_id": row["id"],
+        "impressions": row.get("impressions") or 0,
+        "likes": row.get("likes") or 0,
+        "comments": row.get("comments") or 0,
+        "reposts": row.get("reposts") or 0,
+        "hashtags": row.get("hashtags") or [],
+        "platform": row.get("platform") or "",
+        "measured_at": row.get("metrics_saved_at") or "",
+        "days_after_post": row.get("days_after_post") or 0,
+    }
+
+
+if __name__ == "__main__":
+    print("[Metrics] Supabase metrics module loaded")

storage/sprint.py

@@ -0,0 +1,40 @@
+import json
+from config.settings import SPRINT_LOG
+
+
+def log_sprint_capture(
+    git_diff: str,
+    ocr_text: str,
+    raw_thought: str,
+    timestamp: str,
+) -> None:
+    entry = {
+        "timestamp": timestamp,
+        "raw_thought": raw_thought,
+        "git_diff": git_diff[:1000],
+        "ocr_text": ocr_text[:500],
+    }
+    with open(SPRINT_LOG, "a", encoding="utf-8") as f:
+        f.write(json.dumps(entry) + "\n")
+    print(f"[Sprint] Capture logged to {SPRINT_LOG}")
+
+
+def load_sprint_log() -> list[dict]:
+    if not SPRINT_LOG.exists():
+        return []
+    entries = []
+    with open(SPRINT_LOG, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+    return entries
+
+
+def clear_sprint_log() -> None:
+    if SPRINT_LOG.exists():
+        SPRINT_LOG.unlink()
+    print("[Sprint] Sprint log cleared.")

storage/supabase_client.py

@@ -0,0 +1,25 @@
+import threading
+from supabase import Client, create_client, ClientOptions
+from config.settings import SUPABASE_SERVICE_KEY, SUPABASE_URL
+
+_thread_local = threading.local()
+
+def get_client() -> Client:
+    if not SUPABASE_URL or not SUPABASE_SERVICE_KEY:
+        raise RuntimeError("SUPABASE_URL and SUPABASE_SERVICE_KEY must be configured")
+    
+    if not hasattr(_thread_local, "client"):
+        _thread_local.client = create_client(
+            SUPABASE_URL,
+            SUPABASE_SERVICE_KEY,
+            options=ClientOptions(
+                postgrest_client_timeout=10,
+                storage_client_timeout=10
+            )
+        )
+    return _thread_local.client
+
+
+if __name__ == "__main__":
+    client = get_client()
+    print(f"[Supabase] Client initialized: {bool(client)}")

storage/tone_memory.py

@@ -0,0 +1,139 @@
+import json
+import time
+from pathlib import Path
+from config.settings import TONE_LOG
+
+# [ToneMemory] module for RLHF-style feedback and few-shot example selection
+
+def save_rating(post_text: str, format_key: str, rating: int, timestamp: str = ""):
+    """Appends a post rating to TONE_LOG as newline-delimited JSON."""
+    if not timestamp:
+        timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
+        
+    entry = {
+        "timestamp": timestamp,
+        "format_key": format_key,
+        "post_text": post_text,
+        "rating": rating,
+        "engagement": {
+            "likes": 0,
+            "retweets": 0,
+            "replies": 0,
+            "impressions": 0
+        }
+    }
+    
+    try:
+        with open(TONE_LOG, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry) + "\n")
+        print(f"[ToneMemory] Saved rating {rating} for {format_key}")
+    except Exception as e:
+        print(f"[ToneMemory] Error saving rating: {e}")
+
+def load_ratings():
+    """Returns all entries from TONE_LOG."""
+    if not TONE_LOG.exists():
+        return []
+    
+    entries = []
+    try:
+        with open(TONE_LOG, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    entries.append(json.loads(line))
+    except Exception as e:
+        print(f"[ToneMemory] Error loading ratings: {e}")
+    
+    return entries
+
+def get_few_shot_examples(format_key: str = None, top_n: int = 3) -> list[str]:
+    """
+    Returns top_n post_text strings with highest rating for format_key.
+    If format_key is None, returns top examples across all formats.
+    """
+    entries = load_ratings()
+    if not entries:
+        return []
+    
+    if format_key:
+        filtered = [e for e in entries if e.get("format_key") == format_key]
+    else:
+        filtered = entries
+        
+    # Sort by rating descending
+    sorted_entries = sorted(filtered, key=lambda x: x.get("rating", 0), reverse=True)
+    return [e["post_text"] for e in sorted_entries[:top_n]]
+
+def update_engagement(post_text: str, likes: int, retweets: int, replies: int):
+    """
+    Finds matching entry in TONE_LOG, updates with engagement metrics.
+    Higher engagement boosts effective rating weight.
+    """
+    entries = load_ratings()
+    updated = False
+    
+    # We use post_text as a loose identifier; in a real DB we'd use a UUID
+    for e in entries:
+        if e["post_text"] == post_text:
+            e["engagement"]["likes"] = likes
+            e["engagement"]["retweets"] = retweets
+            e["engagement"]["replies"] = replies
+            updated = True
+            break
+            
+    if updated:
+        try:
+            with open(TONE_LOG, "w", encoding="utf-8") as f:
+                for e in entries:
+                    f.write(json.dumps(e) + "\n")
+            print("[ToneMemory] Updated engagement metrics for post")
+        except Exception as e:
+            print(f"[ToneMemory] Error updating engagement: {e}")
+
+def get_weighted_examples(format_key: str, top_n: int = 3) -> list[str]:
+    """
+    Combines explicit rating + engagement metrics into weighted score.
+    Returns top_n examples by weighted score.
+    Score = rating + (likes * 0.5) + (retweets * 1.0) + (replies * 2.0)
+    """
+    entries = load_ratings()
+    if not entries:
+        return []
+    
+    filtered = [e for e in entries if e.get("format_key") == format_key]
+    
+    def calculate_score(entry):
+        r = entry.get("rating", 0)
+        eng = entry.get("engagement", {})
+        score = r + (eng.get("likes", 0) * 0.5) + (eng.get("retweets", 0) * 1.0) + (eng.get("replies", 0) * 2.0)
+        return score
+
+    sorted_entries = sorted(filtered, key=calculate_score, reverse=True)
+    return [e["post_text"] for e in sorted_entries[:top_n]]
+
+if __name__ == "__main__":
+    print("=== TONE MEMORY TEST ===")
+    
+    # Clear and test
+    if TONE_LOG.exists():
+        TONE_LOG.unlink()
+        
+    save_rating("Example post 1", "deep_tech", 5)
+    save_rating("Example post 2", "deep_tech", 3)
+    save_rating("Example post 3", "deep_tech", 4)
+    save_rating("Example post 4", "struggle", 5)
+    
+    examples = get_few_shot_examples("deep_tech", top_n=2)
+    print(f"Top 2 Deep Tech examples: {examples}")
+    assert len(examples) == 2
+    assert examples[0] == "Example post 1"
+    
+    # Test engagement boost
+    update_engagement("Example post 3", likes=10, retweets=5, replies=2)
+    weighted = get_weighted_examples("deep_tech", top_n=1)
+    print(f"Top weighted Deep Tech: {weighted}")
+    # Score for post 1: 5
+    # Score for post 3: 4 + (10*0.5) + (5*1.0) + (2*2.0) = 4 + 5 + 5 + 4 = 18
+    assert weighted[0] == "Example post 3"
+    
+    print("Tone Memory tests: PASSED")

web/__init__.py

@@ -0,0 +1 @@
+# Make web directory a Python package so it gets packaged and installed to site-packages.