shortcutxl 0.2.0

package/skills/sec-edgar/sec_to_pdf.py

@@ -0,0 +1,109 @@
+"""
+SEC EDGAR HTML to PDF converter.
+Uses Playwright + Chrome to render filings with images.
+
+Usage:
+    python sec_to_pdf.py <filing_url> <output_path>
+
+Example:
+    python sec_to_pdf.py "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm" "/workspace/aapl_10k.pdf"
+
+Why Chrome?
+    SEC.gov blocks headless Chromium with 403 errors (bot detection).
+    Using channel='chrome' with Playwright uses real Google Chrome which bypasses this.
+"""
+
+import asyncio
+import os
+import sys
+
+from playwright.async_api import async_playwright
+
+
+async def convert_sec_filing_to_pdf(url: str, output_path: str) -> dict:
+    """
+    Convert SEC EDGAR filing to PDF with images.
+
+    Args:
+        url: Full URL to SEC filing HTML
+        output_path: Where to save the PDF
+
+    Returns:
+        dict with status, pdf_size, and image_count
+    """
+    async with async_playwright() as p:
+        # MUST use channel='chrome' - regular Chromium gets 403 blocked by SEC
+        browser = await p.chromium.launch(headless=True, channel="chrome")
+        context = await browser.new_context(
+            user_agent="ShortcutAgent/1.0 (support@shortcut.ai)"
+        )
+        page = await context.new_page()
+
+        # Navigate to filing (networkidle waits for no network activity for 500ms)
+        response = await page.goto(url, wait_until="networkidle", timeout=20000)
+
+        if response is None or response.status != 200:
+            await browser.close()
+            return {
+                "status": "error",
+                "code": response.status if response else 0,
+                "message": "SEC blocked request or navigation failed",
+            }
+
+        # Count images for verification
+        images = await page.query_selector_all("img")
+        image_count = len(images)
+
+        # Generate PDF
+        pdf_bytes = await page.pdf(format="A4", print_background=True)
+
+        # Ensure output directory exists and save
+        output_dir = os.path.dirname(output_path)
+        if output_dir:
+            os.makedirs(output_dir, exist_ok=True)
+        with open(output_path, "wb") as f:
+            f.write(pdf_bytes)
+
+        await browser.close()
+
+        return {
+            "status": "success",
+            "pdf_path": output_path,
+            "pdf_size_bytes": len(pdf_bytes),
+            "image_count": image_count,
+        }
+
+
+async def main():
+    if len(sys.argv) != 3:
+        print("Usage: python sec_to_pdf.py <filing_url> <output_path>")
+        print()
+        print("Example:")
+        print(
+            '  python sec_to_pdf.py "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm" "/workspace/aapl_10k.pdf"'
+        )
+        sys.exit(1)
+
+    url = sys.argv[1]
+    output_path = sys.argv[2]
+
+    print("Converting SEC filing to PDF...")
+    print(f"  URL: {url}")
+    print(f"  Output: {output_path}")
+    print()
+
+    result = await convert_sec_filing_to_pdf(url, output_path)
+
+    if result["status"] == "success":
+        size_mb = result["pdf_size_bytes"] / (1024 * 1024)
+        print("Success!")
+        print(f"  PDF saved to: {result['pdf_path']}")
+        print(f"  PDF size: {result['pdf_size_bytes']:,} bytes ({size_mb:.2f} MB)")
+        print(f"  Images rendered: {result['image_count']}")
+    else:
+        print(f"Error: {result['message']} (code: {result['code']})")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/xll/modules/debug_render.py

