gitcast 1.0.0__py3-none-any.whl

ai/prompts.py

@@ -0,0 +1,197 @@
+import json
+from config.settings import get_project_narrative, is_tone_memory_enabled, PROMPTS_FILE, get_twitter_plan
+from storage.tone_memory import get_few_shot_examples
+from ai.viral_patterns import get_viral_pattern
+
+# ── PROMPT_MAP ───────────────────────────────────────────────────────────────
+PROMPT_MAP = {
+    "linkedin": "linkedin_post_prompt",
+    "article": "article_prompt"
+}
+
+
+# ── Narrative injection ───────────────────────────────────────────────────────
+
+def _narrative_block() -> str:
+    narrative = get_project_narrative()
+    if not narrative:
+        return ""
+    return f"\n\nProject context: The developer is building {narrative}. Where relevant, frame the win or struggle in the context of this larger mission."
+
+
+def _tone_block() -> str:
+    if not is_tone_memory_enabled():
+        return ""
+    examples = get_few_shot_examples()
+    if not examples:
+        return ""
+    formatted = "\n\n".join(
+        f"Example post (highly rated by this user):\n{ex}" for ex in examples
+    )
+    return f"\n\nHere are examples of posts this developer has written that performed well. Match their voice, tone, and style closely:\n\n{formatted}"
+
+
+def _plan_block() -> str:
+    """
+    Returns character limit instructions based on the user's X plan.
+    """
+    plan = get_twitter_plan()
+    if plan == "premium":
+        return "\n\nUser Plan: X Premium. You are NOT limited to 280 characters. Feel free to write longer, high-value posts (up to 4000 characters) if the context warrants it."
+    else:
+        return "\n\nUser Plan: X Free/Basic. You MUST stay under 280 characters for the main post."
+
+
+# ── Base rules applied to every prompt ───────────────────────────────────────
+
+BASE_RULES = """
+Rules:
+- Prioritize the developer's raw thought/prompt if one is provided. If the developer's prompt requests a specific topic, tone, or opening phrase (even if it contradicts these rules, like introducing a project or expressing excitement), follow the developer's instructions over these default rules.
+- Write in first person as the developer. Never use "the developer" or third person.
+- Sound human — like a real developer talking to other developers, not a press release.
+- No hashtags unless they appear naturally. Never more than two.
+- No generic filler phrases: "excited to share", "game changer", "thrilled", "journey" (unless explicitly requested by the developer's prompt).
+- Never start with "I" (unless explicitly requested by the developer's prompt).
+- Keep it grounded and specific. Vague posts get ignored.
+- If there is a code snippet in the context, reference the actual function name, variable, or error — not just "the code".
+"""
+
+
+# ── Prompt Loading ───────────────────────────────────────────────────────────
+
+def load_prompt_definitions() -> dict:
+    """Loads prompt templates from the JSON store."""
+    if not PROMPTS_FILE.exists():
+        return {}
+    try:
+        with open(PROMPTS_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"[Prompts] Error loading prompts: {e}")
+        return {}
+
+
+def get_prompt(format_key: str) -> str:
+    """Returns the fully assembled system prompt for a given format key."""
+    pattern = get_viral_pattern(format_key)
+    
+    # Try to load from prompts.json definitions first for full customization
+    definitions = load_prompt_definitions()
+    if format_key in definitions:
+        template = definitions[format_key]["system_prompt"]
+    elif format_key in PROMPT_MAP:
+        func_name = PROMPT_MAP[format_key]
+        if func_name == "linkedin_post_prompt":
+            template = linkedin_post_prompt()
+        elif func_name == "article_prompt":
+            template = article_prompt()
+        else:
+            template = ""
+    else:
+        raise ValueError(f"Unknown prompt format: '{format_key}'")
+    
+    # Assembly with viral pattern injection
+    plan_block = _plan_block() if format_key not in ["linkedin", "pr_generator", "article"] else ""
+    prompt = f"{template}\n\n{pattern}\n\n{BASE_RULES}{_narrative_block()}{_tone_block()}{plan_block}"
+    return prompt
+
+
+def get_all_prompts() -> dict[str, str]:
+    """Returns all prompts as a dict for parallel generation."""
+    definitions = load_prompt_definitions()
+    prompts = {key: get_prompt(key) for key in definitions.keys() if key != "sprint_summary"}
+    
+    # Ensure linkedin and article are included
+    if "linkedin" not in prompts:
+        prompts["linkedin"] = get_prompt("linkedin")
+    if "article" not in prompts:
+        prompts["article"] = get_prompt("article")
+        
+    return prompts
+
+
+# ── Specialized Prompts ───────────────────────────────────────────────────────
+
+def linkedin_post_prompt() -> str:
+    """Professional but human LinkedIn post prompt template."""
+    return """You are a developer writing a professional but human post for LinkedIn.
+
+Your goal is to share a technical win or insight in a way that builds your professional brand without sounding like a corporate robot. LinkedIn posts perform best with white space, a strong hook, and a personal narrative.
+
+IMPORTANT: Prioritize the developer's raw thought/prompt if one is provided. Even if the developer's thought/prompt is brief, you MUST elaborate extensively, explaining the project narrative, technical context, challenges, choices, and what it unlocks next. Do NOT write a short 2-3 sentence post. Your output MUST meet the target length of 800–1300 characters.
+
+Format guidance:
+- Hook: Line 1 must be a compelling one-sentence hook that stops the scroll.
+- The Story: Explain the technical context, the challenge, and how you solved it. Use line breaks for readability.
+- The Insight: Share one high-level takeaway that other professionals (not just devs) can appreciate.
+- CTA: End with a call to action or a question to your network.
+- No hashtag spam (max 3). No generic 'thrilled to announce' filler.
+
+Character target: 800–1300 characters."""
+
+
+def article_prompt(codebase_summary: str = "") -> str:
+    """Generates a full Medium-ready markdown article template."""
+    codebase_block = f"\n\nCodebase Summary:\n{codebase_summary}" if codebase_summary else ""
+    return f"""You are a developer writing a full Medium-ready technical article in Markdown.
+
+Your goal is to turn the current sprint context and raw thoughts into a structured, high-value technical article that documents your journey and teaches a specific lesson.
+
+Sections to include:
+1. Hook: A dramatic opener about the problem or the struggle.
+2. Context: What you were building and why it matters.
+3. The Journey: The key moments, decisions, and breakthroughs from the logs.
+4. Technical Detail: Deep dive into the implementation. Use code snippets from the git diff.
+5. Resolution: What is now built and working that wasn't before? What does it unlock?
+6. Takeaway: One specific thing other developers can apply to their own work.
+
+Target length: 800–1500 words. Be comprehensive and use Markdown formatting for headers, lists, and code blocks.{codebase_block}"""
+
+
+def article_refinement_prompt(current_article: str, instruction: str) -> str:
+    """Takes existing article draft + user refinement instruction."""
+    return f"""You are an editor helping a developer refine their technical article.
+
+Current Article Draft:
+---
+{current_article}
+---
+
+User Instruction: {instruction}
+
+Your job is to update the article based on the user's instruction while maintaining the professional yet human developer voice, the Markdown structure, and the technical depth. Output the COMPLETE updated article.
+
+No preamble. Just the revised Markdown."""
+
+
+# ── Sprint Mode batch prompt ──────────────────────────────────────────────────
+
+def sprint_summary_prompt(num_captures: int) -> str:
+    # Sprint summary is a special case that we'll keep as a function for now
+    # or it could also be moved to JSON if needed.
+    return f"""You are a developer writing a build thread for X (Twitter) that covers an entire coding sprint.
+
+You have been given a log of {num_captures} separate captures made during a focused sprint — each containing a git diff, OCR context, and a short raw thought. Your job is to synthesise them into one compelling narrative thread that tells the full story of the sprint.
+
+Format guidance:
+- Tweet 1: The hook. What was the mission of this sprint? What problem were you trying to solve? Make someone stop scrolling.
+- Tweets 2–4: The build story. Pick the 3 most interesting moments from the log — a key decision, a hard bug, a breakthrough. One tweet per moment. Be specific and sequential.
+- Tweet 5: The outcome. What is now built and working that wasn't before? What does it unlock?
+- Final tweet: One honest reflection — what would you do differently, what surprised you, or what is next?
+
+Rules:
+- Each tweet must stand alone but flow naturally into the next.
+- Number each tweet: 1/, 2/, 3/ etc.
+- Never use "excited to share" or "amazing journey". This is a war report, not a LinkedIn post.
+- Specific details from the log (actual function names, error messages, time spent) make this format work. Use them.
+- Total thread length: 6–7 tweets.
+
+{BASE_RULES}{_narrative_block()}{_tone_block()}"""
+
+
+if __name__ == "__main__":
+    print("=== DYNAMIC PROMPTS TEST ===")
+    prompts = get_all_prompts()
+    for k, p in prompts.items():
+        print(f"\n--- {k.upper()} ---")
+        print(p[:200] + "...")

