create-screenfix 0.1.0

package/python/build/lib/screenfix/annotation_window.py

@@ -0,0 +1,222 @@
+"""Annotation window for adding instructions to screenshots."""
+
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+from AppKit import (
+    NSWindow,
+    NSWindowStyleMaskTitled,
+    NSWindowStyleMaskClosable,
+    NSWindowStyleMaskNonactivatingPanel,
+    NSBackingStoreBuffered,
+    NSImageView,
+    NSImage,
+    NSScrollView,
+    NSTextView,
+    NSButton,
+    NSBezelStyleRounded,
+    NSTextField,
+    NSFont,
+    NSApplication,
+    NSImageScaleProportionallyDown,
+    NSPanel,
+    NSWindowCollectionBehaviorCanJoinAllSpaces,
+    NSWindowCollectionBehaviorFullScreenAuxiliary,
+)
+from Quartz import kCGMaximumWindowLevelKey, CGWindowLevelForKey
+from Foundation import NSMakeRect, NSObject
+import objc
+
+from .config import config
+from .task_tracker import add_task
+
+
+_current_controller = None
+
+
+def save_screenshot(temp_path: str) -> str:
+    """Save screenshot from temp location to final location."""
+    save_dir = Path(config.save_directory)
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"screenshot_{timestamp}.png"
+    final_path = save_dir / filename
+
+    shutil.move(temp_path, final_path)
+    return str(final_path)
+
+
+def cleanup_temp_file(temp_path: str):
+    """Remove temporary file."""
+    try:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+    except OSError:
+        pass
+
+
+class AnnotationWindowDelegate(NSObject):
+    """Delegate to handle window events."""
+
+    def initWithController_(self, controller):
+        self = objc.super(AnnotationWindowDelegate, self).init()
+        if self is None:
+            return None
+        self.controller = controller
+        return self
+
+    def windowWillClose_(self, notification):
+        """Called when window is about to close."""
+        global _current_controller
+        _current_controller = None
+
+
+class AnnotationWindowController(NSObject):
+    """Controller for the annotation window."""
+
+    def initWithImagePath_(self, image_path):
+        self = objc.super(AnnotationWindowController, self).init()
+        if self is None:
+            return None
+
+        self.image_path = image_path
+        self.window = None
+        self.text_view = None
+        self.delegate = None
+
+        self._create_window()
+        return self
+
+    def _create_window(self):
+        """Create the annotation window."""
+        image = NSImage.alloc().initWithContentsOfFile_(self.image_path)
+        if not image:
+            return
+
+        img_size = image.size()
+
+        max_display_width = 400
+        max_display_height = 300
+
+        width_scale = min(1.0, max_display_width / img_size.width) if img_size.width > 0 else 1.0
+        height_scale = min(1.0, max_display_height / img_size.height) if img_size.height > 0 else 1.0
+        scale = min(width_scale, height_scale)
+
+        display_width = int(img_size.width * scale)
+        display_height = int(img_size.height * scale)
+
+        padding = 20
+        window_width = max(display_width + padding * 2, 450)
+        text_area_height = 80
+        button_area_height = 50
+        label_height = 25
+        window_height = display_height + text_area_height + button_area_height + label_height + padding * 3
+
+        style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskNonactivatingPanel
+        self.window = NSPanel.alloc().initWithContentRect_styleMask_backing_defer_(
+            NSMakeRect(200, 200, window_width, window_height),
+            style,
+            NSBackingStoreBuffered,
+            False,
+        )
+        self.window.setTitle_("ScreenFix - Add Instructions")
+
+        self.window.setFloatingPanel_(True)
+        self.window.setHidesOnDeactivate_(False)
+
+        max_level = CGWindowLevelForKey(kCGMaximumWindowLevelKey)
+        self.window.setLevel_(max_level - 1)
+
+        self.window.setCollectionBehavior_(
+            NSWindowCollectionBehaviorCanJoinAllSpaces |
+            NSWindowCollectionBehaviorFullScreenAuxiliary
+        )
+
+        self.delegate = AnnotationWindowDelegate.alloc().initWithController_(self)
+        self.window.setDelegate_(self.delegate)
+
+        content = self.window.contentView()
+        y_pos = padding
+
+        # Cancel button
+        cancel_btn = NSButton.alloc().initWithFrame_(NSMakeRect(padding, y_pos, 100, 32))
+        cancel_btn.setTitle_("Cancel")
+        cancel_btn.setBezelStyle_(NSBezelStyleRounded)
+        cancel_btn.setTarget_(self)
+        cancel_btn.setAction_(objc.selector(self.cancel_, signature=b"v@:@"))
+        content.addSubview_(cancel_btn)
+
+        # Save button
+        save_btn = NSButton.alloc().initWithFrame_(NSMakeRect(window_width - padding - 100, y_pos, 100, 32))
+        save_btn.setTitle_("Save")
+        save_btn.setBezelStyle_(NSBezelStyleRounded)
+        save_btn.setTarget_(self)
+        save_btn.setAction_(objc.selector(self.save_, signature=b"v@:@"))
+        save_btn.setKeyEquivalent_("\r")
+        content.addSubview_(save_btn)
+
+        y_pos += button_area_height
+
+        # Text view
+        scroll_frame = NSMakeRect(padding, y_pos, window_width - padding * 2, text_area_height)
+        scroll_view = NSScrollView.alloc().initWithFrame_(scroll_frame)
+        scroll_view.setHasVerticalScroller_(True)
+        scroll_view.setBorderType_(1)
+
+        text_frame = NSMakeRect(0, 0, scroll_frame.size.width - 4, scroll_frame.size.height)
+        self.text_view = NSTextView.alloc().initWithFrame_(text_frame)
+        self.text_view.setFont_(NSFont.systemFontOfSize_(13))
+        scroll_view.setDocumentView_(self.text_view)
+        content.addSubview_(scroll_view)
+
+        y_pos += text_area_height + 5
+
+        # Label
+        label = NSTextField.labelWithString_("Instructions for Claude Code:")
+        label.setFrame_(NSMakeRect(padding, y_pos, 300, label_height))
+        content.addSubview_(label)
+
+        y_pos += label_height + 5
+
+        # Image view
+        image_view = NSImageView.alloc().initWithFrame_(NSMakeRect(padding, y_pos, display_width, display_height))
+        image_view.setImage_(image)
+        image_view.setImageScaling_(NSImageScaleProportionallyDown)
+        content.addSubview_(image_view)
+
+    def show(self):
+        """Display the window on top of fullscreen apps."""
+        self.window.center()
+        self.window.orderFrontRegardless()
+        self.window.makeKeyWindow()
+        self.window.makeFirstResponder_(self.text_view)
+
+    def cancel_(self, sender):
+        """Handle cancel button click."""
+        cleanup_temp_file(self.image_path)
+        self.window.close()
+
+    def save_(self, sender):
+        """Handle save button click."""
+        instructions = self.text_view.string()
+        saved_path = save_screenshot(self.image_path)
+
+        if instructions and instructions.strip():
+            add_task(instructions.strip(), saved_path)
+
+        self.window.close()
+
+
+def show_annotation_window(image_path: str) -> None:
+    """Display the annotation window for a screenshot."""
+    global _current_controller
+
+    if _current_controller and _current_controller.window:
+        _current_controller.window.close()
+
+    _current_controller = AnnotationWindowController.alloc().initWithImagePath_(image_path)
+    if _current_controller:
+        _current_controller.show()

