gitcast 1.0.0__py3-none-any.whl

publisher/twitter.py

@@ -0,0 +1,100 @@
+import os
+import tweepy
+from config.settings import (
+    TWITTER_API_KEY,
+    TWITTER_API_SECRET,
+    TWITTER_ACCESS_TOKEN,
+    TWITTER_ACCESS_SECRET,
+    TWITTER_BEARER_TOKEN,
+)
+from publisher.clipboard import open_x_compose
+from api.analytics import track
+
+
+def is_configured() -> bool:
+    """Return True only if all 5 Twitter API keys are present and non-empty."""
+    return all([
+        TWITTER_API_KEY,
+        TWITTER_API_SECRET,
+        TWITTER_ACCESS_TOKEN,
+        TWITTER_ACCESS_SECRET,
+        TWITTER_BEARER_TOKEN,
+    ])
+
+
+def upload_media(screenshot_path: str) -> str:
+    """Upload an image via tweepy v1.1 API and return the media_id string."""
+    try:
+        auth = tweepy.OAuth1UserHandler(
+            TWITTER_API_KEY,
+            TWITTER_API_SECRET,
+            TWITTER_ACCESS_TOKEN,
+            TWITTER_ACCESS_SECRET,
+        )
+        api = tweepy.API(auth)
+        media = api.media_upload(filename=screenshot_path)
+        media_id = str(media.media_id)
+        print(f"[Publisher] Media uploaded — media_id: {media_id}")
+        return media_id
+    except Exception as e:
+        print(f"[Publisher] Media upload failed: {e}")
+        raise
+
+
+def publish_post(post_text: str, screenshot_path: str = None) -> dict:
+    """
+    Publish a post to X (Twitter) via API v2.
+    Falls back to clipboard if keys are missing or on any error.
+    """
+    if not is_configured():
+        print("[Publisher] Twitter API not configured — falling back to clipboard.")
+        result = open_x_compose(post_text)
+        result["fallback"] = True
+        track("post_published", {"platform": "twitter", "used_fallback": True})
+        return result
+
+    try:
+        client = tweepy.Client(
+            bearer_token=TWITTER_BEARER_TOKEN,
+            consumer_key=TWITTER_API_KEY,
+            consumer_secret=TWITTER_API_SECRET,
+            access_token=TWITTER_ACCESS_TOKEN,
+            access_token_secret=TWITTER_ACCESS_SECRET,
+        )
+
+        media_ids = None
+        if screenshot_path and os.path.exists(screenshot_path):
+            try:
+                media_id = upload_media(screenshot_path)
+                media_ids = [media_id]
+            except Exception as e:
+                print(f"[Publisher] Skipping media attachment: {e}")
+
+        response = client.create_tweet(text=post_text, media_ids=media_ids)
+        tweet_id = str(response.data["id"])
+        tweet_url = f"https://twitter.com/i/web/status/{tweet_id}"
+
+        print(f"[Publisher] Tweet posted — {tweet_url}")
+        track("post_published", {"platform": "twitter", "used_fallback": False})
+        return {
+            "success": True,
+            "tweet_url": tweet_url,
+            "tweet_id": tweet_id,
+            "fallback": False,
+        }
+
+    except Exception as e:
+        print(f"[Publisher] Twitter API error: {e}")
+        print("[Publisher] Falling back to clipboard.")
+        result = open_x_compose(post_text)
+        result["fallback"] = True
+        track("post_published", {"platform": "twitter", "used_fallback": True})
+        return result
+
+
+if __name__ == "__main__":
+    print(f"[Publisher] Twitter configured: {is_configured()}")
+    if is_configured():
+        print("[Publisher] All 5 API keys are present.")
+    else:
+        print("[Publisher] Missing one or more Twitter API keys — clipboard fallback will be used.")

storage/cleanup.py