ai/viral_patterns.py

@@ -0,0 +1,75 @@
+# [ViralPatterns] module for structural guidance in prompt building
+
+VIRAL_STRUCTURES = {
+    "hot_take": """Optional Structural Guidance (adapt to the developer's prompt if one is provided):
+- Lead with an engaging, opinionated opener related to the topic.
+- Use a supporting observation or detail from the context.
+- Invite discussion or feedback in the closing line.""",
+
+    "confession": """Optional Structural Guidance (only apply if the developer is sharing a struggle/bug):
+- Open with the symptom or frustration to hook the reader.
+- Briefly explain what didn't work and the key breakthrough/fix.
+- Share a lesson learned or invite others to share similar stories.""",
+
+    "technical_flex": """Optional Structural Guidance (only apply if the developer is sharing a win/performance improvement):
+- Lead with a concrete metric, improvement, or milestone.
+- Provide a clear, one-line technical explanation of how it was achieved.
+- Share a sharp, confident insight about the engineering approach.""",
+
+    "thread_hook": """Optional Structural Guidance (for threads):
+- Start with a compelling, open-ended hook/question as the first tweet.
+- Break down the implementation or narrative sequentially across tweets.
+- Number the tweets (1/, 2/, etc.) for flow.""",
+
+    "opinion_mode": """Optional Structural Guidance (only apply if the developer's prompt is about sharing a general opinion/stance):
+- State a clear stance on a developer ecosystem topic or practice.
+- Back it up with specific developer experience rather than general theory.
+- End with an engaging question to the community.""",
+
+    "build_confession": """Optional Structural Guidance (only apply if the developer's prompt is about a struggle or complex feature):
+- Set up the challenge and why it was difficult.
+- Highlight the breakthrough or key design choice.
+- Show the current working outcome.""",
+
+    "linkedin_narrative": """Optional Structural Guidance (for LinkedIn style):
+- Hook: A scroll-stopping opening line highlighting the project, milestone, or challenge.
+- Spacing: Use double line breaks between short paragraphs (1-2 sentences max) to ensure clean readability on mobile devices.
+- Narrative: Tell a relatable story: the challenge/goal, the process, and the breakthrough/launch.
+- Professional Takeaway: Share a high-level lesson or insight that other tech professionals or builders can apply.
+- CTA: End with an engaging question to invite comments (e.g., asking for feedback or experiences).""",
+
+    "velocity_update": """Optional Structural Guidance (for quick status updates):
+- Lead with the direct outcome (e.g., 'Just shipped...', 'Fixed the...').
+- Provide a single sentence of technical context.
+- End with forward momentum (what this unlocks next).""",
+
+    "pr_template": """Optional Structural Guidance (for Pull Requests):
+- Markdown layout with clear headings (What changed, Why, How, Testing, Notes).
+- Technical details referencing actual files, functions, or changes.
+- Neutral, documentation-focused tone."""
+}
+
+def get_viral_pattern(format_key: str) -> str:
+    """Returns a pattern prompt snippet based on the format key."""
+    # Mapping certain format keys to specific patterns
+    mapping = {
+        "deep_tech": "technical_flex",
+        "struggle": "confession",
+        "quick_win": "velocity_update",
+        "linkedin": "linkedin_narrative",
+        "pr_generator": "pr_template",
+        "thought": "hot_take"
+    }
+    
+    pattern_key = mapping.get(format_key, "opinion_mode")
+    return VIRAL_STRUCTURES.get(pattern_key, "")
+
+def get_all_patterns() -> dict:
+    """Returns the full dictionary of viral structures."""
+    return VIRAL_STRUCTURES
+
+if __name__ == "__main__":
+    print("=== VIRAL PATTERNS TEST ===")
+    for key in ["deep_tech", "struggle", "unknown"]:
+        print(f"\n--- Pattern for {key} ---")
+        print(get_viral_pattern(key))

