appsnap 0.2.0__py3-none-any.whl

appsnap/__init__.py

@@ -0,0 +1,15 @@
+"""appsnap - Fast Windows screenshot tool for AI coding agents."""
+
+__version__ = "0.2.0"
+__author__ = "appsnap contributors"
+__license__ = "MIT"
+
+from appsnap.windows import find_all_windows, find_window
+from appsnap.capture import capture_window as capture_window_screenshot
+
+__all__ = [
+    "find_all_windows",
+    "find_window",
+    "capture_window_screenshot",
+    "__version__",
+]

appsnap/__main__.py

@@ -0,0 +1,292 @@
+"""Main CLI entry point for appsnap."""
+
+import argparse
+import json
+import sys
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import NoReturn, Optional
+
+from appsnap import __version__
+from appsnap.capture import capture_window as capture_window_screenshot, validate_output_path
+from appsnap.windows import find_window, get_window_list_formatted, find_all_windows
+
+
+def list_windows() -> None:
+    """List all capturable windows and exit."""
+    windows = get_window_list_formatted()
+
+    if not windows:
+        print("No windows found.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Found {len(windows)} window(s):\n")
+    for title in windows:
+        print(f"  • {title}")
+
+    sys.exit(0)
+
+
+def generate_temp_path() -> str:
+    """
+    Generate a timestamped filename in the system temp directory.
+
+    Returns:
+        Full path to temp file like: /tmp/appsnap_YYYYMMDD_HHMMSS.png
+    """
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"appsnap_{timestamp}.png"
+    temp_dir = Path(tempfile.gettempdir()) / "appsnap"
+    temp_dir.mkdir(exist_ok=True)
+    return str(temp_dir / filename)
+
+
+def sanitize_filename(title: str) -> str:
+    """
+    Sanitize window title for use as filename.
+
+    Args:
+        title: Window title to sanitize
+
+    Returns:
+        Safe filename string
+    """
+    # Replace invalid filename characters
+    invalid_chars = '<>:"/\\|?*'
+    for char in invalid_chars:
+        title = title.replace(char, '_')
+    # Limit length and strip whitespace
+    title = title.strip()[:100]
+    return title if title else "untitled"
+
+
+def capture_all_windows(output_dir: str, json_output: bool) -> None:
+    """
+    Capture screenshots of all windows to a directory.
+
+    Args:
+        output_dir: Directory to save all screenshots
+        json_output: Whether to output JSON summary
+    """
+    windows = find_all_windows()
+
+    if not windows:
+        print("No windows found.", file=sys.stderr)
+        sys.exit(1)
+
+    # Create output directory
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    # Track duplicate titles for numbering
+    title_counts = {}
+    results = []
+    successful = 0
+    failed = 0
+
+    print(
+        f"Capturing {len(windows)} window(s) to {output_path.resolve()}...\n")
+
+    for window in windows:
+        title = window["title"]
+        handle = window["handle"]
+
+        # Handle duplicate titles with counter
+        if title in title_counts:
+            title_counts[title] += 1
+            safe_title = sanitize_filename(title)
+            filename = f"{safe_title}_{title_counts[title]}.png"
+        else:
+            title_counts[title] = 1
+            safe_title = sanitize_filename(title)
+            filename = f"{safe_title}.png"
+
+        output_file = output_path / filename
+
+        try:
+            capture_window_screenshot(handle, str(output_file))
+            print(f"[OK] {title}")
+            results.append({
+                "window": title,
+                "path": str(output_file.resolve()),
+                "status": "success"
+            })
+            successful += 1
+        except Exception as e:
+            print(f"[FAIL] {title}: {e}", file=sys.stderr)
+            results.append({
+                "window": title,
+                "status": "failed",
+                "error": str(e)
+            })
+            failed += 1
+
+    # Summary
+    print(f"\nComplete: {successful} successful, {failed} failed")
+    print(f"Screenshots saved to: {output_path.resolve()}")
+
+    # JSON output if requested
+    if json_output:
+        summary = {
+            "output_dir": str(output_path.resolve()),
+            "total": len(windows),
+            "successful": successful,
+            "failed": failed,
+            "results": results
+        }
+        print(json.dumps(summary, indent=2))
+
+
+def capture_window(
+    window_name: str, output_path: Optional[str], threshold: int, json_output: bool
+) -> None:
+    """
+    Capture a window screenshot and output the result.
+
+    Args:
+        window_name: Window title to search for
+        output_path: Custom output path, or None for temp directory
+        threshold: Fuzzy matching threshold (0-100)
+        json_output: Whether to output JSON format
+    """
+    # Find the window
+    window = find_window(window_name, threshold=threshold)
+
+    if not window:
+        print(
+            f'Error: No window found matching "{window_name}" (threshold: {threshold})',
+            file=sys.stderr,
+        )
+        print("\nTip: Use 'appsnap --list' to see all available windows",
+              file=sys.stderr)
+        print("     Or try lowering the threshold with '--threshold 60'",
+              file=sys.stderr)
+        sys.exit(1)
+
+    # Determine output path
+    if output_path is None:
+        output_path = generate_temp_path()
+    else:
+        # Validate custom path
+        try:
+            validate_output_path(output_path)
+        except ValueError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Capture the screenshot
+    try:
+        capture_window_screenshot(window["handle"], output_path)
+    except ValueError as e:
+        print(f"Error capturing screenshot: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Output results
+    if json_output:
+        result = {
+            "path": str(Path(output_path).resolve()),
+            "window": window["title"],
+            "bbox": list(window["bbox"]),
+        }
+        print(json.dumps(result, indent=2))
+    else:
+        print(str(Path(output_path).resolve()))
+        if output_path.startswith(tempfile.gettempdir()):
+            print(f"Window: {window['title']}", file=sys.stderr)
+            print(f"Note: Temp files may be auto-deleted by the system",
+                  file=sys.stderr)
+
+
+def main() -> NoReturn:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="appsnap",
+        description="Fast Windows screenshot tool for AI coding agents",
+        epilog='Example: appsnap "Visual Studio Code" --output screenshot.png',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "window_name",
+        nargs="?",
+        help="Window title to search for (supports fuzzy matching)",
+    )
+
+    parser.add_argument(
+        "-l",
+        "--list",
+        action="store_true",
+        help="List all capturable windows and exit",
+    )
+
+    parser.add_argument(
+        "-a",
+        "--all",
+        metavar="DIR",
+        help="Capture all windows to specified directory",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="PATH",
+        help="Output file path (default: temp directory with timestamp)",
+    )
+
+    parser.add_argument(
+        "-t",
+        "--threshold",
+        type=int,
+        default=70,
+        metavar="N",
+        help="Fuzzy match threshold 0-100 (default: 70, lower = more lenient)",
+    )
+
+    parser.add_argument(
+        "-j",
+        "--json",
+        action="store_true",
+        help="Output result as JSON with path and metadata",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"appsnap {__version__}",
+        help="Show version and exit",
+    )
+
+    args = parser.parse_args()
+
+    # Handle --list flag
+    if args.list:
+        list_windows()
+
+    # Handle --all flag
+    if args.all:
+        capture_all_windows(args.all, args.json)
+        sys.exit(0)
+
+    # Validate arguments
+    if not args.window_name:
+        parser.print_help()
+        sys.exit(1)
+
+    # Validate threshold range
+    if not 0 <= args.threshold <= 100:
+        print("Error: Threshold must be between 0 and 100", file=sys.stderr)
+        sys.exit(1)
+
+    # Capture window screenshot
+    capture_window(args.window_name, args.output, args.threshold, args.json)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