@@ -0,0 +1,60 @@
+import os
+import time
+from pathlib import Path
+from config.settings import STORAGE_DIR, screenshot_retention_hours
+
+# [Cleanup] module for managing screenshot retention policy
+
+def run_cleanup():
+    """Deletes screenshots older than screenshot_retention_hours."""
+    screenshots_dir = STORAGE_DIR / "screenshots"
+    if not screenshots_dir.exists():
+        print("[Cleanup] No screenshots directory found.")
+        return
+
+    now = time.time()
+    retention_sec = screenshot_retention_hours * 3600
+    deleted_count = 0
+    
+    for file_path in screenshots_dir.glob("*.png"):
+        file_age = now - file_path.stat().st_mtime
+        if file_age > retention_sec:
+            try:
+                # Use secure delete if possible, but for cleanup standard unlink is usually fine
+                # unless the user specifically wants secure delete for all old files.
+                # Given core/security.py exists, we could use it, but it might be overkill for bulk cleanup.
+                file_path.unlink()
+                deleted_count += 1
+            except Exception as e:
+                print(f"[Cleanup] Error deleting {file_path.name}: {e}")
+
+    if deleted_count > 0:
+        print(f"[Cleanup] Deleted {deleted_count} old screenshots.")
+    else:
+        print("[Cleanup] No old screenshots to delete.")
+
+def get_storage_stats():
+    """Returns count of screenshots, total size in MB, and oldest file date."""
+    screenshots_dir = STORAGE_DIR / "screenshots"
+    if not screenshots_dir.exists():
+        return {"count": 0, "total_size_mb": 0.0, "oldest_file": "N/A"}
+
+    files = list(screenshots_dir.glob("*.png"))
+    if not files:
+        return {"count": 0, "total_size_mb": 0.0, "oldest_file": "N/A"}
+
+    total_size = sum(f.stat().st_size for f in files)
+    oldest_time = min(f.stat().st_mtime for f in files)
+    oldest_date = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(oldest_time))
+
+    return {
+        "count": len(files),
+        "total_size_mb": round(total_size / (1024 * 1024), 2),
+        "oldest_file": oldest_date
+    }
+
+if __name__ == "__main__":
+    print("=== STORAGE CLEANUP TEST ===")
+    stats = get_storage_stats()
+    print(f"Current stats: {stats}")
+    run_cleanup()

storage/engagement.py

@@ -0,0 +1,114 @@
+import json
+import time
+import threading
+from pathlib import Path
+import tweepy
+from config.settings import ENGAGEMENT_LOG, TWITTER_BEARER_TOKEN, POST_LOG
+from storage.tone_memory import update_engagement
+
+# [Engagement] module for tracking X metrics 24h after publish
+
+def log_pending_fetch(tweet_id: str, post_text: str):
+    """Saves a tweet ID to ENGAGEMENT_LOG for background processing."""
+    entry = {
+        "tweet_id": tweet_id,
+        "post_text": post_text,
+        "publish_timestamp": time.time(),
+        "fetched": False
+    }
+    try:
+        with open(ENGAGEMENT_LOG, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry) + "\n")
+        print(f"[Engagement] Logged pending fetch for tweet {tweet_id}")
+    except Exception as e:
+        print(f"[Engagement] Error logging pending fetch: {e}")
+
+def get_pending_fetches():
+    """Returns list of entries due for metrics fetch (24h+ old, not fetched)."""
+    if not ENGAGEMENT_LOG.exists():
+        return []
+    
+    pending = []
+    now = time.time()
+    try:
+        with open(ENGAGEMENT_LOG, "r", encoding="utf-8") as f:
+            for line in f:
+                if not line.strip(): continue
+                entry = json.loads(line)
+                # 24 hours = 86400 seconds
+                if not entry.get("fetched") and (now - entry["publish_timestamp"] > 86400):
+                    pending.append(entry)
+    except Exception as e:
+        print(f"[Engagement] Error reading pending fetches: {e}")
+    
+    return pending
+
+def fetch_and_store_metrics(tweet_id: str, post_text: str):
+    """Calls X API v2 to get metrics and updates tone_memory."""
+    if not TWITTER_BEARER_TOKEN:
+        print("[Engagement] No Twitter Bearer Token found, skipping fetch.")
+        return False
+
+    try:
+        client = tweepy.Client(bearer_token=TWITTER_BEARER_TOKEN)
+        response = client.get_tweet(tweet_id, tweet_fields=["public_metrics"])
+        
+        if response.data:
+            metrics = response.data.public_metrics
+            likes = metrics.get("like_count", 0)
+            retweets = metrics.get("retweet_count", 0)
+            replies = metrics.get("reply_count", 0)
+            
+            update_engagement(post_text, likes, retweets, replies)
+            return True
+        else:
+            print(f"[Engagement] Could not find tweet {tweet_id}")
+            return False
+    except Exception as e:
+        print(f"[Engagement] X API error for {tweet_id}: {e}")
+        return False
+
+def mark_as_fetched(tweet_id: str):
+    """Updates ENGAGEMENT_LOG to mark a tweet as fetched."""
+    if not ENGAGEMENT_LOG.exists():
+        return
+    
+    entries = []
+    try:
+        with open(ENGAGEMENT_LOG, "r", encoding="utf-8") as f:
+            for line in f:
+                if not line.strip(): continue
+                entry = json.loads(line)
+                if entry["tweet_id"] == tweet_id:
+                    entry["fetched"] = True
+                entries.append(entry)
+        
+        with open(ENGAGEMENT_LOG, "w", encoding="utf-8") as f:
+            for e in entries:
+                f.write(json.dumps(e) + "\n")
+    except Exception as e:
+        print(f"[Engagement] Error marking as fetched: {e}")
+
+def run_engagement_worker():
+    """Background thread that runs hourly and processes pending fetches."""
+    def worker():
+        while True:
+            print("[Engagement] Checking for pending metrics fetches...")
+            pending = get_pending_fetches()
+            for entry in pending:
+                success = fetch_and_store_metrics(entry["tweet_id"], entry["post_text"])
+                if success:
+                    mark_as_fetched(entry["tweet_id"])
+            
+            # Sleep for 1 hour
+            time.sleep(3600)
+
+    thread = threading.Thread(target=worker, daemon=True)
+    thread.start()
+    print("[Engagement] Background worker started.")
+
+if __name__ == "__main__":
+    print("=== ENGAGEMENT TRACKING TEST ===")
+    log_pending_fetch("123456789", "Test post text")
+    print(f"Pending: {get_pending_fetches()}")
+    # Note: X API call will fail without real token in test