api/analytics.py

@@ -0,0 +1,48 @@
+import uuid
+
+from config.settings import CONFIG_DIR, POSTHOG_API_KEY
+
+
+ANONYMOUS_ID_FILE = CONFIG_DIR / "anonymous_id.txt"
+SENSITIVE_KEYS = {"post_text", "ocr_text", "git_diff", "screenshot_path", "api_key", "key", "raw_thought"}
+
+
+def _anonymous_id() -> str:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    if ANONYMOUS_ID_FILE.exists():
+        value = ANONYMOUS_ID_FILE.read_text(encoding="utf-8").strip()
+        if value:
+            return value
+
+    value = str(uuid.uuid4())
+    ANONYMOUS_ID_FILE.write_text(value, encoding="utf-8")
+    return value
+
+
+ANONYMOUS_ID = _anonymous_id()
+
+
+def _clean_properties(properties: dict) -> dict:
+    cleaned = {}
+    for key, value in (properties or {}).items():
+        if key in SENSITIVE_KEYS:
+            continue
+        cleaned[key] = value
+    return cleaned
+
+
+def track(event: str, properties: dict = {}) -> None:
+    if not POSTHOG_API_KEY:
+        return
+
+    try:
+        import posthog
+
+        posthog.project_api_key = POSTHOG_API_KEY
+        posthog.capture(ANONYMOUS_ID, event, _clean_properties(properties))
+    except Exception:
+        return
+
+
+if __name__ == "__main__":
+    print(f"[Analytics] Anonymous ID: {ANONYMOUS_ID}")

