gitcast 1.0.26__tar.gz → 1.0.28__tar.gz

{gitcast-1.0.26/gitcast.egg-info → gitcast-1.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitcast
-Version: 1.0.26
+Version: 1.0.28
 Summary: git diff → published post. under 60 seconds.
 Home-page: https://github.com/drizzy765/gitcast
 Author: Timilehin Agoro

{gitcast-1.0.26 → gitcast-1.0.28}/ai/prompts.py

@@ -69,6 +69,7 @@ Rules:
 - 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.
+- The project README and tech stack are provided as context. Use them to write about the ACTUAL project the developer is working on — not about Gitcast or any other tool. Reference the real project name, real technologies, and real features described in the README.
 """
 
 

{gitcast-1.0.26 → gitcast-1.0.28}/api/payload.py

@@ -2,72 +2,57 @@ import base64
 from pathlib import Path
 from config.settings import get_project_narrative
 from core.log_stream import stream_log
-
-
-# ── Payload builder ───────────────────────────────────────────────────────────
-
-def build_payload(
-    raw_thought: str,
-    ocr_result: dict,
-    capture_result: dict,
-    format_keys: list = None,
-    multi_screenshots: list = None,
-) -> dict:
-    """
-    Assembles the full payload from all captured context.
-    Supports single or multi-screenshot sessions.
-    """
-    if format_keys is None:
-        format_keys = ["deep_tech", "linkedin", "pr_generator", "quick_win"]
-
-    narrative = get_project_narrative()
-    git_diff = capture_result.get("git_diff", {"diff": "", "success": False})
-    
-    # Handle single or multi-shot
-    if multi_screenshots:
-        screenshots = multi_screenshots
-        primary_shot = screenshots[0]
-    else:
-        # Normalize single shot to a list of one
-        primary_shot = capture_result["screenshot"]
-        screenshots = [{
-            "path": primary_shot["path"],
-            "purpose": "general",
-            "ocr_text": ocr_result.get("text") or ocr_result.get("raw_text", ""),
-            "confidence": ocr_result.get("confidence", 0.0),
-            "timestamp": primary_shot.get("timestamp", ""),
-            "index": 1
-        }]
-
-    # Decide vision fallback based on primary shot or all shots
-    # For now, we'll use OCR if any shot is reliable, but usually it's per-shot.
-    # LLM will see OCR text for each shot.
-    use_vision = ocr_result.get("use_vision_fallback", False) if not multi_screenshots else False
-
-    # encode primary screenshot as base64 for vision fallback
-    screenshot_b64 = None
-    if use_vision and primary_shot.get("path"):
-        screenshot_b64 = _encode_image(primary_shot["path"])
-
-    # build the structured user message
-    user_message = _build_user_message(
-        raw_thought=raw_thought,
-        screenshots=screenshots,
-        git_diff=git_diff,
-        narrative=narrative,
-        use_vision=use_vision,
-    )
-
-    # joined OCR text for legacy/summary access
-    all_ocr = "\n\n".join([s.get("ocr_text", "") for s in screenshots if s.get("ocr_text")])
-
-    stream_log(
-        "Payload",
-        "OK",
-        f"assembled payload: {len(screenshots)} screenshot(s), {len(all_ocr)} OCR chars",
-    )
 
-    return {
+
+# ── Payload builder ───────────────────────────────────────────────────────────
+
+def build_payload(
+    raw_thought: str,
+    ocr_result: dict,
+    capture_result: dict,
+    format_keys: list = None,
+    multi_screenshots: list = None,
+) -> dict:
+    """
+    Assembles the full payload from all captured context.
+    Supports single or multi-screenshot sessions.
+    """
+    if format_keys is None:
+        format_keys = ["deep_tech", "linkedin", "pr_generator", "quick_win"]
+
+    narrative = get_project_narrative()
+    git_diff = capture_result.get("git_diff", {"diff": "", "success": False})
+    
+    # Handle single or multi-shot
+    if multi_screenshots:
+        screenshots = multi_screenshots
+        primary_shot = screenshots[0]
+    else:
+        # Normalize single shot to a list of one
+        primary_shot = capture_result["screenshot"]
+        screenshots = [{
+            "path": primary_shot["path"],
+            "purpose": "general",
+            "ocr_text": ocr_result.get("text") or ocr_result.get("raw_text", ""),
+            "confidence": ocr_result.get("confidence", 0.0),
+            "timestamp": primary_shot.get("timestamp", ""),
+            "index": 1
+        }]
+
+    # Decide vision fallback based on primary shot or all shots
+    # For now, we'll use OCR if any shot is reliable, but usually it's per-shot.
+    # LLM will see OCR text for each shot.
+    use_vision = ocr_result.get("use_vision_fallback", False) if not multi_screenshots else False
+
+    # encode primary screenshot as base64 for vision fallback
+    screenshot_b64 = None
+    if use_vision and primary_shot.get("path"):
+        screenshot_b64 = _encode_image(primary_shot["path"])
+
+    # joined OCR text for legacy/summary access
+    all_ocr = "\n\n".join([s.get("ocr_text", "") for s in screenshots if s.get("ocr_text")])
+
+    payload = {
         "raw_thought": raw_thought.strip(),
         "ocr_text": all_ocr,
         "screenshots": screenshots,
@@ -77,12 +62,30 @@ def build_payload(
         "use_vision_fallback": use_vision,
         "screenshot_b64": screenshot_b64,
         "screenshot_path": primary_shot.get("path", ""),
-        "user_message": user_message,
         "format_keys": format_keys,
         "timestamp": primary_shot.get("timestamp", ""),
         "working_dir": capture_result.get("working_dir", ""),
     }
 
+    # build the structured user message
+    user_message = _build_user_message(
+        raw_thought=raw_thought,
+        screenshots=screenshots,
+        git_diff=git_diff,
+        narrative=narrative,
+        use_vision=use_vision,
+        payload=payload,
+    )
+    payload["user_message"] = user_message
+
+    stream_log(
+        "Payload",
+        "OK",
+        f"assembled payload: {len(screenshots)} screenshot(s), {len(all_ocr)} OCR chars",
+    )
+
+    return payload
+
 
 # ── User message builder ──────────────────────────────────────────────────────
 
@@ -92,6 +95,7 @@ def _build_user_message(
     git_diff: dict,
     narrative: str,
     use_vision: bool,
+    payload: dict = None,
 ) -> str:
     """
     Builds the user-turn message that gets sent to the LLM.
@@ -123,6 +127,15 @@ def _build_user_message(
     if narrative:
         parts.append(f"## Project context\n{narrative}")
 
+    if payload and payload.get("readme_content"):
+        parts.append(
+            f"## Project context\n"
+            f"Project name: {payload.get('project_name', 'Unknown')}\n"
+            f"Tech stack: {payload.get('tech_stack', 'Unknown')}\n"
+            f"README:\n"
+            f"{payload['readme_content'][:1500]}"
+        )
+
     parts.append(
         "\nUsing the context above, generate the post now. "
         "Follow the format and rules in the system prompt exactly."

{gitcast-1.0.26 → gitcast-1.0.28}/cli/gitcast.py

@@ -2,9 +2,16 @@ import sys
 import subprocess
 import httpx
 import webbrowser
+import os
+import signal
 
 _browser_opened = False
-VERSION = "1.0.26"
+VERSION = "1.0.27"
+
+
+def handle_exit(sig=None, frame=None):
+    print("\n> [Gitcast] shutting down... bye.")
+    os._exit(0)
 
 
 def setup():
@@ -65,6 +72,41 @@ Get a free Groq key in 2 minutes:
 
 
 def check_tesseract() -> bool:
+    import subprocess
+    import shutil
+    import os
+
+    # Method 1: check system PATH
+    tesseract_path = shutil.which("tesseract")
+    if tesseract_path:
+        print(f"> [OK] Tesseract OCR found")
+        return True
+
+    # Method 2: check common Windows install paths
+    windows_paths = [
+        r"C:\Program Files\Tesseract-OCR\tesseract.exe",
+        r"C:\Program Files (x86)\Tesseract-OCR\tesseract.exe",
+        r"C:\Users\{}\AppData\Local\Tesseract-OCR\tesseract.exe".format(
+            os.environ.get("USERNAME", "")),
+    ]
+    for path in windows_paths:
+        if os.path.exists(path):
+            # found it — add to PATH so pytesseract
+            # can use it
+            tesseract_dir = os.path.dirname(path)
+            os.environ["PATH"] = (
+                tesseract_dir + os.pathsep +
+                os.environ.get("PATH", ""))
+            # also tell pytesseract directly
+            try:
+                import pytesseract
+                pytesseract.pytesseract.tesseract_cmd = path
+            except ImportError:
+                pass
+            print(f"> [OK] Tesseract OCR found")
+            return True
+
+    # Method 3: try running it directly
     try:
         result = subprocess.run(
             ["tesseract", "--version"],
@@ -75,65 +117,73 @@ def check_tesseract() -> bool:
         if result.returncode == 0:
             print("> [OK] Tesseract OCR found")
             return True
-    except (FileNotFoundError, subprocess.TimeoutExpired):
+    except Exception:
         pass
 
+    # genuinely not found — show install instructions
     print("""
 > [!!] TESSERACT OCR NOT INSTALLED
-
-Required for reading your screen locally.
-Your code never leaves your machine without
-your permission - OCR runs on-device.
-
-Install for your OS:
-
-WINDOWS:
-Download installer:
-github.com/UB-Mannheim/tesseract/wiki
-Run it -> check "Add to PATH" -> restart terminal
-
-MAC:
-brew install tesseract
-
-LINUX:
-sudo apt install tesseract-ocr
-
-Gitcast will still run. Screenshot text
-extraction will be limited until Tesseract
-is installed.
-""")
+>
+> Required for reading your screen locally.
+> Your code never leaves your machine without
+> your permission - OCR runs on-device.
+>
+> WINDOWS:
+>   Download: github.com/UB-Mannheim/tesseract/wiki
+>   Run installer
+>   Check "Add to PATH" during install
+>   Restart terminal then run gitcast again
+>
+> MAC:
+>   brew install tesseract
+>
+> LINUX:
+>   sudo apt install tesseract-ocr
+>
+> Gitcast will still run. Posts will generate
+> but screenshot text extraction is limited.
+    """)
     return False
 
 
 def check_server():
     from core.cloud_client import check_server_health
+    import time
 
     print("> [Cloud] Connecting to Gitcast server...")
-    health = check_server_health()
-
-    if health.get("status") == "unreachable":
-        print("> [!!] Cannot reach Gitcast server")
-        print(">      Check your internet connection")
-        print(">      Server: https://gitcast-api.onrender.com")
-        return False
 
-    if health.get("status") == "ok":
-        providers = health.get("providers", {})
-        active = [key for key, value in providers.items() if value]
-        print("> [OK] Connected to Gitcast server")
-        print(f"> [OK] AI providers: {', '.join(active)}")
+    # Render free tier sleeps after inactivity
+    # retry up to 3 times with increasing delays
+    for attempt in range(3):
+        health = check_server_health()
+
+        if health.get("status") == "ok":
+            providers = health.get("providers", {})
+            active = [k for k, v in providers.items()
+                      if v]
+            print(f"> [OK] Connected to Gitcast server")
+            print(f"> [OK] Providers: "
+                  f"{', '.join(active)}")
+            from config.settings import BYOK_KEY
+            if BYOK_KEY:
+                print("> [OK] Using your own API key")
+            else:
+                print("> [OK] Using Gitcast shared key")
+                print(">      Add your own for unlimited:")
+                print(">      gitcast --setup")
+            return True
 
-        from config.settings import BYOK_KEY
+        if attempt == 0:
+            print("> [Cloud] Server waking up, "
+                  "please wait...")
+        time.sleep(8)
 
-        if BYOK_KEY:
-            print("> [OK] Using your own API key")
-        else:
-            print("> [OK] Using Gitcast shared key")
-            print(">      Add your own key anytime:")
-            print(">      gitcast --setup or [BYOK] in dashboard")
-        return True
-
-    return True
+    # after retries still failed
+    print("> [!!] Cannot reach Gitcast server")
+    print(">      Posts may not generate")
+    print(">      Check: "
+          "https://gitcast-api.onrender.com/health")
+    return False
 
 def main():
     if "--setup" in sys.argv:
@@ -148,8 +198,9 @@ def main():
         print(f"> GITCAST v{VERSION}")
         print("> git diff -> published post.")
         print(">")
+        print("> // Press Ctrl+C to quit\n")
+
         check_tesseract()
-        check_server()
 
         # start FastAPI server in background thread
         import threading
@@ -184,9 +235,20 @@ def main():
         print("> [OK] browser opened")
         print("> Press Ctrl+Shift+P to capture")
 
+        check_server()
+
         from core.tray import run_tray
         from core.trigger import on_trigger
-        run_tray(trigger_callback=on_trigger)
+
+        # register BEFORE starting tray:
+        signal.signal(signal.SIGINT, handle_exit)
+        signal.signal(signal.SIGTERM, handle_exit)
+
+        # wrap run_tray in try/except:
+        try:
+            run_tray(trigger_callback=on_trigger)
+        except KeyboardInterrupt:
+            handle_exit()
         return
 
     command = sys.argv[1]

{gitcast-1.0.26 → gitcast-1.0.28}/core/ocr.py

@@ -1,21 +1,35 @@
 import os
+import shutil
 import pytesseract
 from PIL import Image
 from pathlib import Path
 from config.settings import get_ocr_threshold
 from core.log_stream import stream_log
 
-# ── Tesseract path (Windows) ──────────────────────────────────────────────────
+# ── Tesseract path ────────────────────────────────────────────────────────────
 
-# explicitly set the tesseract path for Windows
-# if installed elsewhere, update this path
-TESSERACT_PATH = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
+def _find_and_set_tesseract():
+    """Find Tesseract and configure pytesseract."""
+    # check PATH first
+    path = shutil.which("tesseract")
+    if path:
+        pytesseract.pytesseract.tesseract_cmd = path
+        return True
 
-if Path(TESSERACT_PATH).exists():
-    pytesseract.pytesseract.tesseract_cmd = TESSERACT_PATH
-else:
-    # fallback — rely on PATH
-    stream_log("OCR", "WARN", "Tesseract not found at default path. Relying on PATH.")
+    # check common Windows locations
+    windows_paths = [
+        r"C:\Program Files\Tesseract-OCR\tesseract.exe",
+        r"C:\Program Files (x86)\Tesseract-OCR\tesseract.exe",
+    ]
+    for p in windows_paths:
+        if os.path.exists(p):
+            pytesseract.pytesseract.tesseract_cmd = p
+            return True
+
+    return False
+
+# call once at module level:
+_find_and_set_tesseract()
 
 
 # ── OCR runner ────────────────────────────────────────────────────────────────

gitcast-1.0.28/core/project_reader.py

@@ -0,0 +1,125 @@
+import os
+import json
+from pathlib import Path
+
+MAX_README_CHARS = 3000
+MAX_STACK_CHARS = 500
+
+def read_project_context(directory: str = None) -> dict:
+    """
+    Reads project context from the current working
+    directory. Extracts README, tech stack, and
+    project name to give the AI real grounding.
+    """
+    cwd = Path(directory or os.getcwd())
+
+    context = {
+        "project_name": cwd.name,
+        "readme_content": "",
+        "tech_stack": "",
+        "project_type": "",
+        "main_language": "",
+    }
+
+    # Read README
+    for readme_name in [
+        "README.md", "readme.md",
+        "README.txt", "README"]:
+        readme_path = cwd / readme_name
+        if readme_path.exists():
+            try:
+                content = readme_path.read_text(
+                    encoding="utf-8", errors="ignore")
+                # cap at 3000 chars
+                context["readme_content"] = \
+                    content[:MAX_README_CHARS]
+                if len(content) > MAX_README_CHARS:
+                    context["readme_content"] += \
+                        "\n... [truncated]"
+                break
+            except Exception:
+                pass
+
+    # Detect tech stack from config files
+    stack_signals = []
+
+    if (cwd / "requirements.txt").exists():
+        try:
+            reqs = (cwd / "requirements.txt"
+                    ).read_text(errors="ignore")
+            stack_signals.append(
+                f"Python project. Dependencies: "
+                f"{reqs[:300]}")
+            context["main_language"] = "Python"
+        except Exception:
+            pass
+
+    if (cwd / "package.json").exists():
+        try:
+            pkg = json.loads(
+                (cwd / "package.json").read_text())
+            name = pkg.get("name", "")
+            deps = list(pkg.get(
+                "dependencies", {}).keys())[:10]
+            stack_signals.append(
+                f"JavaScript/Node project: {name}. "
+                f"Dependencies: {', '.join(deps)}")
+            context["main_language"] = "JavaScript"
+        except Exception:
+            pass
+
+    if (cwd / "Cargo.toml").exists():
+        stack_signals.append("Rust project")
+        context["main_language"] = "Rust"
+
+    if (cwd / "go.mod").exists():
+        stack_signals.append("Go project")
+        context["main_language"] = "Go"
+
+    if (cwd / "pom.xml").exists():
+        stack_signals.append("Java/Maven project")
+        context["main_language"] = "Java"
+
+    if (cwd / "Dockerfile").exists():
+        stack_signals.append("Dockerized")
+
+    if (cwd / ".github").exists():
+        stack_signals.append("GitHub Actions CI")
+
+    context["tech_stack"] = " | ".join(
+        stack_signals)[:MAX_STACK_CHARS]
+
+    # detect project type
+    if (cwd / "manage.py").exists():
+        context["project_type"] = "Django web app"
+    elif (cwd / "app.py").exists() or \
+         (cwd / "main.py").exists():
+        context["project_type"] = "Python app"
+    elif (cwd / "index.js").exists() or \
+         (cwd / "index.ts").exists():
+        context["project_type"] = "Node.js app"
+    elif (cwd / "src").exists():
+        context["project_type"] = "Source project"
+
+    return context
+
+def detect_gitcast_window(ocr_text: str) -> bool:
+    """
+    Detects if the captured window is the Gitcast
+    dashboard itself (localhost:8000).
+    Returns True if the screenshot is of Gitcast.
+    """
+    gitcast_signals = [
+        "localhost:8000",
+        "127.0.0.1:8000",
+        "DRAFT_ROOM",
+        "X_POST",
+        "GITCAST",
+        "git diff → published post",
+        "NEW_CAPTURE",
+        "QUICK_WIN",
+    ]
+    ocr_upper = ocr_text.upper()
+    matches = sum(1 for s in gitcast_signals
+                  if s.upper() in ocr_upper)
+    return matches >= 2

{gitcast-1.0.26 → gitcast-1.0.28}/core/trigger.py

@@ -41,7 +41,7 @@ def _show_tray_notification(title, message):
         print(f"[Trigger] {title}: {message}")
 
 
-def _generate_and_open(raw_thought, capture, ocr):
+def _generate_and_open(raw_thought, capture, ocr, project_ctx):
     payload = build_payload(
         raw_thought=raw_thought,
         ocr_result=ocr,
@@ -50,6 +50,25 @@ def _generate_and_open(raw_thought, capture, ocr):
     payload["use_vision_fallback"] = False
     payload["screenshot_b64"] = None
 
+    # inject project context into payload
+    payload["project_name"] = project_ctx["project_name"]
+    payload["readme_content"] = project_ctx["readme_content"]
+    payload["tech_stack"] = project_ctx["tech_stack"]
+    payload["project_type"] = project_ctx["project_type"]
+    payload["main_language"] = project_ctx["main_language"]
+
+    # build enriched user message
+    if project_ctx["readme_content"]:
+        payload["user_message"] = (
+            payload.get("user_message", "") +
+            f"\n\n## Project: "
+            f"{project_ctx['project_name']}\n"
+            f"## Tech stack: "
+            f"{project_ctx['tech_stack']}\n"
+            f"## README context:\n"
+            f"{project_ctx['readme_content'][:1500]}"
+        )
+
     def generate_and_show():
         try:
             print('[Trigger] calling generate_posts...')
@@ -108,13 +127,63 @@ def _generate_and_open(raw_thought, capture, ocr):
 def _run_trigger():
     """The actual trigger logic — moved from on_trigger."""
     print("[Trigger] on_trigger fired successfully")
-    print("[Gitcast] Hotkey fired — starting capture...")
 
+    # read project context FIRST before capture
+    from core.project_reader import (
+        read_project_context, detect_gitcast_window)
+    from core.capture import detect_working_directory
+
+    working_dir = detect_working_directory()
+    project_ctx = read_project_context(working_dir)
+
+    if project_ctx["readme_content"]:
+        print(f"[Trigger] README found for: "
+              f"{project_ctx['project_name']}")
+    if project_ctx["tech_stack"]:
+        print(f"[Trigger] Stack: "
+              f"{project_ctx['tech_stack'][:60]}")
+
+    # run capture
+    print("[Gitcast] Hotkey fired — starting capture...")
     capture = run_capture()
     print("[Trigger] capture complete")
     ocr = run_ocr(capture["screenshot"]["path"])
     print("[Trigger] OCR complete")
 
+    # detect if user captured Gitcast dashboard
+    ocr_text = ocr.get("text", "") or \
+               ocr.get("raw_text", "")
+    if detect_gitcast_window(ocr_text):
+        print("""
+  > [!!] You captured the Gitcast dashboard.
+  >
+  > For best results:
+  >   1. Switch to your code editor (VS Code,
+  >      PyCharm, terminal with your code)
+  >   2. Press Ctrl+Shift+P again
+  >
+  > The 5-second countdown gives you time to switch.
+  > Gitcast will still generate using your README
+  > and project narrative as context.
+        """)
+
+        # show tray notification
+        try:
+            from plyer import notification
+            notification.notify(
+                title="Gitcast",
+                message="Switch to your code editor "
+                        "then press Ctrl+Shift+P again",
+                timeout=5,
+            )
+        except Exception:
+            pass
+
+        # clear OCR text — don't send dashboard content to AI
+        ocr["text"] = ""
+        ocr["raw_text"] = ""
+        ocr["reliable"] = False
+
     if is_sprint_mode():
         log_sprint_capture(
             git_diff=capture["git_diff"].get("diff", ""),
@@ -132,7 +201,7 @@ def _run_trigger():
         # use narrative as the raw thought
         raw_thought = narrative
         print("[Trigger] using project narrative — skipping popup")
-        _generate_and_open(raw_thought, capture, ocr)
+        _generate_and_open(raw_thought, capture, ocr, project_ctx)
 
     else:
         # first time or no narrative — show popup once
@@ -145,7 +214,7 @@ def _run_trigger():
             # save as project narrative for future
             set_project_narrative(thought)
             print(f"[Trigger] narrative saved: '{thought}'")
-            _generate_and_open(thought, capture, ocr)
+            _generate_and_open(thought, capture, ocr, project_ctx)
 
         def on_dismiss():
             print("[Trigger] popup dismissed")
@@ -156,3 +225,4 @@ def _run_trigger():
             on_dismiss=on_dismiss,
             prompt_text="What are you building? (saved for future captures)"
         )
+

{gitcast-1.0.26 → gitcast-1.0.28/gitcast.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitcast
-Version: 1.0.26
+Version: 1.0.28
 Summary: git diff → published post. under 60 seconds.
 Home-page: https://github.com/drizzy765/gitcast
 Author: Timilehin Agoro

{gitcast-1.0.26 → gitcast-1.0.28}/gitcast.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ core/framing.py
 core/hotkey.py
 core/log_stream.py
 core/ocr.py
+core/project_reader.py
 core/screenshot_session.py
 core/security.py
 core/tray.py

{gitcast-1.0.26 → gitcast-1.0.28}/setup.py

@@ -50,7 +50,7 @@ if os.path.exists(requirements_path):
 
 setup(
     name="gitcast",
-    version="1.0.26",
+    version="1.0.28",
     description="git diff → published post. under 60 seconds.",
     long_description=long_description,
     long_description_content_type="text/markdown",