gitcast 1.0.0__py3-none-any.whl

core/screenshot_session.py

@@ -0,0 +1,274 @@
+import time
+import sys
+import webbrowser
+import json
+import threading
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.live import Live
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+from rich.prompt import Prompt
+from rich import box
+from pynput import keyboard
+from core.capture import capture_active_window, detect_working_directory, get_git_diff
+from core.ocr import run_ocr
+from core.security import scan_for_secrets, delete_capture
+from config.settings import STORAGE_DIR, CURRENT_DRAFT, get_project_narrative
+
+console = Console()
+
+class ScreenshotSession:
+    def __init__(self):
+        self.screenshots = []
+        self.max_shots = 6
+        self.done = False
+        self.cancelled = False
+        self.working_dir = detect_working_directory()
+        self.git_diff = get_git_diff(self.working_dir)
+        self.accent_color = "#6366f1"
+        self._lock = threading.Lock()
+        self._processing = False
+
+    def run(self):
+        """Starts the interactive terminal session."""
+        self.show_header()
+        
+        # Start hotkey listener
+        with keyboard.Listener(on_press=self.on_press) as listener:
+            try:
+                while not self.done and not self.cancelled:
+                    if len(self.screenshots) >= self.max_shots:
+                        if not self._processing:
+                            console.print(f"\n[bold {self.accent_color}]Limit of {self.max_shots} reached. Moving to final review...[/bold {self.accent_color}]")
+                            time.sleep(1.5)
+                            self.done = True
+                            break
+                    time.sleep(0.1)
+            except KeyboardInterrupt:
+                self.cancelled = True
+            
+            # Stop listener to free up stdin for Prompts
+            listener.stop()
+
+        if self.cancelled:
+            console.print("\n[red]Session cancelled. No screenshots saved.[/red]")
+            return []
+
+        # Remove any screenshots that might have failed
+        self.screenshots = [s for s in self.screenshots if s.get("path")]
+
+        if not self.screenshots:
+            console.print("[yellow]No screenshots captured.[/yellow]")
+            return []
+
+        # BATCH REVIEW & TAGGING
+        # Now we ask for purposes and keep/discard all at once
+        self.review_and_tag_shots()
+        
+        if self.screenshots:
+            self.finish_session()
+            return self.screenshots
+        else:
+            console.print("[yellow]All shots discarded. Nothing to post.[/yellow]")
+            return []
+
+    def show_header(self):
+        header = Panel(
+            f"Capture up to [bold]{self.max_shots}[/bold] screenshots. Tag them all at the end.\n\n"
+            f"[bold {self.accent_color}]Ctrl+S[/bold {self.accent_color}]  →  [white]Capture Now (Instant)[/white]\n"
+            f"[bold {self.accent_color}]Ctrl+D[/bold {self.accent_color}]  →  [white]Done & Review[/white]\n"
+            f"[bold {self.accent_color}]Ctrl+C[/bold {self.accent_color}]  →  [white]Cancel[/white]",
+            title=f"[bold {self.accent_color}]GITCAST[/bold {self.accent_color}]  ·  Rapid Capture Mode",
+            expand=False,
+            border_style=self.accent_color,
+            box=box.ROUNDED,
+            padding=(1, 2)
+        )
+        console.print(header)
+
+    def on_press(self, key):
+        """Handles session hotkeys."""
+        try:
+            # Ctrl+S (\x13)
+            if hasattr(key, 'char') and key.char == '\x13':
+                if self._processing:
+                    # Very brief message so it doesn't clutter
+                    console.print("[dim]...waiting for current capture...[/dim]", end="\r")
+                else:
+                    threading.Thread(target=self.take_screenshot, daemon=True).start()
+            
+            # Ctrl+D (\x04)
+            elif hasattr(key, 'char') and key.char == '\x04':
+                if not self._processing:
+                    self.done = True
+                    return False
+                
+            # Ctrl+C (\x03)
+            elif hasattr(key, 'char') and key.char == '\x03':
+                self.cancelled = True
+                return False
+        except Exception:
+            pass
+
+    def take_screenshot(self):
+        """Captures window silently and adds to queue."""
+        with self._lock:
+            self._processing = True
+            try:
+                # Minimal 1s countdown for focus shift
+                for i in range(1, 0, -1):
+                    time.sleep(0.5)
+                
+                shot = capture_active_window(delay=0.1)
+                if not shot["success"]:
+                    console.print(f"[red]Capture failed: {shot['error']}[/red]")
+                    return
+
+                # OCR and Security (Silent progress)
+                ocr = run_ocr(shot["path"])
+                security = scan_for_secrets(ocr["text"] or ocr["raw_text"])
+
+                if not security["clean"]:
+                    console.print(f"\n[red]⚠️  Shot {len(self.screenshots)+1} blocked (sensitive content).[/red]")
+                    delete_capture(shot["path"])
+                    return
+
+                # Add to list with default purpose
+                screenshot_data = {
+                    "path": shot["path"],
+                    "purpose": "code", 
+                    "ocr_text": ocr["text"] or ocr["raw_text"],
+                    "confidence": ocr["confidence"],
+                    "timestamp": shot["timestamp"],
+                    "index": len(self.screenshots) + 1
+                }
+                self.screenshots.append(screenshot_data)
+                
+                # Non-blocking success message
+                console.print(f"[bold green]✓[/bold green] Captured Shot {len(self.screenshots)}  ·  [dim]Press Ctrl+S for more or Ctrl+D to finish[/dim]")
+                
+            finally:
+                self._processing = False
+
+    def review_and_tag_shots(self):
+        """Final phase where user tags and picks shots."""
+        console.print(Panel(
+            "REVIEW & TAG YOUR SESSION\n[dim]Assign purposes and decide what to keep[/dim]", 
+            style=f"bold {self.accent_color}", 
+            border_style=self.accent_color,
+            box=box.DOUBLE
+        ))
+        
+        keeps = [True] * len(self.screenshots)
+        
+        while True:
+            table = Table(show_header=True, border_style=self.accent_color, box=box.ROUNDED)
+            table.add_column("ID", justify="center")
+            table.add_column("Preview", width=40)
+            table.add_column("Purpose")
+            table.add_column("Status")
+            
+            for i, (s, keep) in enumerate(zip(self.screenshots, keeps), 1):
+                status = "[green]Keep[/green]" if keep else "[red]Discard[/red]"
+                check = "[bold green]✓[/bold green]" if keep else "[ ]"
+                preview = (s["ocr_text"][:37].replace("\n", " ") + "...") if s["ocr_text"] else "No text"
+                table.add_row(f"{check} {i}", preview, f"[bold]{s['purpose']}[/bold]", status)
+            
+            console.print(table)
+            console.print("[dim]Commands: [ID] to toggle status | [pID] to set purpose (e.g. p1) | [d] done[/dim]")
+            action = Prompt.ask("Action", default="d")
+            
+            if action.lower() == 'd':
+                break
+            
+            # Purpose setting (e.g. p1)
+            if action.lower().startswith('p') and len(action) > 1:
+                try:
+                    idx = int(action[1:]) - 1
+                    if 0 <= idx < len(self.screenshots):
+                        purpose = Prompt.ask(
+                            f"Purpose for Shot {idx+1}",
+                            choices=["code", "terminal", "browser", "result", "other"],
+                            default=self.screenshots[idx]["purpose"]
+                        )
+                        self.screenshots[idx]["purpose"] = purpose
+                except ValueError:
+                    pass
+                continue
+
+            # Toggle keep/discard
+            try:
+                idx = int(action) - 1
+                if 0 <= idx < len(keeps):
+                    keeps[idx] = not keeps[idx]
+            except ValueError:
+                console.print("[red]Invalid command.[/red]")
+                
+        # Final cleanup
+        final_shots = []
+        for s, keep in zip(self.screenshots, keeps):
+            if keep:
+                final_shots.append(s)
+            else:
+                delete_capture(s["path"])
+        
+        self.screenshots = final_shots
+
+    def finish_session(self):
+        """Saves session and opens dashboard."""
+        console.print(Panel(
+            "[bold green]✓ Session Complete[/bold green]\n"
+            "Opening dashboard to finish your post...",
+            border_style="green",
+            box=box.ROUNDED,
+            padding=(1, 2)
+        ))
+        
+        self.save_session_and_generate()
+        webbrowser.open("http://localhost:8000")
+
+    def save_session_and_generate(self):
+        """Background generation of post variations."""
+        from api.payload import build_payload
+        from ai.generator import generate_posts
+        import asyncio
+
+        payload = build_payload(
+            raw_thought="",
+            ocr_result={}, 
+            capture_result={"working_dir": self.working_dir, "git_diff": self.git_diff, "screenshot": self.screenshots[0]},
+            multi_screenshots=self.screenshots
+        )
+        
+        draft_data = {
+            "payload": payload,
+            "variations": {},
+            "timestamp": payload["timestamp"],
+            "status": "generating"
+        }
+        with open(CURRENT_DRAFT, "w", encoding="utf-8") as f:
+            json.dump(draft_data, f, indent=4)
+
+        def run_gen():
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                variations = loop.run_until_complete(generate_posts(payload))
+                draft_data["variations"] = variations
+                draft_data["status"] = "ready"
+                with open(CURRENT_DRAFT, "w", encoding="utf-8") as f:
+                    json.dump(draft_data, f, indent=4)
+            except Exception as e:
+                from core.log_stream import stream_log
+                stream_log("Generator", "ERROR", f"Hotkey background generation failed: {e}")
+                draft_data["status"] = "failed"
+                with open(CURRENT_DRAFT, "w", encoding="utf-8") as f:
+                    json.dump(draft_data, f, indent=4)
+
+        threading.Thread(target=run_gen, daemon=True).start()
+
+if __name__ == "__main__":
+    session = ScreenshotSession()
+    session.run()