api/auth.py

@@ -0,0 +1,49 @@
+import uuid
+from fastapi import Header, HTTPException
+
+# [Auth] module for session-based API security
+
+def generate_session_token():
+    """Returns a random UUID string for session authentication."""
+    return str(uuid.uuid4())
+
+# SESSION_TOKEN global set on module import
+SESSION_TOKEN = generate_session_token()
+
+async def verify_token(x_session_token: str = Header(None)):
+    """
+    FastAPI dependency that raises 401 if the provided token 
+    doesn't match the active session token.
+    """
+    if x_session_token != SESSION_TOKEN:
+        raise HTTPException(
+            status_code=401, 
+            detail="Unauthorized: Invalid or missing X-Session-Token"
+        )
+    return x_session_token
+
+def get_token():
+    """Returns current SESSION_TOKEN for startup display."""
+    return SESSION_TOKEN
+
+if __name__ == "__main__":
+    print("=== API AUTH TEST ===")
+    token = get_token()
+    print(f"Current Session Token: {token}")
+    
+    # Simple simulated verification
+    import asyncio
+    async def test_verify():
+        try:
+            await verify_token(token)
+            print("Verification with correct token: PASSED")
+        except HTTPException:
+            print("Verification with correct token: FAILED")
+            
+        try:
+            await verify_token("wrong-token")
+            print("Verification with wrong token: FAILED")
+        except HTTPException:
+            print("Verification with wrong token: PASSED")
+            
+    asyncio.run(test_verify())

api/auth_middleware.py

