agentreel 0.1.0

package/scripts/browser_demo.py

@@ -0,0 +1,215 @@
+"""
+Browser demo recorder. Uses claude CLI to generate a Playwright script,
+runs it with video recording, then extracts highlight timestamps.
+
+Usage:
+    python browser_demo.py <url> <output_video> [task]
+    python browser_demo.py --highlights <video_path> <output_json> [task]
+"""
+import asyncio
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+
+def find_claude():
+    """Find the claude CLI binary."""
+    import shutil
+    claude = shutil.which("claude")
+    if claude:
+        return claude
+    for path in [
+        os.path.expanduser("~/.local/bin/claude"),
+        "/usr/local/bin/claude",
+    ]:
+        if os.path.isfile(path):
+            return path
+    return "claude"
+
+
+def generate_playwright_script(url, task):
+    """Use claude CLI to generate a Playwright demo script."""
+    prompt = (
+        f"Generate a Playwright Python async function that demos a web app at {url}. "
+        f"Task: {task}. "
+        f"The function signature is: async def demo(page). "
+        f"Navigate to the URL, wait for load, interact with key features — "
+        f"click buttons, fill forms, scroll. Take about 20 seconds total. "
+        f"Add page.wait_for_timeout(1500) between actions so the viewer can see each step. "
+        f"Return ONLY the Python function code, no imports, no markdown fences."
+    )
+
+    claude = find_claude()
+    print(f"Using claude at: {claude}", file=sys.stderr)
+
+    result = subprocess.run(
+        [claude, "-p", prompt, "--output-format", "text"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    text = result.stdout.strip()
+    if "```" in text:
+        parts = text.split("```")
+        for part in parts:
+            part = part.strip()
+            if part.startswith("python"):
+                part = part[6:].strip()
+            if "async def demo" in part:
+                text = part
+                break
+    return text
+
+
+def extract_highlights(video_path, task):
+    """Ask Claude to suggest highlight timestamps for a browser recording."""
+    claude = find_claude()
+
+    prompt = (
+        f"I recorded a browser demo video of a web app. The task was: {task}. "
+        f"The video is about 20 seconds long. "
+        f"Suggest 3-4 highlight moments as a JSON array. Each highlight has: "
+        f'"label" (1-2 words), "overlay" (short caption with **bold** for accent), '
+        f'"videoStartSec" (start time in seconds), "videoEndSec" (end time). '
+        f"Each clip should be 3-5 seconds. Cover: page load, key interaction, result. "
+        f"Return ONLY the JSON array."
+    )
+
+    result = subprocess.run(
+        [claude, "-p", prompt, "--output-format", "text"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    text = result.stdout.strip()
+    if "```" in text:
+        parts = text.split("```")
+        for part in parts:
+            part = part.strip()
+            if part.startswith("json"):
+                part = part[4:].strip()
+            if part.startswith("["):
+                text = part
+                break
+
+    highlights = json.loads(text)
+
+    # Add videoSrc to each highlight (the Go/JS CLI will set the actual path)
+    for h in highlights:
+        h["videoSrc"] = "browser-demo.mp4"
+
+    return highlights
+
+
+async def record_browser_demo(url, task, output_path):
+    """Generate and run a Playwright demo with video recording."""
+    from playwright.async_api import async_playwright
+
+    print(f"Generating demo script for {url}...", file=sys.stderr)
+    script_code = generate_playwright_script(url, task)
+    print(f"Script ready ({len(script_code)} chars)", file=sys.stderr)
+
+    video_dir = tempfile.mkdtemp()
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        context = await browser.new_context(
+            viewport={"width": 1280, "height": 800},
+            record_video_dir=video_dir,
+            record_video_size={"width": 1280, "height": 800},
+        )
+        page = await context.new_page()
+
+        # Navigate first
+        print(f"Loading {url}...", file=sys.stderr)
+        try:
+            await page.goto(url, wait_until="networkidle", timeout=15000)
+        except Exception as e:
+            print(f"Navigation warning: {e}", file=sys.stderr)
+            await page.goto(url, timeout=15000)
+
+        await page.wait_for_timeout(1000)
+
+        # Execute the generated demo
+        try:
+            local_ns = {}
+            full_code = f"import asyncio\n{script_code}"
+            compiled = compile(full_code, "<demo>", "exec")
+            exec(compiled, local_ns)  # noqa: S102
+
+            if "demo" in local_ns:
+                print("Running demo script...", file=sys.stderr)
+                await local_ns["demo"](page)
+            else:
+                print("No demo() function found, waiting on page...", file=sys.stderr)
+                await page.wait_for_timeout(10000)
+        except Exception as e:
+            print(f"Demo script error: {e}", file=sys.stderr)
+            # Scroll around as fallback
+            await page.wait_for_timeout(2000)
+            await page.evaluate("window.scrollTo({ top: 500, behavior: 'smooth' })")
+            await page.wait_for_timeout(2000)
+            await page.evaluate("window.scrollTo({ top: 0, behavior: 'smooth' })")
+            await page.wait_for_timeout(2000)
+
+        # Get the video path before closing
+        video = page.video
+        await page.close()
+        await context.close()
+        await browser.close()
+
+    # Find the recorded video and convert to mp4
+    for f in os.listdir(video_dir):
+        if f.endswith(".webm"):
+            webm_path = os.path.join(video_dir, f)
+
+            # Convert webm to mp4 with ffmpeg
+            print(f"Converting to mp4...", file=sys.stderr)
+            try:
+                subprocess.run(
+                    ["ffmpeg", "-y", "-i", webm_path, "-c:v", "libx264",
+                     "-preset", "fast", "-crf", "23", output_path],
+                    capture_output=True,
+                    timeout=60,
+                )
+                print(f"Saved: {output_path}", file=sys.stderr)
+            except (subprocess.TimeoutExpired, FileNotFoundError):
+                # ffmpeg not available, use webm directly
+                import shutil
+                mp4_path = output_path.replace(".mp4", ".webm")
+                shutil.copy2(webm_path, mp4_path)
+                print(f"Saved (webm): {mp4_path}", file=sys.stderr)
+            return
+
+    print("Error: no video file recorded", file=sys.stderr)
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print(
+            "Usage:\n"
+            "  python browser_demo.py <url> <output_video> [task]\n"
+            "  python browser_demo.py --highlights <video_path> <output_json> [task]",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if sys.argv[1] == "--highlights":
+        video_path = sys.argv[2]
+        output = sys.argv[3]
+        task = sys.argv[4] if len(sys.argv) > 4 else "Demo the web app"
+        print(f"Extracting highlights...", file=sys.stderr)
+        highlights = extract_highlights(video_path, task)
+        with open(output, "w") as f:
+            json.dump(highlights, f, indent=2)
+        print(f"Saved {len(highlights)} highlights to: {output}", file=sys.stderr)
+    else:
+        url = sys.argv[1]
+        output = sys.argv[2]
+        task = sys.argv[3] if len(sys.argv) > 3 else "Explore the main features"
+        asyncio.run(record_browser_demo(url, task, output))

package/scripts/cli_demo.py

@@ -0,0 +1,272 @@
+"""
+CLI demo recorder. Uses `claude` CLI to plan the demo, then records it.
+
+Usage:
+    python cli_demo.py <command> <workdir> <output_cast> [context]
+"""
+import json
+import os
+import pty
+import select
+import subprocess
+import sys
+import time
+
+
+def find_claude():
+    """Find the claude CLI binary."""
+    import shutil
+    claude = shutil.which("claude")
+    if claude:
+        return claude
+    # Common locations
+    for path in [
+        os.path.expanduser("~/.local/bin/claude"),
+        "/usr/local/bin/claude",
+        os.path.expanduser("~/.claude/bin/claude"),
+    ]:
+        if os.path.isfile(path):
+            return path
+    return "claude"
+
+
+def generate_demo_plan(command: str, context: str) -> list[dict]:
+    """Use claude CLI to plan a demo sequence."""
+    prompt = f"""You are planning a terminal demo for a CLI tool. The tool is invoked with: {command}
+
+Context about what this tool does:
+{context}
+
+Generate a JSON array of demo steps. Each step is an object with:
+- "type": "command" (run a shell command)
+- "value": the command string
+- "delay": seconds to wait after (for dramatic effect)
+- "description": one-line description
+
+Make the demo:
+- Show the most impressive features
+- 5-8 steps max
+- Start simple, build to the wow moment
+- Use realistic commands
+
+Return ONLY the JSON array, no markdown, no explanation."""
+
+    claude = find_claude()
+    print(f"Using claude at: {claude}", file=sys.stderr)
+
+    result = subprocess.run(
+        [claude, "-p", prompt, "--output-format", "text"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    if result.returncode != 0:
+        print(f"claude stderr: {result.stderr}", file=sys.stderr)
+        raise RuntimeError(f"claude failed: {result.stderr}")
+
+    text = result.stdout.strip()
+    print(f"Claude output: {text[:200]}...", file=sys.stderr)
+
+    # Strip markdown fences if present
+    if "```" in text:
+        # Find JSON between fences
+        parts = text.split("```")
+        for part in parts:
+            part = part.strip()
+            if part.startswith("json"):
+                part = part[4:].strip()
+            if part.startswith("["):
+                text = part
+                break
+
+    return json.loads(text)
+
+
+def record_demo(steps: list[dict], workdir: str, output_path: str):
+    """Execute demo steps in a PTY and record as asciicast v2."""
+    cols, rows = 80, 24
+    start_time = time.time()
+
+    with open(output_path, "w") as f:
+        header = {
+            "version": 2,
+            "width": cols,
+            "height": rows,
+            "timestamp": int(start_time),
+        }
+        f.write(json.dumps(header) + "\n")
+
+        def write_event(event_type: str, data: str):
+            elapsed = time.time() - start_time
+            f.write(json.dumps([round(elapsed, 6), event_type, data]) + "\n")
+            f.flush()
+
+        for step in steps:
+            if step["type"] != "command":
+                continue
+
+            cmd = step["value"]
+            desc = step.get("description", "")
+
+            # Show description as dim comment
+            if desc:
+                write_event("o", f"\x1b[38;5;245m# {desc}\x1b[0m\r\n")
+                time.sleep(0.3)
+
+            # Type the command character by character
+            write_event("o", "\x1b[38;5;76m$\x1b[0m ")
+            for char in cmd:
+                write_event("o", char)
+                time.sleep(0.04)
+            write_event("o", "\r\n")
+            time.sleep(0.2)
+
+            # Execute in PTY
+            pid, fd = pty.fork()
+            if pid == 0:
+                os.chdir(workdir)
+                os.execvp("/bin/sh", ["/bin/sh", "-c", cmd])
+            else:
+                deadline = time.time() + 15
+                while time.time() < deadline:
+                    r, _, _ = select.select([fd], [], [], 0.1)
+                    if r:
+                        try:
+                            data = os.read(fd, 4096)
+                            if data:
+                                write_event("o", data.decode("utf-8", errors="replace"))
+                            else:
+                                break
+                        except OSError:
+                            break
+                    pid_result = os.waitpid(pid, os.WNOHANG)
+                    if pid_result[0] != 0:
+                        # Drain remaining output
+                        try:
+                            while True:
+                                r, _, _ = select.select([fd], [], [], 0.1)
+                                if r:
+                                    data = os.read(fd, 4096)
+                                    if data:
+                                        write_event("o", data.decode("utf-8", errors="replace"))
+                                    else:
+                                        break
+                                else:
+                                    break
+                        except OSError:
+                            pass
+                        break
+
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+
+            delay = step.get("delay", 1.0)
+            time.sleep(delay)
+            write_event("o", "\r\n")
+
+    print(f"Saved: {output_path}", file=sys.stderr)
+
+
+def extract_highlights(cast_path: str, context: str) -> list[dict]:
+    """Ask Claude to pick 3-4 highlight moments from the recorded session."""
+    # Read the asciicast and strip to just the text content
+    lines_output = []
+    with open(cast_path) as f:
+        for i, line in enumerate(f):
+            if i == 0:
+                continue  # skip header
+            try:
+                event = json.loads(line)
+                if event[1] == "o":
+                    lines_output.append(event[2])
+            except (json.JSONDecodeError, IndexError):
+                continue
+
+    raw_output = "".join(lines_output)
+    # Clean ANSI for Claude to read, but keep the raw for display
+    import re
+    clean = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', raw_output)
+
+    prompt = f"""You are creating a highlights reel for a CLI tool demo video. Here is the full terminal output:
+
+---
+{clean[:3000]}
+---
+
+Context: {context}
+
+Pick 3-4 highlight moments that would look impressive in a short video. For each highlight, return:
+- "label": short label (1-2 words) like "Initialize", "Configure", "Run", "Results"
+- "lines": array of objects, each with "text" (string), and optionally "color" (hex), "bold" (bool), "dim" (bool), "isPrompt" (bool if it's a shell command)
+- "zoomLine": (optional) index of the most impressive line to zoom into
+
+Each highlight should have 4-8 lines max. Keep the text concise.
+Use these colors: green="#50fa7b", yellow="#f1fa8c", purple="#bd93f9", red="#ff5555", dim="#6272a4", white="#f8f8f2"
+
+Return ONLY a JSON array of highlights. No markdown fences."""
+
+    claude = find_claude()
+    result = subprocess.run(
+        [claude, "-p", prompt, "--output-format", "text"],
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+
+    text = result.stdout.strip()
+    if "```" in text:
+        parts = text.split("```")
+        for part in parts:
+            part = part.strip()
+            if part.startswith("json"):
+                part = part[4:].strip()
+            if part.startswith("["):
+                text = part
+                break
+
+    return json.loads(text)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 4:
+        print("Usage: python cli_demo.py <command> <workdir> <output> [context]", file=sys.stderr)
+        print("       python cli_demo.py --highlights <cast_file> <output_json> [context]", file=sys.stderr)
+        sys.exit(1)
+
+    # Highlights mode: extract highlights from existing recording
+    if sys.argv[1] == "--highlights":
+        cast_file = sys.argv[2]
+        output = sys.argv[3]
+        context = sys.argv[4] if len(sys.argv) > 4 else ""
+        print(f"Extracting highlights from: {cast_file}", file=sys.stderr)
+        highlights = extract_highlights(cast_file, context)
+        with open(output, "w") as f:
+            json.dump(highlights, f, indent=2)
+        print(f"Saved {len(highlights)} highlights to: {output}", file=sys.stderr)
+        sys.exit(0)
+
+    # Record mode: plan + record + extract highlights
+    command = sys.argv[1]
+    workdir = sys.argv[2]
+    output = sys.argv[3]
+    context = sys.argv[4] if len(sys.argv) > 4 else ""
+
+    print(f"Planning demo for: {command}", file=sys.stderr)
+    steps = generate_demo_plan(command, context)
+    print(f"Generated {len(steps)} steps:", file=sys.stderr)
+    for s in steps:
+        print(f"  $ {s['value']}  — {s.get('description', '')}", file=sys.stderr)
+
+    print("Recording...", file=sys.stderr)
+    record_demo(steps, workdir, output)
+
+    # Extract highlights from the recording
+    highlights_path = output.replace(".cast", "-highlights.json")
+    print("Extracting highlights...", file=sys.stderr)
+    highlights = extract_highlights(output, context)
+    with open(highlights_path, "w") as f:
+        json.dump(highlights, f, indent=2)
+    print(f"Saved {len(highlights)} highlights to: {highlights_path}", file=sys.stderr)