core/security.py

@@ -0,0 +1,126 @@
+import os
+import re
+from pathlib import Path
+from cryptography.fernet import Fernet
+from config.settings import ENCRYPTION_KEY_PATH
+from api.analytics import track
+
+# [Security] module for data protection and sensitive content scanning
+
+def generate_key():
+    """Creates a new Fernet key and saves it to ENCRYPTION_KEY_PATH."""
+    key = Fernet.generate_key()
+    ENCRYPTION_KEY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(ENCRYPTION_KEY_PATH, "wb") as key_file:
+        key_file.write(key)
+    
+    # Add to .gitignore if not already present
+    gitignore_path = Path(".gitignore")
+    if gitignore_path.exists():
+        with open(gitignore_path, "r") as f:
+            content = f.read()
+        if ".secret_key" not in content:
+            with open(gitignore_path, "a") as f:
+                f.write("\n.secret_key\n")
+            print("[Security] Added .secret_key to .gitignore")
+    
+    return key
+
+def load_key():
+    """Loads the existing key or generates a new one."""
+    if not ENCRYPTION_KEY_PATH.exists():
+        return generate_key()
+    with open(ENCRYPTION_KEY_PATH, "rb") as key_file:
+        return key_file.read()
+
+def encrypt_file(path: str):
+    """Encrypts a file in place using Fernet symmetric encryption."""
+    key = load_key()
+    f = Fernet(key)
+    with open(path, "rb") as file:
+        file_data = file.read()
+    encrypted_data = f.encrypt(file_data)
+    with open(path, "wb") as file:
+        file.write(encrypted_data)
+    print(f"[Security] Encrypted: {path}")
+
+def decrypt_file(path: str) -> bytes:
+    """Decrypts a file and returns the bytes without writing to disk."""
+    key = load_key()
+    f = Fernet(key)
+    with open(path, "rb") as file:
+        encrypted_data = file.read()
+    return f.decrypt(encrypted_data)
+
+def scan_for_secrets(ocr_text: str) -> dict:
+    """
+    Scans OCR text for potential sensitive patterns.
+    Returns {"clean": bool, "matches": list}
+    """
+    patterns = [
+        r"KEY\s*=\s*['\"]?([a-zA-Z0-9_\-]{20,})['\"]?",
+        r"TOKEN\s*=\s*['\"]?([a-zA-Z0-9_\-]{20,})['\"]?",
+        r"SECRET\s*=\s*['\"]?([a-zA-Z0-9_\-]{20,})['\"]?",
+        r"PASSWORD\s*=\s*['\"]?([a-zA-Z0-9_\-]{20,})['\"]?",
+        r"Bearer\s+([a-zA-Z0-9_\-\.]{20,})",
+        r"sk-[a-zA-Z0-9]{20,}",
+        r"pk-[a-zA-Z0-9]{20,}",
+        r"[a-fA-F0-9]{32,}", # Long hex strings
+    ]
+    
+    matches = []
+    for pattern in patterns:
+        found = re.findall(pattern, ocr_text, re.IGNORECASE)
+        if found:
+            matches.extend(found)
+    
+    unique_matches = list(set(matches))
+    if unique_matches:
+        track("sensitive_content_blocked", {"pattern_count": len(unique_matches)})
+
+    return {
+        "clean": len(matches) == 0,
+        "matches": unique_matches
+    }
+
+def delete_capture(screenshot_path: str):
+    """Securely deletes a screenshot from disk."""
+    try:
+        path = Path(screenshot_path)
+        if path.exists():
+            # Overwrite with random data before deleting (basic secure delete)
+            size = path.stat().st_size
+            with open(path, "wb") as f:
+                f.write(os.urandom(size))
+            path.unlink()
+            print(f"[Security] Securely deleted: {screenshot_path}")
+    except Exception as e:
+        print(f"[Security] Error deleting {screenshot_path}: {e}")
+
+if __name__ == "__main__":
+    print("=== SECURITY MODULE TEST ===")
+    
+    # Test encryption/decryption
+    test_file = "test_security.png"
+    with open(test_file, "wb") as f:
+        f.write(b"fake image data")
+    
+    print("Original data: b'fake image data'")
+    encrypt_file(test_file)
+    
+    try:
+        decrypted = decrypt_file(test_file)
+        print(f"Decrypted data: {decrypted}")
+        assert decrypted == b"fake image data"
+        print("Encryption/Decryption test: PASSED")
+    finally:
+        if os.path.exists(test_file):
+            os.remove(test_file)
+
+    # Test secret scanning
+    test_text = "My API key is KEY=sk-1234567890abcdef1234567890 and my token is Bearer some-long-token-string-here"
+    scan_results = scan_for_secrets(test_text)
+    print(f"Scan results: {scan_results}")
+    assert not scan_results["clean"]
+    assert len(scan_results["matches"]) >= 2
+    print("Secret scanning test: PASSED")