@@ -0,0 +1,129 @@
+import hashlib
+import json
+from typing import Optional
+from fastapi import Header, Query, HTTPException
+from jose import JWTError, jwt
+
+from config.settings import CONFIG_DIR, SUPABASE_JWT_AUDIENCE, SUPABASE_JWT_SECRET
+from storage.supabase_client import get_client
+
+LOCAL_USER_ID = "local_user"
+KNOWN_SESSIONS: dict[str, str] = {}
+SESSION_CACHE_FILE = CONFIG_DIR / "auth_sessions.json"
+
+
+def _token_hash(token: str) -> str:
+    return hashlib.sha256(token.encode("utf-8")).hexdigest()
+
+
+def _load_session_cache() -> dict[str, str]:
+    try:
+        if SESSION_CACHE_FILE.exists():
+            with open(SESSION_CACHE_FILE, "r", encoding="utf-8") as file:
+                data = json.load(file)
+            if isinstance(data, dict):
+                return {str(key): str(value) for key, value in data.items()}
+    except Exception:
+        return {}
+    return {}
+
+
+def _save_session_cache(cache: dict[str, str]) -> None:
+    try:
+        SESSION_CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with open(SESSION_CACHE_FILE, "w", encoding="utf-8") as file:
+            json.dump(cache, file, indent=2)
+    except Exception:
+        pass
+
+
+def _unauthorized(message: str = "Unauthorized") -> HTTPException:
+    return HTTPException(status_code=401, detail=message)
+
+
+def verify_jwt(token: str) -> dict:
+    if not token:
+        raise _unauthorized("Missing bearer token")
+
+    known_user_id = KNOWN_SESSIONS.get(token)
+    if known_user_id:
+        return {"user_id": known_user_id, "sub": known_user_id}
+    cached_user_id = _load_session_cache().get(_token_hash(token))
+    if cached_user_id:
+        KNOWN_SESSIONS[token] = cached_user_id
+        return {"user_id": cached_user_id, "sub": cached_user_id}
+
+    if SUPABASE_JWT_SECRET:
+        try:
+            payload = jwt.decode(
+                token,
+                SUPABASE_JWT_SECRET,
+                algorithms=["HS256"],
+                audience=SUPABASE_JWT_AUDIENCE,
+            )
+        except JWTError as exc:
+            raise _unauthorized("Invalid bearer token") from exc
+
+        user_id = payload.get("sub")
+        if not user_id:
+            raise _unauthorized("Invalid bearer token")
+        payload["user_id"] = user_id
+        return payload
+
+    try:
+        response = get_client().auth.get_user(token)
+        user = getattr(response, "user", None)
+        user_id = getattr(user, "id", None)
+        if not user_id:
+            raise _unauthorized("Invalid bearer token")
+        return {"user_id": str(user_id), "sub": str(user_id)}
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise _unauthorized("Invalid bearer token") from exc
+
+
+def register_session(access_token: str, user_id: str) -> None:
+    if access_token and user_id:
+        user_id = str(user_id)
+        KNOWN_SESSIONS[access_token] = user_id
+        cache = _load_session_cache()
+        cache[_token_hash(access_token)] = user_id
+        _save_session_cache(cache)
+
+
+def unregister_session(access_token: str) -> None:
+    if access_token:
+        KNOWN_SESSIONS.pop(access_token, None)
+        cache = _load_session_cache()
+        cache.pop(_token_hash(access_token), None)
+        _save_session_cache(cache)
+
+
+async def get_current_user(
+    authorization: str = Header(None),
+    x_session_token: str = Header(None),
+    token: Optional[str] = Query(None),
+) -> str:
+    from api.auth import get_token
+    session_token = x_session_token or token
+    if session_token and session_token == get_token():
+        return LOCAL_USER_ID
+
+    if not authorization and token:
+        payload = verify_jwt(token.strip())
+        return str(payload["user_id"])
+
+    if not authorization:
+        raise _unauthorized("Missing Authorization header")
+
+    scheme, _, bearer_token = authorization.partition(" ")
+    if scheme.lower() != "bearer" or not bearer_token:
+        raise _unauthorized("Authorization header must be Bearer token")
+
+    payload = verify_jwt(bearer_token.strip())
+    return str(payload["user_id"])
+
+
+if __name__ == "__main__":
+    print("[AuthMiddleware] Import OK")

api/auth_routes.py