@@ -0,0 +1,272 @@
+"""
+debug_render.py — Progressive rendering tests for isolating display issues.
+
+Type these in Excel cells to test each layer of the rendering pipeline:
+
+  =debug_write_test()     Layer 1: Can we write to a cell at all via COM?
+  =debug_batch_test()     Layer 2: Does xl_batch() work?
+  =debug_grid_test()      Layer 3: Can we write a 2D grid?
+  =debug_format_pong()    Layer 4: Set column/row sizes for pong display
+  =debug_frame()          Layer 5: Render one static pong frame
+  =debug_counter()        Layer 6: Animated counter (1 cell, 1Hz)
+  =debug_stop()           Stop any running animation
+"""
+
+import shortcut_xl
+from shortcut_xl import xl_func, xl_log
+
+_counter_running = False
+
+
+# === Layer 1: Basic COM write ===
+
+@xl_func
+def debug_write_test():
+    """Write a value to Z1 via xl_app() COM. Simplest possible test."""
+    try:
+        def _do(app):
+            app.ActiveSheet.Range("Z1").Value = "WRITE_OK"
+        shortcut_xl.xl_batch(_do)
+        return "Wrote 'WRITE_OK' to Z1 — check Z1"
+    except Exception as e:
+        xl_log(f"debug_write_test FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 2: xl_batch with ScreenUpdating toggle ===
+
+@xl_func
+def debug_batch_test():
+    """Write 3 cells in one batch. Tests ScreenUpdating toggle + PumpWaitingMessages."""
+    try:
+        def _do(app):
+            sheet = app.ActiveSheet
+            sheet.Range("Z1").Value = "BATCH"
+            sheet.Range("Z2").Value = "TEST"
+            sheet.Range("Z3").Value = "OK"
+        shortcut_xl.xl_batch(_do)
+        return "Wrote Z1:Z3 — check those cells"
+    except Exception as e:
+        xl_log(f"debug_batch_test FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 3: 2D grid write via Resize().Value ===
+
+@xl_func
+def debug_grid_test():
+    """Write a small 5x5 grid using the same Resize().Value pattern as pong."""
+    try:
+        grid = []
+        for r in range(5):
+            row = []
+            for c in range(5):
+                if r == 0 or r == 4 or c == 0 or c == 4:
+                    row.append("#")  # border
+                elif r == 2 and c == 2:
+                    row.append("X")  # center
+                else:
+                    row.append("")   # empty (same as pong does)
+            grid.append(row)
+
+        def _do(app):
+            sheet = app.ActiveSheet
+            top = sheet.Range("Z5").Cells(1, 1)
+            sheet.Range("Z5:AD9").Value = grid
+
+        shortcut_xl.xl_batch(_do)
+        xl_log(f"debug_grid_test: wrote 5x5 grid to Z5:AD9, data={grid}")
+        return "Wrote 5x5 grid to Z5:AD9 — check those cells"
+    except Exception as e:
+        xl_log(f"debug_grid_test FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 3b: Grid with tuples (test COM conversion) ===
+
+@xl_func
+def debug_grid_tuple_test():
+    """Same as grid_test but converts to tuple-of-tuples for COM.
+    If this works but debug_grid_test doesn't, it's a list-vs-tuple issue."""
+    try:
+        grid = []
+        for r in range(5):
+            row = []
+            for c in range(5):
+                if r == 0 or r == 4 or c == 0 or c == 4:
+                    row.append("#")
+                elif r == 2 and c == 2:
+                    row.append("X")
+                else:
+                    row.append("")
+            grid.append(tuple(row))
+        grid = tuple(grid)
+
+        def _do(app):
+            sheet = app.ActiveSheet
+            sheet.Range("Z5:AD9").Value = grid
+
+        shortcut_xl.xl_batch(_do)
+        xl_log(f"debug_grid_tuple_test: wrote tuple grid to Z5:AD9")
+        return "Wrote tuple-of-tuples 5x5 to Z5:AD9"
+    except Exception as e:
+        xl_log(f"debug_grid_tuple_test FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 4: Format cells for pong display ===
+
+@xl_func
+def debug_format_pong():
+    """Set up column widths and row heights so pong grid looks right.
+    This is what pong.py is missing — without it, the grid is spread across
+    the entire screen and looks like nothing."""
+    try:
+        def _do(app):
+            sheet = app.ActiveSheet
+            # Columns A-AD (1-30): narrow width for character grid
+            cols = sheet.Range("A:AD")
+            cols.ColumnWidth = 2.0
+            cols.HorizontalAlignment = -4108  # xlCenter
+
+            # Rows 3-22 (pong grid area): compact height
+            rows = sheet.Range("3:22")
+            rows.RowHeight = 15
+
+            # Monospace font for the grid
+            grid_range = sheet.Range("A3:AD22")
+            grid_range.Font.Name = "Consolas"
+            grid_range.Font.Size = 11
+
+            # Scoreboard formatting
+            sheet.Range("A1").Font.Name = "Consolas"
+            sheet.Range("A1").Font.Size = 14
+            sheet.Range("A1").Font.Bold = True
+
+        shortcut_xl.xl_batch(_do)
+        return "Formatted A:AD for pong display"
+    except Exception as e:
+        xl_log(f"debug_format_pong FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 5: Static pong frame ===
+
+@xl_func
+def debug_frame():
+    """Render exactly one pong frame. No animation, no schedule_call.
+    If this shows up, the rendering works and the issue is in the animation loop."""
+    try:
+        WIDTH, HEIGHT, PADDLE_H = 30, 20, 4
+        grid = []
+        ball_x, ball_y = 15, 10
+        paddle_l, paddle_r = 8, 8
+
+        for r in range(HEIGHT):
+            row = []
+            for c in range(WIDTH):
+                ch = ""
+                if c == 0 and paddle_l <= r < paddle_l + PADDLE_H:
+                    ch = chr(9608)  # full block
+                elif c == WIDTH - 1 and paddle_r <= r < paddle_r + PADDLE_H:
+                    ch = chr(9608)
+                elif r == ball_y and c == ball_x:
+                    ch = chr(9679)  # black circle
+                elif c == WIDTH // 2 and r % 2 == 0:
+                    ch = chr(9474)  # light vertical
+                row.append(ch)
+            grid.append(row)
+
+        def _do(app):
+            sheet = app.ActiveSheet
+            sheet.Range("A3:AD22").Value = grid
+            sheet.Range("A1").Value = "PONG   0  :  0"
+            sheet.Range("A2").Value = "Static frame test"
+
+        shortcut_xl.xl_batch(_do)
+        xl_log("debug_frame: wrote static pong frame")
+        return "Wrote static pong frame to A3:AD22"
+    except Exception as e:
+        xl_log(f"debug_frame FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 5b: Static frame with ASCII (no Unicode) ===
+
+@xl_func
+def debug_frame_ascii():
+    """Same as debug_frame but uses ASCII chars only.
+    If this renders but debug_frame doesn't, it's a Unicode/font issue."""
+    try:
+        WIDTH, HEIGHT, PADDLE_H = 30, 20, 4
+        grid = []
+        ball_x, ball_y = 15, 10
+        paddle_l, paddle_r = 8, 8
+
+        for r in range(HEIGHT):
+            row = []
+            for c in range(WIDTH):
+                ch = "."  # visible empty (not "")
+                if c == 0 and paddle_l <= r < paddle_l + PADDLE_H:
+                    ch = "|"
+                elif c == WIDTH - 1 and paddle_r <= r < paddle_r + PADDLE_H:
+                    ch = "|"
+                elif r == ball_y and c == ball_x:
+                    ch = "O"
+                elif c == WIDTH // 2 and r % 2 == 0:
+                    ch = ":"
+                row.append(ch)
+            grid.append(row)
+
+        def _do(app):
+            sheet = app.ActiveSheet
+            sheet.Range("A3:AD22").Value = grid
+            sheet.Range("A1").Value = "PONG   0  :  0"
+            sheet.Range("A2").Value = "Static ASCII frame test"
+
+        shortcut_xl.xl_batch(_do)
+        xl_log("debug_frame_ascii: wrote ASCII pong frame")
+        return "Wrote ASCII pong frame to A3:AD22"
+    except Exception as e:
+        xl_log(f"debug_frame_ascii FAILED: {e}")
+        return f"FAILED: {e}"
+
+
+# === Layer 6: Animated counter (simplest animation) ===
+
+@xl_func
+def debug_counter():
+    """Increment a single cell once per second. Simplest animation test.
+    If this works, schedule_call + xl_batch animation pipeline is fine."""
+    global _counter_running
+    if _counter_running:
+        return "Already running! =debug_stop() first"
+
+    _counter_running = True
+    _count = [0]
+
+    def _tick():
+        if not _counter_running:
+            return
+        _count[0] += 1
+        xl_log(f"debug_counter tick: {_count[0]}")
+        try:
+            def _do(app):
+                app.ActiveSheet.Range("Z1").Value = f"Count: {_count[0]}"
+            shortcut_xl.xl_batch(_do)
+        except Exception as e:
+            xl_log(f"debug_counter error: {e}")
+
+        if _counter_running and _count[0] < 30:
+            shortcut_xl.schedule_call(_tick, 1.0)
+
+    shortcut_xl.schedule_call(_tick, 0.1)
+    return "Counting in Z1 (1/sec, 30 max)"
+
+
+@xl_func
+def debug_stop():
+    """Stop the debug counter."""
+    global _counter_running
+    _counter_running = False
+    return "Stopped"

package/xll/modules/gameboy.py

@@ -0,0 +1,241 @@
+"""
+Game Boy emulator in Excel — type =gb_start() to play Pokemon Red!
+
+Runs a Game Boy ROM via PyBoy at full 160x144 resolution.
+Colors are auto-detected from the game's actual palette.
+
+Arrow keys + Z (A) + X (B) + Enter (Start) + Backspace (Select).
+Type =gb_stop() to end.
+"""
+import shortcut_xl
+from shortcut_xl import xl_func, xl_log
+import ctypes
+import os
+import time
+
+WIDTH = 160
+HEIGHT = 144
+TARGET_EMU_FPS = 60  # Game Boy runs at ~60 FPS
+
+# Column letter helper
+def _col_letter(n):
+    s = ""
+    while n > 0:
+        n, rem = divmod(n - 1, 26)
+        s = chr(65 + rem) + s
+    return s
+
+_GRID_RANGE = f"A3:{_col_letter(WIDTH)}{2 + HEIGHT}"
+
+# Key mappings: Windows VK code -> PyBoy button name
+_KEY_MAP = {
+    0x25: 'left',
+    0x26: 'up',
+    0x27: 'right',
+    0x28: 'down',
+    0x5A: 'a',       # Z
+    0x58: 'b',       # X
+    0x0D: 'start',   # Enter
+    0x08: 'select',  # Backspace
+}
+
+_state = {
+    'pyboy': None,
+    'running': False,
+    '_formatted': False,
+    '_keys_held': set(),
+    '_palette_bgr': None,
+    '_last_tick': 0.0,
+}
+
+# Excel OnKey strings to suppress during gameplay
+_ONKEY_SUPPRESS = [
+    "z", "Z", "x", "X",
+    "{LEFT}", "{RIGHT}", "{UP}", "{DOWN}",
+    "~", "{BS}",
+]
+
+
+def _suppress_keys(app):
+    for k in _ONKEY_SUPPRESS:
+        app.OnKey(k, "")
+
+
+def _restore_keys(app):
+    for k in _ONKEY_SUPPRESS:
+        app.OnKey(k)
+
+
+def _poll_keys():
+    pb = _state['pyboy']
+    if not pb:
+        return
+    currently_held = set()
+    for vk in _KEY_MAP:
+        if ctypes.windll.user32.GetAsyncKeyState(vk) & 0x8000:
+            currently_held.add(vk)
+    prev = _state['_keys_held']
+    for vk in currently_held - prev:
+        pb.button_press(_KEY_MAP[vk])
+    for vk in prev - currently_held:
+        pb.button_release(_KEY_MAP[vk])
+    _state['_keys_held'] = currently_held
+
+
+def _detect_palette():
+    """Scan screen for unique colors, build sorted palette."""
+    import numpy as np
+    screen = _state['pyboy'].screen.ndarray[:, :, :3]
+    unique = np.unique(screen.reshape(-1, 3), axis=0)
+    brightness = np.sum(unique, axis=1)
+    order = np.argsort(brightness)
+    palette = [tuple(unique[i]) for i in order]
+    _state['_palette_bgr'] = [
+        int(b) * 65536 + int(g) * 256 + int(r) for r, g, b in palette
+    ]
+    # Build threshold list from midpoints between palette brightness levels
+    b_sorted = sorted(brightness)
+    thresholds = []
+    for i in range(len(b_sorted) - 1):
+        thresholds.append((b_sorted[i] + b_sorted[i + 1]) / 2.0 / 3.0)  # per-channel avg
+    _state['_thresholds'] = thresholds
+    xl_log(f"gb palette: {len(palette)} colors, thresholds={thresholds}")
+
+
+def _grab_frame():
+    """Fast frame grab: threshold-based, returns list-of-lists (no tuple conversion)."""
+    import numpy as np
+    screen = _state['pyboy'].screen.ndarray[:, :, 0]  # R channel (GB is grayscale R=G=B)
+    thresholds = _state.get('_thresholds', [64, 128, 192])
+
+    indices = np.zeros(screen.shape, dtype=np.uint8)
+    for i, t in enumerate(thresholds):
+        indices[screen >= t] = i + 1
+
+    return indices.tolist()  # list-of-lists — fast C-level conversion
+
+
+def _render(grid):
+    def _paint(app):
+        app.Calculation = -4135  # xlCalculationManual
+        sheet = app.ActiveSheet
+
+        if not _state['_formatted']:
+            _state['_formatted'] = True
+            area = sheet.Range(_GRID_RANGE)
+            area.ColumnWidth = 0.75
+            area.RowHeight = 5
+            area.NumberFormat = ";;;"
+
+            # Conditional formatting from detected palette
+            area.FormatConditions.Delete()
+            for val, bgr in enumerate(_state['_palette_bgr']):
+                fc = area.FormatConditions.Add(1, 3, str(val))
+                fc.Interior.Color = bgr
+                fc.Font.Color = bgr
+                fc.StopIfTrue = False
+
+            _suppress_keys(app)
+
+        sheet.Range(_GRID_RANGE).Value = grid
+        sheet.Range("A1").Value = "GAME BOY"
+        sheet.Range("A2").Value = (
+            chr(8592) + chr(8593) + chr(8594) + chr(8595)
+            + "  Z=A  X=B  Enter=Start  Back=Select   gb_stop() to end"
+        )
+
+    shortcut_xl.xl_batch(_paint)
+
+
+def _tick():
+    if not _state['running']:
+        return
+    try:
+        pb = _state['pyboy']
+        now = time.perf_counter()
+        elapsed = now - _state['_last_tick']
+        _state['_last_tick'] = now
+
+        # Advance emulator to keep game at real speed
+        # Even if rendering is slow, the game plays at correct pace
+        frames_to_run = max(1, min(int(elapsed * TARGET_EMU_FPS), 10))
+        _poll_keys()
+        for _ in range(frames_to_run - 1):
+            pb.tick(1, False)  # advance without rendering
+        pb.tick(1, True)       # render last frame only
+
+        # Re-detect palette every ~2 seconds of game time
+        if pb.frame_count % 120 == 0:
+            _detect_palette()
+            _state['_formatted'] = False
+
+        grid = _grab_frame()
+        _render(grid)
+    except Exception as e:
+        xl_log(f"gameboy tick error: {e}")
+        import traceback
+        xl_log(traceback.format_exc())
+        _state['running'] = False
+        shortcut_xl.schedule_call(_restore_calc, 0.3)
+        return
+    # Schedule next tick immediately — render as fast as COM allows
+    shortcut_xl.schedule_call(_tick, 0.001)
+
+
+def _restore_calc():
+    def _do(app):
+        _restore_keys(app)
+        app.Calculation = -4105  # xlCalculationAutomatic
+    shortcut_xl.xl_batch(_do)
+
+
+@xl_func
+def gb_start(rom_path=""):
+    if _state['running']:
+        return "Already running! gb_stop() first"
+
+    if not rom_path or rom_path is None:
+        rom_path = "pokemon_red"
+
+    if not os.path.isfile(rom_path):
+        modules_dir = os.path.dirname(os.path.abspath(__file__))
+        roms_dir = os.path.join(os.path.dirname(modules_dir), "roms")
+        candidate = os.path.join(roms_dir, rom_path if rom_path.endswith(".gb") else rom_path + ".gb")
+        if os.path.isfile(candidate):
+            rom_path = candidate
+
+    if not os.path.isfile(rom_path):
+        return f"ROM not found: {rom_path}"
+
+    try:
+        from pyboy import PyBoy
+        pb = PyBoy(rom_path, window='null')
+        for _ in range(200):
+            pb.tick(1, True)
+        _state['pyboy'] = pb
+    except Exception as e:
+        xl_log(f"gb_start error: {e}")
+        return f"Failed: {e}"
+
+    _detect_palette()
+
+    _state['running'] = True
+    _state['_formatted'] = False
+    _state['_keys_held'] = set()
+    _state['_last_tick'] = time.perf_counter()
+    shortcut_xl.schedule_call(_tick, 0.1)
+    return "GAME BOY!"
+
+
+@xl_func
+def gb_stop():
+    _state['running'] = False
+    pb = _state.get('pyboy')
+    if pb:
+        try:
+            pb.stop(False)
+        except Exception:
+            pass
+        _state['pyboy'] = None
+    shortcut_xl.schedule_call(_restore_calc, 0.3)
+    return "Stopped"