core/tray.py

@@ -0,0 +1,54 @@
+import pystray
+import os
+from PIL import Image, ImageDraw
+from pystray import MenuItem as item
+import webbrowser
+from .hotkey import start_hotkey_listener, stop_hotkey_listener
+
+_icon = None
+
+def create_image():
+    # Generate a simple icon
+    width = 64
+    height = 64
+    color1 = (0, 128, 255)
+    color2 = (255, 255, 255)
+    image = Image.new('RGB', (width, height), color1)
+    dc = ImageDraw.Draw(image)
+    dc.rectangle(
+        (width // 4, height // 4, width * 3 // 4, height * 3 // 4),
+        fill=color2
+    )
+    return image
+
+def run_tray(trigger_callback):
+    global _icon
+    # Start the hotkey listener
+    start_hotkey_listener(trigger_callback)
+
+    def on_quit(icon, item):
+        stop_tray()
+        os._exit(0)
+
+    def trigger_action(icon, item):
+        trigger_callback()
+
+    def open_dashboard(icon, item):
+        webbrowser.open("http://127.0.0.1:8000")
+
+    image = create_image()
+    menu = pystray.Menu(
+        item('Dashboard', open_dashboard),
+        item('Trigger Capture (Ctrl+Alt+S)', trigger_action),
+        item('Quit', on_quit)
+    )
+
+    _icon = pystray.Icon("gitcast", image, "Gitcast", menu)
+    _icon.run()
+
+def stop_tray():
+    global _icon
+    stop_hotkey_listener()
+    if _icon:
+        _icon.stop()
+        print("[Tray] Icon stopped.")

gitcast-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Timilehin Agoro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gitcast-1.0.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: gitcast
+Version: 1.0.0
+Summary: git diff → published post. under 60 seconds.
+Home-page: https://github.com/drizzy765/gitcast
+Author: Timilehin Agoro
+Author-email: agorotimilehi05@gmail.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow
+Requires-Dist: cryptography
+Requires-Dist: fastapi
+Requires-Dist: groq
+Requires-Dist: httpx
+Requires-Dist: keyboard
+Requires-Dist: limits
+Requires-Dist: mss
+Requires-Dist: posthog
+Requires-Dist: pynput
+Requires-Dist: pystray
+Requires-Dist: pytesseract
+Requires-Dist: python-dotenv
+Requires-Dist: python-jose[cryptography]
+Requires-Dist: rich
+Requires-Dist: sentry-sdk[fastapi]
+Requires-Dist: slowapi
+Requires-Dist: supabase
+Requires-Dist: tweepy
+Requires-Dist: uvicorn
+
+# Gitcast
+
+On-demand, privacy-first desktop utility that captures active window context,
+extracts code changes, and generates platform-ready X (Twitter) posts with one keystroke.
+
+## Install
+
+```bash
+pip install gitcast
+```
+
+## Setup
+
+1. Install Tesseract OCR:
+   - Windows: https://github.com/UB-Mannheim/tesseract/wiki
+   - Mac: `brew install tesseract`
+   - Linux: `sudo apt install tesseract-ocr`
+
+2. Add your API keys:
+   ```bash
+   gitcast --setup
+   ```
+   (opens `.env` file for editing)
+
+3. Run:
+   ```bash
+   gitcast
+   ```
+
+Dashboard opens at http://127.0.0.1:8000
+Press Ctrl+Shift+P from anywhere to capture.
+
+## Stack
+- Python 3.11+
+- FastAPI, pynput, mss, Tesseract, Groq API, Tweepy

gitcast-1.0.0.dist-info/RECORD

@@ -0,0 +1,61 @@
+ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai/formatter.py,sha256=1bfPCzRiOsJ_M2_aOJsb2xCkx-SFUK2bVBCpZCRRdo4,2338
+ai/generator.py,sha256=25qcPlRATAU3CpeojDQhTFS8RbhlsckAnjItBWLU1KY,24443
+ai/prompts.py,sha256=uBa8FQsbd7TlUhrqe-MMku83sHr_ZmCcb1zkFO6jeP8,10304
+ai/viral_patterns.py,sha256=tm7236kOAwtqtAp5fiQs4tEPrq_KE9Y1EUrZNyolh8c,3879
+api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api/analytics.py,sha256=3MfmZmP2kt77BZ5FQ7ce13TMQ2vJYbiDCMrBcx7sQyA,1198
+api/auth.py,sha256=DM2ZtXHOCvZbRjaxp336B3mlzYKDUhSlXP06GQSOhvM,1498
+api/auth_middleware.py,sha256=RuHD8YxHV_SizRXXKDpqDw2j5SHN5k6_N4erfakCdlU,4075
+api/auth_routes.py,sha256=fYMAbL3DKyD4sANhFkCcAqveCgnSCPkYI_FH9nMaSp4,4023
+api/monitoring.py,sha256=iWvqPYUiq6BATd1DMRKuYent38LJOUnW8oZWs_jH24s,1559
+api/payload.py,sha256=jLxMZMM3s0-ZpqO0s662bY8cfHjgm7MVKUVaXmVX7jU,9651
+api/ratelimit.py,sha256=7EeFRlsvQFc1mOnvd5BBzabT98pbbhkS61ujP4CputM,253
+api/routes.py,sha256=DlKHeeYVzpdKamz3tfKNkyr3lbtKEOvAoWDq9uw7dlU,57814
+api/server.py,sha256=N9f0qHksNiFCp6-c6yAJ1ClkBORXjupTAxaAeIUlC3g,5499
+api/validators.py,sha256=ENVAw9AWGAS3g4Ro3UKFGRQdrCwOdxOyRQ8ggmqIdg4,2907
+assets/__init__.py,sha256=L582TvLegqQlplr9qawaiDbbFBQT6HuZxvNZygQieoY,93
+assets/favicon-16x16.png,sha256=3xo2x9dQmGsdJvWpCEK5d8WveCxW9wm1yS-7dN1GpIg,272
+assets/favicon-32x32.png,sha256=91im3NSOf4sDViP9i2GfoTcfiKbuWwK3BOqguG62rVo,613
+assets/favicon-64x64.png,sha256=VRwOkiPyjiCtA4Lu4b8PwjuWtWLmGatv5B6JkQA3UCc,1292
+assets/favicon.ico,sha256=VUkA-33GjavIqwoKtQEHBNuUFwqCuWp0i3lmbeX3sj4,2916
+assets/icon.png,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/.env.example,sha256=0msnLTS8DyYpT9t-BuUgMWjADgvkIHdLAIqL0ex6OJE,955
+cli/__init__.py,sha256=QHJaTQVcqGsvBTXZQN2GFSjZLYQImJg5Xwqj2DzR5IA,14
+cli/gitcast.py,sha256=217btuKYK6ysC5Bi6bFKjqJ-qfVsdHxpn0ow8sSuCXE,2824
+config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+config/settings.py,sha256=YNGPQLHGYj6Rst_1wUr0EhtHhOeKLGj0zSWThHHonQo,6406
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/capture.py,sha256=QUg_j_M6RahKoLpNejpLId3Gj287af49jVlfqnxwrqE,8783
+core/codebase_reader.py,sha256=7WkboJ3emE_6InN97vQpOu83vExO-iVaPkf3xDx1BHc,3503
+core/framing.py,sha256=pGZQNWmYTINa-eDyUbY1NCkIwVZzuUmmnzrmR9kN9cg,2923
+core/hotkey.py,sha256=V22jTfWdo1pgszY83uT75DrMr4wsbA_rIJKxw8R4Tmg,438
+core/log_stream.py,sha256=aWo5F2cGVSwuGBg4AtrdGAcSm2qpLBcp-_caRfjm6nM,1227
+core/ocr.py,sha256=P30R7lVHvvF-8lKGTKXgu-6r6lTenORt8ENiD0g76P8,6130
+core/screenshot_session.py,sha256=9xZ8akYYc7WmK-FQeLuAwCEOY23iViSylf5RhUjlew4,10869
+core/security.py,sha256=JU6d03pmgcZno3eozPjUar307xCOud8CcxAhvDRNQ5s,4258
+core/tray.py,sha256=Gam9lylleXZYr-3OHJ7QxBfNj3hVpU5Nh_193I13XDc,1293
+publisher/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+publisher/clipboard.py,sha256=oQrPPl9wZgtAd4DBz3HpgHSaLFpsNFHtoV9JT5vIkLE,1626
+publisher/twitter.py,sha256=QUara_G-8jTPTkEYTGFrUbQxjSZCMLwRtPIdJNwRmfo,3355
+storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+storage/cleanup.py,sha256=9UWuH4mjK2SySfOeYdOs1vB4Yq1ixLGFDWdT_bRT5Nc,2221
+storage/engagement.py,sha256=m00ecVngQu6UElsd-Ax9s32ITUkT4Bf_RB-TqImM1BA,4120
+storage/insights.py,sha256=i2TQRbJ7Tf6HEPDgCiCCGzYGklDcnGRC62ofN18ADms,7882
+storage/key_manager.py,sha256=D2ceDV5judPaPP6aANwqE0Xa6w8DLc73qB3LYKbcfeE,1278
+storage/logger.py,sha256=-J4r1ELkCxjWuUNsZbBQZ8gaN1vZSbEdNXDuVPZ3lPc,6496
+storage/metrics.py,sha256=r1ZKr2OP82-Os-tyMPchZhaqO_6I5q7M60Z_hwfdiks,3976
+storage/sprint.py,sha256=dsVIMe0BWhxV65popfg2zjjRoDWB6mJS-bl9FJ5y4Ww,1019
+storage/streak.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+storage/supabase_client.py,sha256=IBaCcmWfj49aOS1jUdyhKkDzaDw1BEaH4LZ4LLORK0U,791
+storage/tone_memory.py,sha256=hr6xOO20GhBwhZam_OHLRAypM0gKphTeXAnU3BZFb3g,4721
+ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+web/__init__.py,sha256=eOuhaq0eKt3yb_CUJcLmQZorRDsoZ0c08yG4FgPrPzw,90
+web/index.html,sha256=ap1AI_03XihVgDxh-YWE84OocXrYgkCRii3TSjuVFCY,210179
+web/landing.html,sha256=ouCDxNpaFzM-hKsylty-T8JPXPBXP0q5c-SU_RXFpco,34469
+gitcast-1.0.0.dist-info/LICENSE,sha256=BekKKCXOSkFiRzT17cdBpdSqjKhfXkNAYhroTwa1Y78,1072
+gitcast-1.0.0.dist-info/METADATA,sha256=s4WUmFX_Fk-vqBI8YOVb_Dg4r1fts4gH1f-a0WevzOM,1508
+gitcast-1.0.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+gitcast-1.0.0.dist-info/entry_points.txt,sha256=Qu4EahnnTiLiONI6OfXoanLMf2n-vhamtcDvqvAni_Q,45
+gitcast-1.0.0.dist-info/top_level.txt,sha256=43Ln1zzXEtb4ZLGBypsfgc3N1bkEc3z3P7eo7hNvnjk,55
+gitcast-1.0.0.dist-info/RECORD,,

gitcast-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gitcast-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gitcast = cli.gitcast:main

gitcast-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,10 @@
+ai
+api
+assets
+cli
+config
+core
+publisher
+storage
+ui
+web

publisher/clipboard.py

@@ -0,0 +1,44 @@
+import webbrowser
+from api.analytics import track
+
+
+def copy_to_clipboard(post_text: str) -> dict:
+    """Copy post text to the system clipboard using tkinter."""
+    try:
+        import tkinter as tk
+
+        root = tk.Tk()
+        root.withdraw()
+        root.clipboard_clear()
+        root.clipboard_append(post_text)
+        root.update()  # required for clipboard to persist after destroy
+        root.destroy()
+        print("[Publisher] Text copied to clipboard.")
+        track("post_copied", {"platform": "clipboard"})
+        return {"success": True, "method": "clipboard"}
+    except Exception as e:
+        print(f"[Publisher] Clipboard copy failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+def open_x_compose(post_text: str) -> dict:
+    """Copy text to clipboard then open X compose page in the default browser."""
+    try:
+        clip_result = copy_to_clipboard(post_text)
+        if not clip_result["success"]:
+            return clip_result
+
+        compose_url = "https://twitter.com/compose/tweet"
+        webbrowser.open(compose_url)
+        print(f"[Publisher] Opened {compose_url} — paste your post from clipboard.")
+        return {"success": True, "method": "clipboard"}
+    except Exception as e:
+        print(f"[Publisher] Failed to open X compose: {e}")
+        return {"success": False, "error": str(e)}
+
+
+if __name__ == "__main__":
+    sample = "🚀 Just shipped a new feature! Building in public with Context Engine. #buildinpublic #devtools"
+    print("[Publisher] Testing open_x_compose...")
+    result = open_x_compose(sample)
+    print(f"[Publisher] Result: {result}")