appsnap/capture.py

@@ -0,0 +1,137 @@
+"""Screenshot capture utilities using Win32 PrintWindow with fallback."""
+
+import ctypes
+from ctypes import windll
+from pathlib import Path
+import time
+
+from PIL import Image, ImageGrab
+import win32gui
+import win32ui
+import win32con
+
+
+def capture_window(hwnd: int, output_path: str) -> None:
+    """
+    Capture a screenshot of a specific window by handle.
+
+    Tries Win32 PrintWindow API first for direct window content capture.
+    Falls back to screen region capture if PrintWindow fails (protected apps).
+
+    Args:
+        hwnd: Window handle (HWND) to capture
+        output_path: File path where screenshot will be saved (PNG format)
+
+    Raises:
+        ValueError: If window cannot be captured
+        OSError: If screenshot cannot be saved
+
+    Example:
+        >>> hwnd = 12345  # Window handle
+        >>> capture_window(hwnd, "screenshot.png")
+    """
+    # Validate window is visible
+    if not win32gui.IsWindow(hwnd) or not win32gui.IsWindowVisible(hwnd):
+        raise ValueError("Window is not visible or invalid handle")
+
+    # Check if window is minimized
+    if win32gui.IsIconic(hwnd):
+        raise ValueError("Window is minimized - cannot capture")
+
+    # Get window dimensions
+    left, top, right, bottom = win32gui.GetWindowRect(hwnd)
+    width = right - left
+    height = bottom - top
+
+    if width <= 0 or height <= 0:
+        raise ValueError(f"Invalid window dimensions: {width}x{height}")
+
+    # Ensure output directory exists
+    output_path_obj = Path(output_path)
+    output_path_obj.parent.mkdir(parents=True, exist_ok=True)
+
+    # Try PrintWindow first (works for most apps, even when partially occluded)
+    try:
+        hwndDC = win32gui.GetWindowDC(hwnd)
+        mfcDC = win32ui.CreateDCFromHandle(hwndDC)
+        saveDC = mfcDC.CreateCompatibleDC()
+
+        saveBitMap = win32ui.CreateBitmap()
+        saveBitMap.CreateCompatibleBitmap(mfcDC, width, height)
+        saveDC.SelectObject(saveBitMap)
+
+        # PW_RENDERFULLCONTENT (0x00000002)
+        result = windll.user32.PrintWindow(hwnd, saveDC.GetSafeHdc(), 2)
+
+        if result != 0:
+            # PrintWindow succeeded
+            bmpinfo = saveBitMap.GetInfo()
+            bmpstr = saveBitMap.GetBitmapBits(True)
+            img = Image.frombuffer(
+                'RGB',
+                (bmpinfo['bmWidth'], bmpinfo['bmHeight']),
+                bmpstr, 'raw', 'BGRX', 0, 1
+            )
+
+            # Clean up
+            win32gui.DeleteObject(saveBitMap.GetHandle())
+            saveDC.DeleteDC()
+            mfcDC.DeleteDC()
+            win32gui.ReleaseDC(hwnd, hwndDC)
+
+            img.save(str(output_path_obj), "PNG")
+            return
+
+        # PrintWindow failed, clean up before fallback
+        win32gui.DeleteObject(saveBitMap.GetHandle())
+        saveDC.DeleteDC()
+        mfcDC.DeleteDC()
+        win32gui.ReleaseDC(hwnd, hwndDC)
+
+    except Exception:
+        pass  # Fall through to ImageGrab fallback
+
+    # Fallback: Use PIL ImageGrab for screen region capture
+    # This works for protected windows but requires them to be visible
+    try:
+        # Try to bring window to foreground for better capture
+        try:
+            win32gui.SetForegroundWindow(hwnd)
+            time.sleep(0.05)  # Brief pause for window to come to front
+        except:
+            pass  # Some windows don't allow foreground activation
+
+        # Capture the screen region where the window is located
+        img = ImageGrab.grab(bbox=(left, top, right, bottom), all_screens=True)
+
+        if img is None or img.size[0] == 0 or img.size[1] == 0:
+            raise ValueError("Captured image is empty")
+
+        img.save(str(output_path_obj), "PNG")
+        return
+
+    except Exception as e:
+        raise ValueError(f"Failed to capture window: {e}")
+
+
+def validate_output_path(path: str) -> None:
+    """
+    Validate that an output path is usable.
+
+    Args:
+        path: File path to validate
+
+    Raises:
+        ValueError: If path is invalid or points to a directory
+    """
+    output_path = Path(path)
+
+    # Check if path points to an existing directory
+    if output_path.exists() and output_path.is_dir():
+        raise ValueError(f"Output path is a directory: {path}")
+
+    # Check if parent directory can be created/accessed
+    try:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise ValueError(f"Cannot create parent directory for {path}: {e}")

