create-screenfix 0.1.0

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

@@ -0,0 +1,318 @@
+"""MCP server for ScreenFix."""
+
+import asyncio
+import base64
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent, ImageContent
+
+from .config import config
+from .task_tracker import get_tasks, get_pending_tasks, mark_task_complete
+
+
+STATE_FILE = Path.home() / ".config" / "screenfix" / "state.json"
+
+
+def get_daemon_state() -> dict:
+    """Read the daemon state file."""
+    if not STATE_FILE.exists():
+        return {"running": False, "listening": False}
+
+    try:
+        with open(STATE_FILE, "r") as f:
+            state = json.load(f)
+
+        pid = state.get("pid")
+        if pid:
+            try:
+                os.kill(pid, 0)
+                state["running"] = True
+            except OSError:
+                state["running"] = False
+        else:
+            state["running"] = False
+
+        return state
+    except (json.JSONDecodeError, IOError):
+        return {"running": False, "listening": False}
+
+
+def get_screenshots() -> list[dict]:
+    """Get list of screenshots."""
+    save_dir = Path(config.save_directory)
+    if not save_dir.exists():
+        return []
+
+    screenshots = []
+    for f in save_dir.glob("*.png"):
+        screenshots.append({
+            "path": str(f),
+            "filename": f.name,
+            "modified": f.stat().st_mtime,
+        })
+
+    screenshots.sort(key=lambda x: x["modified"], reverse=True)
+    return screenshots
+
+
+def get_last_screenshot() -> dict | None:
+    """Get the most recent screenshot."""
+    screenshots = get_screenshots()
+    return screenshots[0] if screenshots else None
+
+
+def start_daemon() -> tuple[bool, str]:
+    """Start the daemon as a background process."""
+    state = get_daemon_state()
+    if state.get("running"):
+        return True, "Daemon is already running"
+
+    try:
+        log_dir = Path.home() / ".config" / "screenfix"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "daemon.log"
+
+        with open(log_file, "a") as log:
+            subprocess.Popen(
+                [sys.executable, "-m", "screenfix.daemon"],
+                cwd=os.getcwd(),
+                stdout=log,
+                stderr=log,
+                start_new_session=True,
+            )
+
+        time.sleep(0.5)
+
+        new_state = get_daemon_state()
+        if new_state.get("running"):
+            return True, f"Daemon started (PID: {new_state.get('pid')}). Use Cmd+Ctrl+Shift+4 to capture."
+        else:
+            return True, f"Daemon starting... Check logs at {log_file}"
+
+    except Exception as e:
+        return False, f"Failed to start daemon: {e}"
+
+
+def stop_daemon() -> tuple[bool, str]:
+    """Stop the daemon."""
+    state = get_daemon_state()
+    if not state.get("running"):
+        return True, "Daemon is not running"
+
+    pid = state.get("pid")
+    if pid:
+        try:
+            os.kill(pid, 15)
+            return True, "Daemon stopped"
+        except OSError as e:
+            return False, f"Failed to stop daemon: {e}"
+
+    return False, "Could not find daemon PID"
+
+
+def create_server() -> Server:
+    """Create the MCP server."""
+    server = Server("screenfix")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name="start_daemon",
+                description="Start ScreenFix daemon. Use Cmd+Ctrl+Shift+4 to capture screenshots instantly.",
+                inputSchema={"type": "object", "properties": {}, "required": []},
+            ),
+            Tool(
+                name="stop_daemon",
+                description="Stop the ScreenFix daemon",
+                inputSchema={"type": "object", "properties": {}, "required": []},
+            ),
+            Tool(
+                name="get_status",
+                description="Get ScreenFix status",
+                inputSchema={"type": "object", "properties": {}, "required": []},
+            ),
+            Tool(
+                name="get_last_screenshot",
+                description="Get the most recent screenshot with its image and related task",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "include_image": {
+                            "type": "boolean",
+                            "description": "Include image data",
+                            "default": True,
+                        }
+                    },
+                    "required": [],
+                },
+            ),
+            Tool(
+                name="list_screenshots",
+                description="List all screenshots",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "limit": {"type": "integer", "default": 10}
+                    },
+                    "required": [],
+                },
+            ),
+            Tool(
+                name="get_tasks",
+                description="Get tasks from tasks.md",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "pending_only": {"type": "boolean", "default": False}
+                    },
+                    "required": [],
+                },
+            ),
+            Tool(
+                name="complete_task",
+                description="Mark a task as complete",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_text": {"type": "string", "description": "Task text to mark complete"}
+                    },
+                    "required": ["task_text"],
+                },
+            ),
+            Tool(
+                name="read_screenshot",
+                description="Read a specific screenshot by path",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string", "description": "Path to screenshot"}
+                    },
+                    "required": ["path"],
+                },
+            ),
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent | ImageContent]:
+
+        if name == "start_daemon":
+            success, message = start_daemon()
+            return [TextContent(type="text", text=message)]
+
+        elif name == "stop_daemon":
+            success, message = stop_daemon()
+            return [TextContent(type="text", text=message)]
+
+        elif name == "get_status":
+            state = get_daemon_state()
+            screenshots = get_screenshots()
+            tasks = get_pending_tasks()
+
+            status = "Running" if state.get("running") else "Not running"
+            text = f"""ScreenFix Status:
+- Daemon: {status}
+- Screenshots: {len(screenshots)}
+- Pending tasks: {len(tasks)}
+
+Use Cmd+Ctrl+Shift+4 to capture (instant, no delay)"""
+            return [TextContent(type="text", text=text)]
+
+        elif name == "get_last_screenshot":
+            include_image = arguments.get("include_image", True)
+            screenshot = get_last_screenshot()
+
+            if not screenshot:
+                return [TextContent(type="text", text="No screenshots found. Use Cmd+Ctrl+Shift+4 to capture.")]
+
+            result = [TextContent(type="text", text=f"Screenshot: {screenshot['path']}")]
+
+            if include_image and os.path.exists(screenshot["path"]):
+                with open(screenshot["path"], "rb") as f:
+                    image_data = base64.standard_b64encode(f.read()).decode("utf-8")
+                result.append(ImageContent(type="image", data=image_data, mimeType="image/png"))
+
+            tasks = get_tasks()
+            for task in tasks:
+                if task.get("screenshot") == screenshot["path"]:
+                    result.append(TextContent(
+                        type="text",
+                        text=f"\nTask: {task['text']}\nStatus: {'Done' if task['completed'] else 'Pending'}"
+                    ))
+                    break
+
+            return result
+
+        elif name == "list_screenshots":
+            limit = arguments.get("limit", 10)
+            screenshots = get_screenshots()[:limit]
+
+            if not screenshots:
+                return [TextContent(type="text", text="No screenshots found.")]
+
+            lines = ["Screenshots:"]
+            for i, s in enumerate(screenshots, 1):
+                lines.append(f"{i}. {s['filename']}")
+
+            return [TextContent(type="text", text="\n".join(lines))]
+
+        elif name == "get_tasks":
+            pending_only = arguments.get("pending_only", False)
+            tasks = get_pending_tasks() if pending_only else get_tasks()
+
+            if not tasks:
+                return [TextContent(type="text", text="No tasks found.")]
+
+            lines = ["Tasks:"]
+            for i, task in enumerate(tasks, 1):
+                status = "[x]" if task["completed"] else "[ ]"
+                lines.append(f"{i}. {status} {task['text']}")
+
+            return [TextContent(type="text", text="\n".join(lines))]
+
+        elif name == "complete_task":
+            task_text = arguments.get("task_text", "")
+            if mark_task_complete(task_text):
+                return [TextContent(type="text", text=f"Completed: {task_text}")]
+            return [TextContent(type="text", text=f"Task not found: {task_text}")]
+
+        elif name == "read_screenshot":
+            path = arguments.get("path", "")
+            if not path or not os.path.exists(path):
+                return [TextContent(type="text", text=f"Not found: {path}")]
+
+            with open(path, "rb") as f:
+                image_data = base64.standard_b64encode(f.read()).decode("utf-8")
+
+            return [
+                TextContent(type="text", text=f"Screenshot: {path}"),
+                ImageContent(type="image", data=image_data, mimeType="image/png"),
+            ]
+
+        return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+    return server
+
+
+async def run_server():
+    """Run the MCP server."""
+    server = create_server()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main():
+    """Main entry point."""
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,129 @@
+"""Task tracker for managing tasks.md file."""
+
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from .config import config
+
+
+def add_task(instruction: str, screenshot_path: Optional[str] = None) -> str:
+    """
+    Add a task to the tasks.md file.
+
+    Args:
+        instruction: Task instruction text
+        screenshot_path: Optional path to related screenshot
+
+    Returns:
+        The formatted task entry that was added
+    """
+    tasks_path = Path(config.tasks_file)
+
+    # Create parent directory if needed
+    tasks_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create file with header if it doesn't exist
+    if not tasks_path.exists():
+        with open(tasks_path, "w") as f:
+            f.write("# Tasks for Claude Code\n\n")
+
+    # Format the task entry
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    # Build task lines
+    task_lines = [f"- [ ] {instruction.strip()}"]
+
+    # Add screenshot reference if provided
+    if screenshot_path:
+        task_lines.append(f"  - Screenshot: `{screenshot_path}`")
+
+    task_lines.append(f"  - Added: {timestamp}")
+    task_lines.append("")  # Blank line after entry
+
+    task_entry = "\n".join(task_lines) + "\n"
+
+    # Append to file
+    with open(tasks_path, "a") as f:
+        f.write(task_entry)
+
+    return task_entry
+
+
+def get_tasks() -> list[dict]:
+    """
+    Read all tasks from tasks.md.
+
+    Returns:
+        List of task dictionaries with keys: text, completed, screenshot, added
+    """
+    tasks_path = Path(config.tasks_file)
+
+    if not tasks_path.exists():
+        return []
+
+    tasks = []
+    current_task = None
+
+    with open(tasks_path, "r") as f:
+        for line in f:
+            # Check for task line
+            if line.startswith("- [ ] ") or line.startswith("- [x] "):
+                if current_task:
+                    tasks.append(current_task)
+                completed = line.startswith("- [x] ")
+                current_task = {
+                    "text": line[6:].strip(),
+                    "completed": completed,
+                    "screenshot": None,
+                    "added": None,
+                }
+            elif current_task and line.strip().startswith("- Screenshot:"):
+                # Extract screenshot path
+                path = line.strip()[14:].strip().strip("`")
+                current_task["screenshot"] = path
+            elif current_task and line.strip().startswith("- Added:"):
+                # Extract timestamp
+                current_task["added"] = line.strip()[9:].strip()
+
+        # Don't forget the last task
+        if current_task:
+            tasks.append(current_task)
+
+    return tasks
+
+
+def get_pending_tasks() -> list[dict]:
+    """Get only incomplete tasks."""
+    return [t for t in get_tasks() if not t["completed"]]
+
+
+def mark_task_complete(task_text: str) -> bool:
+    """
+    Mark a task as complete by its text.
+
+    Args:
+        task_text: The task text to find and mark complete
+
+    Returns:
+        True if task was found and marked, False otherwise
+    """
+    tasks_path = Path(config.tasks_file)
+
+    if not tasks_path.exists():
+        return False
+
+    with open(tasks_path, "r") as f:
+        content = f.read()
+
+    # Find and replace the checkbox
+    search = f"- [ ] {task_text}"
+    replace = f"- [x] {task_text}"
+
+    if search in content:
+        content = content.replace(search, replace, 1)
+        with open(tasks_path, "w") as f:
+            f.write(content)
+        return True
+
+    return False

package/python/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "screenfix"
+version = "0.1.0"
+description = "Screenshot capture tool for Claude Code via MCP"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.0.0",
+    "pyobjc-core>=10.0",
+    "pyobjc-framework-Cocoa>=10.0",
+    "pyobjc-framework-Quartz>=10.0",
+    "Pillow>=10.0.0",
+]
+
+[project.scripts]
+screenfix-daemon = "screenfix.daemon:main"
+screenfix-mcp = "screenfix.mcp_server:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

package/python/requirements.txt

@@ -0,0 +1,5 @@
+mcp>=1.0.0
+pyobjc-core>=10.0
+pyobjc-framework-Cocoa>=10.0
+pyobjc-framework-Quartz>=10.0
+Pillow>=10.0.0

package/python/screenfix/__init__.py

@@ -0,0 +1,3 @@
+"""ScreenFix - Screen snipping tool integrated with Claude Code via MCP."""
+
+__version__ = "0.1.0"

package/python/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()