@@ -0,0 +1,117 @@
+from fastapi import APIRouter, Depends, Header, HTTPException, Request
+from fastapi.responses import RedirectResponse
+from pydantic import BaseModel
+
+from api.auth_middleware import get_current_user, register_session, unregister_session
+from config.settings import APP_BASE_URL
+from storage.supabase_client import get_client
+
+
+router = APIRouter()
+
+
+class MagicLinkRequest(BaseModel):
+    email: str
+
+
+class VerifyOtpRequest(BaseModel):
+    email: str
+    token: str
+
+
+@router.post("/magic-link")
+def magic_link(body: MagicLinkRequest):
+    try:
+        get_client().auth.sign_in_with_otp({"email": body.email})
+        return {"success": True, "message": "check your email"}
+    except Exception as e:
+        print(f"[AuthRoutes] Magic link failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+@router.post("/verify-otp")
+def verify_otp(body: VerifyOtpRequest):
+    try:
+        response = get_client().auth.verify_otp({
+            "email": body.email,
+            "token": body.token,
+            "type": "email",
+        })
+        session = getattr(response, "session", None)
+        user = getattr(response, "user", None)
+        access_token = getattr(session, "access_token", "")
+        user_id = getattr(user, "id", "")
+        if not access_token or not user_id:
+            raise HTTPException(status_code=401, detail="Invalid OTP")
+        register_session(access_token, str(user_id))
+        return {"access_token": access_token, "user_id": str(user_id)}
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"[AuthRoutes] OTP verification failed: {e}")
+        raise HTTPException(status_code=401, detail="Invalid OTP") from e
+
+
+@router.get("/github")
+def github_login():
+    try:
+        redirect_to = f"{APP_BASE_URL.rstrip('/')}/auth/callback"
+        response = get_client().auth.sign_in_with_oauth({
+            "provider": "github",
+            "options": {"redirect_to": redirect_to},
+        })
+        return RedirectResponse(str(response.url))
+    except Exception as e:
+        print(f"[AuthRoutes] GitHub OAuth failed: {e}")
+        raise HTTPException(status_code=500, detail="GitHub OAuth failed") from e
+
+
+@router.get("/callback")
+def auth_callback(request: Request):
+    code = request.query_params.get("code", "")
+    code_verifier = request.query_params.get("code_verifier", "")
+    if not code:
+        raise HTTPException(status_code=400, detail="Missing OAuth code")
+
+    try:
+        response = get_client().auth.exchange_code_for_session({
+            "auth_code": code,
+            "code_verifier": code_verifier,
+            "redirect_to": f"{APP_BASE_URL.rstrip('/')}/auth/callback",
+        })
+        session = getattr(response, "session", None)
+        user = getattr(response, "user", None)
+        access_token = getattr(session, "access_token", "")
+        refresh_token = getattr(session, "refresh_token", "")
+        user_id = getattr(user, "id", "")
+        if not access_token:
+            raise HTTPException(status_code=401, detail="OAuth exchange failed")
+
+        register_session(access_token, str(user_id))
+        fragment = f"access_token={access_token}&refresh_token={refresh_token}&user_id={user_id}"
+        return RedirectResponse(f"/app#{fragment}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"[AuthRoutes] OAuth callback failed: {e}")
+        raise HTTPException(status_code=401, detail="OAuth callback failed") from e
+
+
+@router.post("/logout")
+def logout(
+    authorization: str = Header(None),
+    user_id: str = Depends(get_current_user),
+):
+    try:
+        _, _, token = (authorization or "").partition(" ")
+        unregister_session(token)
+        if token:
+            get_client().auth.admin.sign_out(token, "global")
+        return {"success": True}
+    except Exception as e:
+        print(f"[AuthRoutes] Logout failed for user {user_id}: {e}")
+        return {"success": False, "error": str(e)}
+
+
+if __name__ == "__main__":
+    print("[AuthRoutes] Router loaded")

api/monitoring.py

@@ -0,0 +1,56 @@
+from config.settings import SENTRY_DSN
+
+
+SENSITIVE_KEYS = {"post_text", "ocr_text", "git_diff", "screenshot_path", "api_key", "key"}
+
+
+def _strip_sensitive(value):
+    if isinstance(value, dict):
+        return {
+            key: ("[redacted]" if key in SENSITIVE_KEYS else _strip_sensitive(item))
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [_strip_sensitive(item) for item in value]
+    return value
+
+
+def init_sentry() -> None:
+    if not SENTRY_DSN:
+        print("[Monitoring] Sentry not configured - skipping")
+        return
+
+    try:
+        import sentry_sdk
+
+        def before_send(event, hint):
+            return _strip_sensitive(event)
+
+        sentry_sdk.init(
+            dsn=SENTRY_DSN,
+            traces_sample_rate=0.2,
+            profiles_sample_rate=0.1,
+            environment="production",
+            before_send=before_send,
+        )
+        print("[Monitoring] Sentry configured")
+    except Exception as e:
+        print(f"[Monitoring] Sentry init failed: {e}")
+
+
+def capture_error(error: Exception, context: dict = {}) -> None:
+    safe_context = _strip_sensitive(context or {})
+    print(f"[Error] {error}")
+    try:
+        import sentry_sdk
+
+        with sentry_sdk.push_scope() as scope:
+            for key, value in safe_context.items():
+                scope.set_context(key, value if isinstance(value, dict) else {"value": value})
+            sentry_sdk.capture_exception(error)
+    except Exception:
+        return
+
+
+if __name__ == "__main__":
+    init_sentry()