package/python/build/lib/screenfix/clipboard_watcher.py

@@ -0,0 +1,164 @@
+"""
+Clipboard watcher for detecting new screenshots.
+
+Watches the system clipboard for new image data and triggers
+a callback when detected. Use Cmd+Ctrl+Shift+4 to copy screenshot
+to clipboard (instant, no preview delay).
+"""
+
+import os
+import time
+import threading
+from pathlib import Path
+from typing import Callable, Optional
+
+from AppKit import NSPasteboard, NSPasteboardTypePNG, NSPasteboardTypeTIFF
+from Foundation import NSData
+
+
+# Temp directory for clipboard images
+CLIPBOARD_TEMP_DIR = Path("/tmp/screenfix/clipboard")
+
+
+class ClipboardWatcher:
+    """Watches clipboard for new images."""
+
+    def __init__(self, callback: Callable[[str], None], poll_interval: float = 0.3):
+        """
+        Initialize the clipboard watcher.
+
+        Args:
+            callback: Function to call when new image detected.
+                     Called with path to saved image file.
+            poll_interval: How often to check clipboard (seconds).
+        """
+        self._callback = callback
+        self._poll_interval = poll_interval
+        self._running = False
+        self._thread: Optional[threading.Thread] = None
+        self._last_change_count = 0
+
+    def start(self):
+        """Start watching the clipboard."""
+        if self._running:
+            return
+
+        # Ensure temp directory exists
+        CLIPBOARD_TEMP_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Get initial change count
+        pasteboard = NSPasteboard.generalPasteboard()
+        self._last_change_count = pasteboard.changeCount()
+
+        self._running = True
+        self._thread = threading.Thread(target=self._watch_loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop watching the clipboard."""
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+
+    @property
+    def is_running(self) -> bool:
+        """Check if watcher is running."""
+        return self._running
+
+    def _watch_loop(self):
+        """Main watch loop running in background thread."""
+        while self._running:
+            try:
+                self._check_clipboard()
+            except Exception as e:
+                import sys
+                print(f"Clipboard watch error: {e}", file=sys.stderr)
+
+            time.sleep(self._poll_interval)
+
+    def _check_clipboard(self):
+        """Check if clipboard has new image data."""
+        pasteboard = NSPasteboard.generalPasteboard()
+        current_count = pasteboard.changeCount()
+
+        # No change
+        if current_count == self._last_change_count:
+            return
+
+        self._last_change_count = current_count
+
+        # Check for image data (PNG preferred, fallback to TIFF)
+        image_data = None
+        extension = ".png"
+
+        # Try PNG first
+        png_data = pasteboard.dataForType_(NSPasteboardTypePNG)
+        if png_data:
+            image_data = png_data
+            extension = ".png"
+        else:
+            # Try TIFF (screenshots are often TIFF on clipboard)
+            tiff_data = pasteboard.dataForType_(NSPasteboardTypeTIFF)
+            if tiff_data:
+                image_data = tiff_data
+                extension = ".tiff"
+
+        if not image_data:
+            return  # No image on clipboard
+
+        # Save to temp file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        filename = f"clipboard_{timestamp}{extension}"
+        temp_path = CLIPBOARD_TEMP_DIR / filename
+
+        # Write the image data
+        image_data.writeToFile_atomically_(str(temp_path), True)
+
+        # Clear clipboard to prevent re-triggers
+        pasteboard.clearContents()
+
+        # Convert TIFF to PNG if needed (for consistency)
+        if extension == ".tiff":
+            png_path = temp_path.with_suffix(".png")
+            if self._convert_to_png(temp_path, png_path):
+                os.remove(temp_path)
+                temp_path = png_path
+
+        # Trigger callback
+        self._callback(str(temp_path))
+
+    def _convert_to_png(self, tiff_path: Path, png_path: Path) -> bool:
+        """Convert TIFF to PNG using CoreGraphics."""
+        try:
+            from Quartz import (
+                CGImageSourceCreateWithURL,
+                CGImageSourceCreateImageAtIndex,
+                CGImageDestinationCreateWithURL,
+                CGImageDestinationAddImage,
+                CGImageDestinationFinalize,
+                kCGImagePropertyOrientation,
+            )
+            from Foundation import NSURL
+
+            # Read TIFF
+            source_url = NSURL.fileURLWithPath_(str(tiff_path))
+            source = CGImageSourceCreateWithURL(source_url, None)
+            if not source:
+                return False
+
+            image = CGImageSourceCreateImageAtIndex(source, 0, None)
+            if not image:
+                return False
+
+            # Write PNG
+            dest_url = NSURL.fileURLWithPath_(str(png_path))
+            destination = CGImageDestinationCreateWithURL(dest_url, "public.png", 1, None)
+            if not destination:
+                return False
+
+            CGImageDestinationAddImage(destination, image, None)
+            return CGImageDestinationFinalize(destination)
+
+        except Exception:
+            return False

package/python/build/lib/screenfix/config.py

@@ -0,0 +1,66 @@
+"""Configuration management for ScreenFix."""
+
+import os
+import json
+from pathlib import Path
+
+DEFAULT_CONFIG = {
+    "save_directory": "./screenfix/screenshots",
+    "tasks_file": "./screenfix/tasks/screenfix-tasks.md",
+}
+
+CONFIG_DIR = Path.home() / ".config" / "screenfix"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+class Config:
+    """Configuration manager for ScreenFix."""
+
+    def __init__(self):
+        self._config = DEFAULT_CONFIG.copy()
+        self._load()
+
+    def _load(self):
+        """Load configuration from file."""
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE, "r") as f:
+                    saved = json.load(f)
+                    self._config.update(saved)
+            except (json.JSONDecodeError, IOError):
+                pass
+
+    def save(self):
+        """Save configuration to file."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(self._config, f, indent=2)
+
+    @property
+    def save_directory(self) -> str:
+        """Directory where screenshots are saved."""
+        return self._config["save_directory"]
+
+    @save_directory.setter
+    def save_directory(self, value: str):
+        self._config["save_directory"] = os.path.expanduser(value)
+        self.save()
+
+    @property
+    def tasks_file(self) -> str:
+        """Path to the tasks.md file."""
+        return self._config["tasks_file"]
+
+    @tasks_file.setter
+    def tasks_file(self, value: str):
+        self._config["tasks_file"] = os.path.expanduser(value)
+        self.save()
+
+    def ensure_directories(self):
+        """Ensure save and tasks directories exist."""
+        Path(self.save_directory).mkdir(parents=True, exist_ok=True)
+        Path(self.tasks_file).parent.mkdir(parents=True, exist_ok=True)
+
+
+# Global config instance
+config = Config()

package/python/build/lib/screenfix/daemon.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+ScreenFix Daemon - Clipboard watcher for instant screenshot capture.
+
+Watches the clipboard for new images and shows annotation window instantly.
+Use Cmd+Ctrl+Shift+4 to capture screenshot to clipboard (no preview delay).
+
+Run with: python -m screenfix.daemon
+"""
+
+import json
+import os
+import queue
+import signal
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from AppKit import (
+    NSApplication,
+    NSApplicationActivationPolicyAccessory,
+    NSEventMaskAny,
+)
+from Foundation import NSDate, NSDefaultRunLoopMode
+
+from .config import config
+
+
+# State file for communication with MCP server
+STATE_FILE = Path.home() / ".config" / "screenfix" / "state.json"
+
+
+def update_state(listening: bool = None, last_capture: str = None):
+    """Update the state file for MCP server to read."""
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    state = {"pid": os.getpid(), "listening": False}
+
+    if STATE_FILE.exists():
+        try:
+            with open(STATE_FILE, "r") as f:
+                state = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    state["pid"] = os.getpid()
+    if listening is not None:
+        state["listening"] = listening
+    if last_capture is not None:
+        state["last_capture"] = last_capture
+        state["last_capture_time"] = datetime.now().isoformat()
+
+    with open(STATE_FILE, "w") as f:
+        json.dump(state, f, indent=2)
+
+
+def clear_state():
+    """Clear the state file on exit."""
+    if STATE_FILE.exists():
+        try:
+            os.remove(STATE_FILE)
+        except OSError:
+            pass
+
+
+class ScreenFixDaemon:
+    """Daemon that watches clipboard for screenshots."""
+
+    def __init__(self):
+        self._running = False
+        self._clipboard_watcher = None
+        self._app = None
+        self._main_thread_queue = queue.Queue()
+
+    def _on_clipboard_image(self, image_path: str):
+        """Called when a new image is detected on clipboard."""
+        print(f"Screenshot detected: {image_path}", file=sys.stderr)
+        self._main_thread_queue.put(image_path)
+
+    def _process_main_thread_queue(self):
+        """Process any pending work on the main thread."""
+        try:
+            while True:
+                image_path = self._main_thread_queue.get_nowait()
+                self._show_annotation(image_path)
+        except queue.Empty:
+            pass
+
+    def _show_annotation(self, image_path: str):
+        """Show the annotation window. Must be called from main thread."""
+        from .annotation_window import show_annotation_window
+        show_annotation_window(image_path)
+
+    def _setup_signal_handlers(self):
+        """Set up signal handlers for graceful shutdown."""
+        def handle_signal(signum, frame):
+            print(f"\nShutting down...", file=sys.stderr)
+            self.stop()
+
+        signal.signal(signal.SIGINT, handle_signal)
+        signal.signal(signal.SIGTERM, handle_signal)
+
+    def start(self):
+        """Start the daemon."""
+        if self._running:
+            return
+
+        self._running = True
+        config.ensure_directories()
+
+        # Initialize NSApplication for UI
+        self._app = NSApplication.sharedApplication()
+        self._app.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
+        self._app.finishLaunching()
+
+        self._setup_signal_handlers()
+
+        print("ScreenFix daemon started", file=sys.stderr)
+        print(f"Screenshots will be saved to: {config.save_directory}", file=sys.stderr)
+        print(f"Tasks will be saved to: {config.tasks_file}", file=sys.stderr)
+        print("\nUse Cmd+Ctrl+Shift+4 to capture (INSTANT, no delay!)", file=sys.stderr)
+        print("Press Ctrl+C to stop.\n", file=sys.stderr)
+
+        # Start clipboard watcher
+        from .clipboard_watcher import ClipboardWatcher
+        self._clipboard_watcher = ClipboardWatcher(self._on_clipboard_image)
+        self._clipboard_watcher.start()
+
+        update_state(listening=True)
+
+        # Run the main loop
+        while self._running:
+            self._process_main_thread_queue()
+
+            while True:
+                event = self._app.nextEventMatchingMask_untilDate_inMode_dequeue_(
+                    NSEventMaskAny,
+                    NSDate.dateWithTimeIntervalSinceNow_(0.05),
+                    NSDefaultRunLoopMode,
+                    True
+                )
+                if event is None:
+                    break
+                self._app.sendEvent_(event)
+
+    def stop(self):
+        """Stop the daemon."""
+        self._running = False
+
+        if self._clipboard_watcher:
+            self._clipboard_watcher.stop()
+            self._clipboard_watcher = None
+
+        clear_state()
+
+        if self._app:
+            self._app.terminate_(None)
+
+
+def is_daemon_running() -> bool:
+    """Check if the daemon is already running."""
+    if not STATE_FILE.exists():
+        return False
+
+    try:
+        with open(STATE_FILE, "r") as f:
+            state = json.load(f)
+
+        pid = state.get("pid")
+        if pid:
+            try:
+                os.kill(pid, 0)
+                return True
+            except OSError:
+                clear_state()
+                return False
+    except (json.JSONDecodeError, IOError):
+        return False
+
+    return False
+
+
+def main():
+    """Main entry point."""
+    if is_daemon_running():
+        print("ScreenFix daemon is already running!", file=sys.stderr)
+        sys.exit(1)
+
+    daemon = ScreenFixDaemon()
+
+    try:
+        daemon.start()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+    finally:
+        daemon.stop()
+
+
+if __name__ == "__main__":
+    main()