appsnap/windows.py

@@ -0,0 +1,115 @@
+"""Window enumeration and finding utilities for Windows."""
+
+import ctypes
+from typing import Dict, List, Optional
+
+import win32gui
+from fuzzywuzzy import process
+
+# DPI awareness setup (from Windows-MCP pattern)
+PROCESS_PER_MONITOR_DPI_AWARE = 2
+
+
+def setup_dpi_awareness() -> None:
+    """
+    Set up DPI awareness for accurate window coordinate retrieval.
+
+    Uses Per-Monitor DPI Awareness (v2) if available, falls back to basic DPI awareness.
+    """
+    try:
+        ctypes.windll.shcore.SetProcessDpiAwareness(
+            PROCESS_PER_MONITOR_DPI_AWARE)
+    except Exception:
+        # Fallback for older Windows versions
+        ctypes.windll.user32.SetProcessDPIAware()
+
+
+def find_all_windows() -> List[Dict[str, any]]:
+    """
+    Enumerate all visible windows with titles.
+
+    Returns:
+        List of window dictionaries containing:
+            - handle: Window handle (HWND)
+            - title: Window title text
+            - bbox: Bounding box tuple (left, top, right, bottom)
+    """
+    windows = []
+
+    def callback(hwnd, _):
+        if win32gui.IsWindow(hwnd) and win32gui.IsWindowVisible(hwnd):
+            # Skip minimized windows
+            if win32gui.IsIconic(hwnd):
+                return
+
+            title = win32gui.GetWindowText(hwnd)
+            if title:  # Only include windows with titles
+                try:
+                    left, top, right, bottom = win32gui.GetWindowRect(hwnd)
+                    # Filter out windows with invalid dimensions
+                    if right > left and bottom > top:
+                        windows.append(
+                            {
+                                "handle": hwnd,
+                                "title": title,
+                                "bbox": (left, top, right, bottom),
+                            }
+                        )
+                except Exception:
+                    # Skip windows that can't be queried
+                    pass
+
+    win32gui.EnumWindows(callback, None)
+    return windows
+
+
+def find_window(window_name: str, threshold: int = 70) -> Optional[Dict[str, any]]:
+    """
+    Find a window by fuzzy name matching.
+
+    Args:
+        window_name: Window title to search for (partial matches supported)
+        threshold: Fuzzy match threshold 0-100 (default 70).
+                  Higher = stricter matching, lower = more lenient.
+
+    Returns:
+        Window dictionary with handle, title, and bbox, or None if not found.
+
+    Example:
+        >>> window = find_window("Visual Studio")
+        >>> if window:
+        ...     print(f"Found: {window['title']}")
+        ...     print(f"Bbox: {window['bbox']}")
+    """
+    windows = find_all_windows()
+    if not windows:
+        return None
+
+    # Create mapping of titles to window data
+    window_titles = {w["title"]: w for w in windows}
+
+    # Fuzzy match against all window titles
+    match = process.extractOne(
+        window_name, list(window_titles.keys()), score_cutoff=threshold
+    )
+
+    if match:
+        matched_title = match[0]
+        return window_titles[matched_title]
+
+    return None
+
+
+def get_window_list_formatted() -> List[str]:
+    """
+    Get a sorted list of all window titles for display.
+
+    Returns:
+        Sorted list of window title strings.
+    """
+    windows = find_all_windows()
+    return sorted([w["title"] for w in windows])
+
+
+# Initialize DPI awareness when module is imported
+setup_dpi_awareness()