storage/insights.py

@@ -0,0 +1,203 @@
+from collections import defaultdict
+from datetime import datetime, timedelta
+
+from storage.logger import get_streak, load_posts
+from storage.metrics import get_all_metrics
+
+
+def _parse_dt(value: str):
+    try:
+        return datetime.fromisoformat(value)
+    except Exception:
+        return None
+
+
+def _parse_metric_post_dt(post_id: str):
+    value = str(post_id or "")
+    try:
+        if len(value) >= 15 and value[8] == "_":
+            return datetime.strptime(value[:15], "%Y%m%d_%H%M%S")
+        if len(value) >= 19 and value[4] == "-" and "T" in value[:19]:
+            return datetime.strptime(value[:19], "%Y-%m-%dT%H:%M:%S")
+    except Exception:
+        return None
+    return None
+
+
+def _avg(values: list) -> float:
+    return sum(values) / len(values) if values else 0.0
+
+
+def _engagement_rate(metrics: dict) -> float:
+    impressions = max(0, int(metrics.get("impressions", 0)))
+    if impressions == 0:
+        return 0.0
+    engagement = int(metrics.get("likes", 0)) + int(metrics.get("comments", 0)) + int(metrics.get("reposts", 0))
+    return round((engagement / impressions) * 100, 2)
+
+
+def _bucket_chars(count: int) -> str:
+    if count <= 140:
+        return "0-140"
+    if count <= 200:
+        return "141-200"
+    if count <= 260:
+        return "201-260"
+    return "261-280"
+
+
+def _time_window(dt: datetime) -> str:
+    hour = dt.hour
+    if 6 <= hour < 9:
+        return "6am-9am"
+    if 9 <= hour < 12:
+        return "9am-12pm"
+    if 12 <= hour < 15:
+        return "12pm-3pm"
+    if 15 <= hour < 18:
+        return "3pm-6pm"
+    if 18 <= hour < 21:
+        return "6pm-9pm"
+    if 21 <= hour < 23:
+        return "9pm-11pm"
+    return "late-night"
+
+
+def _format_from_metric_post_id(post_id: str) -> str:
+    value = str(post_id or "")
+    if "-" not in value:
+        return ""
+    suffix = value.rsplit("-", 1)[1]
+    return suffix if suffix and not suffix[:2].isdigit() else ""
+
+
+def _row_from_metric(post_id: str, metrics: dict, post: dict = None) -> dict:
+    post = post or {}
+    dt = _parse_dt(post.get("timestamp", "")) or _parse_metric_post_dt(post_id) or _parse_dt(metrics.get("measured_at", ""))
+    impressions = int(metrics.get("impressions", 0))
+    text = post.get("post_text", "")
+    return {
+        "post_id": post_id,
+        "post_text": text,
+        "format_key": post.get("format_key", "") or _format_from_metric_post_id(post_id) or metrics.get("platform", ""),
+        "timestamp": post.get("timestamp", "") or (dt.isoformat() if dt else metrics.get("measured_at", "")),
+        "dt": dt,
+        "day": dt.strftime("%A").lower() if dt else "",
+        "time_window": _time_window(dt) if dt else "",
+        "char_bucket": _bucket_chars(len(text)),
+        "impressions": impressions,
+        "likes": int(metrics.get("likes", 0)),
+        "comments": int(metrics.get("comments", 0)),
+        "reposts": int(metrics.get("reposts", 0)),
+        "hashtags": metrics.get("hashtags", []),
+        "engagement_rate": _engagement_rate(metrics),
+    }
+
+
+def _best_group(rows: list, key: str) -> dict:
+    groups = defaultdict(list)
+    for row in rows:
+        if row.get(key):
+            groups[row[key]].append(row["impressions"])
+    if not groups:
+        return {}
+    name, values = max(groups.items(), key=lambda item: _avg(item[1]))
+    return {"name": name, "avg": round(_avg(values), 1), "sample_size": len(values)}
+
+
+def calculate_insights(user_id: str) -> dict:
+    posts = load_posts(user_id)
+    metrics_entries = get_all_metrics(user_id)
+    metrics_by_post = {}
+    for metric in metrics_entries:
+        metrics_by_post[metric.get("post_id")] = metric
+
+    rows = []
+    matched_metric_ids = set()
+    for post in posts:
+        post_id = post.get("id") or post.get("timestamp")
+        metrics = metrics_by_post.get(post_id) or post.get("metrics")
+        if not metrics:
+            continue
+        matched_metric_ids.add(post_id)
+        rows.append(_row_from_metric(post_id, metrics, post))
+
+    for post_id, metrics in metrics_by_post.items():
+        if post_id in matched_metric_ids:
+            continue
+        rows.append(_row_from_metric(post_id, metrics))
+
+    if len(rows) < 5:
+        return {"insufficient_data": True, "posts_needed": 5 - len(rows), "posts_with_metrics": len(rows)}
+
+    cutoff = datetime.now() - timedelta(days=30)
+    recent = [row for row in rows if row["dt"] and row["dt"] >= cutoff] or rows
+    streak = get_streak(user_id)
+    total_impressions = sum(row["impressions"] for row in recent)
+    best_format = _best_group(rows, "format_key")
+    best_day = _best_group(rows, "day")
+    best_time = _best_group(rows, "time_window")
+    top = max(rows, key=lambda row: row["impressions"])
+    overall_avg = _avg([row["impressions"] for row in rows])
+
+    patterns = []
+    by_format = defaultdict(list)
+    by_chars = defaultdict(list)
+    by_day = defaultdict(list)
+    tags = defaultdict(list)
+    for row in rows:
+        by_format[row["format_key"]].append(row["impressions"])
+        by_chars[row["char_bucket"]].append(row["impressions"])
+        by_day[row["day"]].append(row["impressions"])
+        for tag in row["hashtags"]:
+            tags[tag].append(row["impressions"])
+
+    if len(by_format) >= 2:
+        ordered = sorted(by_format.items(), key=lambda item: _avg(item[1]), reverse=True)
+        high, low = ordered[0], ordered[-1]
+        if _avg(low[1]) > 0:
+            patterns.append({
+                "pattern": "format",
+                "description": f"{high[0].upper()} format gets {round(_avg(high[1]) / _avg(low[1]), 1)}x more impressions than {low[0].upper()}",
+                "impact": "high",
+            })
+    if by_chars:
+        bucket, values = max(by_chars.items(), key=lambda item: _avg(item[1]))
+        lift = round(((_avg(values) - overall_avg) / overall_avg) * 100, 0) if overall_avg else 0
+        patterns.append({"pattern": "length", "description": f"posts in the {bucket} char bucket get {lift}% more engagement", "impact": "medium"})
+    if by_day:
+        day, values = max(by_day.items(), key=lambda item: _avg(item[1]))
+        multiple = round(_avg(values) / overall_avg, 1) if overall_avg else 0
+        patterns.append({"pattern": "day", "description": f"{day} posts get {multiple}x your average", "impact": "medium"})
+
+    hashtag_performance = [
+        {"hashtag": tag, "avg_impressions": round(_avg(values), 1), "uses": len(values)}
+        for tag, values in sorted(tags.items(), key=lambda item: _avg(item[1]), reverse=True)
+    ]
+    for tag in hashtag_performance[:3]:
+        patterns.append({
+            "pattern": "hashtag",
+            "description": f"{tag['hashtag']} adds avg {int(tag['avg_impressions'])} impressions",
+            "impact": "medium",
+        })
+
+    return {
+        "overview": {
+            "total_posts": len(recent),
+            "total_verified": len([post for post in posts if post.get("posted_verified")]),
+            "total_impressions": total_impressions,
+            "avg_engagement_rate": round(_avg([row["engagement_rate"] for row in recent]), 2),
+            "posting_streak": streak.get("current_streak", 0),
+            "best_streak": streak.get("best_streak", streak.get("current_streak", 0)),
+        },
+        "best_format": {"format_key": best_format.get("name", ""), "avg_impressions": best_format.get("avg", 0.0), "sample_size": best_format.get("sample_size", 0)},
+        "best_day": {"day": best_day.get("name", ""), "avg_impressions": best_day.get("avg", 0.0)},
+        "best_time": {"window": best_time.get("name", ""), "avg_impressions": best_time.get("avg", 0.0)},
+        "top_post": {key: top[key] for key in ["post_text", "impressions", "likes", "format_key", "timestamp"]},
+        "viral_patterns": patterns[:8],
+        "hashtag_performance": hashtag_performance[:20],
+    }
+
+
+if __name__ == "__main__":
+    print("[Insights] Supabase insights module loaded")