appsnap-0.2.0.dist-info/METADATA

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: appsnap
+Version: 0.2.0
+Summary: Fast Windows screenshot tool for AI coding agents
+Project-URL: Homepage, https://github.com/detroittommy879/appsnap
+Project-URL: Repository, https://github.com/detroittommy879/appsnap
+Project-URL: Issues, https://github.com/detroittommy879/appsnap/issues
+Project-URL: Documentation, https://github.com/detroittommy879/appsnap#readme
+Project-URL: Changelog, https://github.com/detroittommy879/appsnap/releases
+Author: appsnap contributors
+License: MIT
+License-File: LICENSE
+Keywords: ai-agent,automation,cli,desktop,screenshot,windows
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: fuzzywuzzy>=0.18.0
+Requires-Dist: pillow>=11.0.0
+Requires-Dist: python-levenshtein>=0.25.0
+Requires-Dist: pywin32>=306
+Provides-Extra: dev
+Requires-Dist: black>=24.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.3.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# 📸 appsnap
+
+**Fast Windows screenshot tool for AI coding agents**
+
+`appsnap` is a simple, fast CLI tool for capturing screenshots of Windows application windows. Perfect for AI agents that need to verify UI changes during development iterations.
+
+## ✨ Features
+
+- 🎯 **Window-specific capture** - Target apps by name with fuzzy matching
+- � **Bulk capture** - Screenshot all windows at once for testing
+- 🚀 **Fast** - Screenshots in ~0.1-0.3 seconds
+- 🤖 **Agent-friendly** - JSON output and stdout paths for easy parsing
+- 📁 **Smart defaults** - Temp directory with auto-cleanup
+- 🔍 **List windows** - See all capturable windows
+- 🎨 **DPI-aware** - Handles high-DPI displays correctly
+- 🔢 **Duplicate handling** - Auto-numbers windows with identical titles
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Install from PyPI with uvx (recommended)
+uvx appsnap
+
+# Or install as a tool with uv
+uv tool install appsnap
+
+# Or with pipx
+pipx install appsnap
+
+# Install from GitHub (development version)
+uv tool install git+https://github.com/detroittommy879/appsnap.git
+
+# Development mode (local testing)
+git clone https://github.com/detroittommy879/appsnap.git
+cd appsnap
+uv venv
+uv pip install -e .
+```
+
+### Usage
+
+**Option 1: After activating venv**
+
+```bash
+# Activate the virtual environment first
+.venv\Scripts\activate  # Windows
+# source .venv/bin/activate  # Linux/Mac
+
+# Then use appsnap directly
+appsnap --list
+appsnap "Visual Studio Code"
+```
+
+**Option 2: Using uv run (no activation needed)**
+
+```bash
+# Run from within the appsnap directory
+cd appsnap
+uv run appsnap --list
+uv run appsnap "Chrome" --output screenshot.png
+```
+
+**Common Commands:**
+
+```bash
+# List all capturable windows
+appsnap --list
+
+# Capture a window (saves to temp directory)
+appsnap "Visual Studio Code"
+
+# Capture with custom output path
+appsnap "Chrome" --output screenshot.png
+
+# JSON output for agents
+appsnap "Notepad" --json
+# {"path": "C:\\Temp\\appsnap\\appsnap_20260202_153045.png", "window": "Notepad", "bbox": [100, 200, 800, 600]}
+
+# Adjust fuzzy matching threshold (0-100, default 70)
+appsnap "VS" --threshold 60
+
+# Capture ALL windows to a folder (great for testing!)
+appsnap --all ./screenshots
+
+# Capture all with JSON summary
+appsnap --all ./test-screens --json
+```
+
+## 🤖 AI Agent Integration
+
+### Claude Desktop Skill
+
+Add to your agent prompt or skill:
+
+```
+When you need to verify UI changes, use: appsnap "App Name" --json
+Parse the JSON output to get the screenshot path and window metadata.
+```
+
+### Python Integration
+
+```python
+import subprocess
+import json
+
+result = subprocess.run(
+    ["appsnap", "Chrome", "--json"],
+    capture_output=True,
+    text=True
+)
+data = json.loads(result.stdout)
+screenshot_path = data["path"]
+```
+
+### PowerShell Integration
+
+```powershell
+$result = appsnap "VSCode" --json | ConvertFrom-Json
+Write-Host "Screenshot: $($result.path)"
+```
+
+## 📖 CLI Options
+
+```
+positional arguments:
+  window_name           Window title to search for (fuzzy matching)
+
+options:
+  -h, --help            Show this help message and exit
+  -l, --list            List all capturable windows
+  -a DIR, --all DIR     Capture all windows to specified directory
+  -o PATH, --output PATH
+                        Output file path (default: temp directory)
+  -t N, --threshold N   Fuzzy match threshold 0-100 (default: 70)
+  -j, --json            Output JSON with path and metadata
+```
+
+### Bulk Capture Example
+
+The `--all` flag is perfect for quickly testing that all windows capture correctly:
+
+```bash
+# Capture all windows to a test folder
+uv run appsnap --all ./test-captures
+
+# Output:
+# Capturing 42 window(s) to C:\path\to\test-captures...
+#
+# [OK] Visual Studio Code
+# [OK] Chrome - Google Search
+# [OK] Task Manager
+# [OK] Settings
+# [OK] PowerShell_1  # Auto-numbered duplicate
+# [OK] PowerShell_2  # Auto-numbered duplicate
+# ...
+#
+# Complete: 40 successful, 2 failed
+# Screenshots saved to: C:\path\to\test-captures
+```
+
+Windows with the same title automatically get numbered (e.g., `PowerShell_1.png`, `PowerShell_2.png`).
+
+## 🛠️ How It Works
+
+1. **DPI Awareness** - Sets process DPI awareness for correct scaling on high-DPI displays
+2. **Window Enumeration** - Uses Win32 API to enumerate all visible, non-minimized windows
+3. **Fuzzy Matching** - Finds windows using `fuzzywuzzy` for flexible name matching
+4. **Direct Window Capture** - Uses Win32 `PrintWindow` API to capture window content directly (works even when partially occluded)
+5. **Output** - Saves to temp or custom location, prints path to stdout for easy agent parsing
+
+## 🔧 Development
+
+```bash
+# Clone and install dev dependencies
+git clone <repo>
+cd appsnap
+uv pip install -e ".[dev]"
+
+# Run tests
+uv run pytest
+
+# Run with local changes
+uv run appsnap --list
+```
+
+## 🐛 Troubleshooting
+
+### "No window found matching..."
+
+- Use `appsnap --list` to see exact window titles
+- Try lowering the threshold: `--threshold 60`
+- Make sure the window is visible (not minimized)
+
+### Screenshots are blank, wrong window, or multiple windows
+
+**v0.1.1 Fix:** Switched to Win32 PrintWindow API for direct window content capture.
+
+This method captures the actual window content, not screen regions, so it:
+
+- Works correctly on multi-monitor setups
+- Captures partially occluded windows
+- Handles DPI scaling properly
+
+If you still have issues:
+
+- Ensure the window is not minimized (minimized windows cannot be captured)
+- Some apps (especially GPU-accelerated ones) may not respond to PrintWindow correctly
+- Try bringing the window to foreground if capture fails
+
+### DPI/Scaling issues
+
+The tool automatically handles DPI awareness. If you see incorrect sizing:
+
+- Ensure Windows display scaling is consistent
+- Check that the app respects DPI settings
+
+## 📝 License
+
+MIT License - see [LICENSE](LICENSE) for details
+
+## 🙏 Acknowledgments
+
+Built on the excellent Windows-MCP project patterns and libraries:
+
+- [Pillow](https://github.com/python-pillow/Pillow) - Screenshot capture and image processing
+- [fuzzywuzzy](https://github.com/seatgeek/fuzzywuzzy) - Fuzzy string matching
+- [pywin32](https://github.com/mhammond/pywin32) - Windows API access
+
+## 🤝 Contributing
+
+Contributions welcome! Please feel free to submit issues or pull requests.
+
+For maintainers publishing to PyPI, see [PUBLISHING.md](PUBLISHING.md) for detailed instructions on:
+
+- Setting up GitHub Actions for automated PyPI releases
+- Manual publishing workflow
+- AI agent skill integration
+- Troubleshooting
+
+---
+
+Made for AI agents, by developers 🤖❤️

appsnap-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+appsnap/__init__.py,sha256=1Ol3w5E4NGkkHDEAW6LuNmn88V-096KeP-q29_wviWg,402
+appsnap/__main__.py,sha256=AkKtGArHydEHwueO414hEPekM03rw221NIMaKCEhFCU,8348
+appsnap/capture.py,sha256=PB8Y2Q5-h6BkR7fVt8Yqf1QNv63OrR1Z_zL7IGVOqHo,4555
+appsnap/windows.py,sha256=cCvz--9N-kTSC8axxegV8Ne9qIwPkqIwyh3DNmyyYEQ,3537
+appsnap-0.2.0.dist-info/METADATA,sha256=UeyR5zSbD8_hCzaz-eikkonQOJkjRdgm-UTpBctHpZ4,8132
+appsnap-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+appsnap-0.2.0.dist-info/entry_points.txt,sha256=l1gGnZkAyFUqrlPGaCnU5vpl-n7KNcie_Nq3q3XgN2A,50
+appsnap-0.2.0.dist-info/licenses/LICENSE,sha256=n43RGUuODSNb4emThiS6Zt7F3234aAXVRthApBekBio,1098
+appsnap-0.2.0.dist-info/RECORD,,

appsnap-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

appsnap-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+appsnap = appsnap.__main__:main

appsnap-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 appsnap contributors
+
+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.