storage/key_manager.py

@@ -0,0 +1,45 @@
+from cryptography.fernet import Fernet, InvalidToken
+
+from config.settings import ENCRYPTION_KEY_PATH
+
+
+def _load_or_create_fernet_key() -> bytes:
+    ENCRYPTION_KEY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    if ENCRYPTION_KEY_PATH.exists():
+        key = ENCRYPTION_KEY_PATH.read_bytes().strip()
+        if key:
+            return key
+
+    key = Fernet.generate_key()
+    ENCRYPTION_KEY_PATH.write_bytes(key)
+    return key
+
+
+def _fernet() -> Fernet:
+    return Fernet(_load_or_create_fernet_key())
+
+
+def encrypt_key(raw_key: str) -> str:
+    if not raw_key:
+        raise ValueError("raw_key is required")
+    return _fernet().encrypt(raw_key.encode("utf-8")).decode("utf-8")
+
+
+def decrypt_key(encrypted_key: str) -> str:
+    if not encrypted_key:
+        raise ValueError("encrypted_key is required")
+    try:
+        return _fernet().decrypt(encrypted_key.encode("utf-8")).decode("utf-8")
+    except InvalidToken as exc:
+        raise ValueError("Invalid encrypted key") from exc
+
+
+def mask_key(raw_key: str) -> str:
+    suffix = (raw_key or "")[-3:]
+    return f"••••••••...{suffix}"
+
+
+if __name__ == "__main__":
+    sample = "test_api_key_abc"
+    encrypted = encrypt_key(sample)
+    print(f"[KeyManager] Mask: {mask_key(decrypt_key(encrypted))}")