Notebooklm Superskill

# Runtime data
data/
downloads/

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
.venv/
venv/
ENV/
env/
.env

# IDE
.idea/
.vscode/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db

# Logs
*.log

patchright==1.55.2
python-dotenv==1.0.0

"""NotebookLM SuperSkill - Generate slides, audio, infographics, and video from NotebookLM."""

__version__ = "1.0.0"

"""
Artifact Monitor for NotebookLM SuperSkill
Monitors artifact generation status using shimmer detection
"""

import time
from typing import Optional, List, Dict, Any

from patchright.sync_api import Page, ElementHandle

from config import ARTIFACT_SELECTORS, ARTIFACT_TIMEOUT_SECONDS


class ArtifactMonitor:
    """Monitor NotebookLM artifact generation status"""

    def __init__(self, page: Page, artifact_type: str = "slides"):
        """
        Initialize artifact monitor.

        Args:
            page: Playwright page
            artifact_type: Type of artifact (slides, audio, infographic, video)
        """
        self.page = page
        self.artifact_type = artifact_type
        self.selector = ARTIFACT_SELECTORS.get(artifact_type, ARTIFACT_SELECTORS["slides"])

    def count_artifacts(self) -> int:
        """Count current artifacts of this type in Studio panel"""
        try:
            artifacts = self.page.query_selector_all(self.selector)
            return len(artifacts)
        except Exception:
            return 0

    def get_artifacts(self) -> List[ElementHandle]:
        """Get all artifact elements of this type"""
        try:
            return self.page.query_selector_all(self.selector)
        except Exception:
            return []

    def is_shimmer_loading(self, artifact: ElementHandle) -> bool:
        """
        Check if artifact is still loading (shimmer animation active).

        NotebookLM uses a 'shimmer' CSS class on the parent container
        to indicate loading state.

        Args:
            artifact: Artifact element handle

        Returns:
            True if artifact is still loading
        """
        try:
            parent = artifact.evaluate_handle("el => el.closest('.artifact-item-button')")
            if parent:
                classes = parent.evaluate("el => el.className") or ""
                return "shimmer" in classes
        except Exception:
            pass
        return False

    def get_loading_count(self) -> int:
        """Count how many artifacts are currently loading"""
        artifacts = self.get_artifacts()
        return sum(1 for a in artifacts if self.is_shimmer_loading(a))

    def get_ready_count(self) -> int:
        """Count how many artifacts are ready (not loading)"""
        artifacts = self.get_artifacts()
        return sum(1 for a in artifacts if not self.is_shimmer_loading(a))

    def wait_for_artifact_ready(
        self,
        initial_count: int,
        timeout_sec: int = ARTIFACT_TIMEOUT_SECONDS
    ) -> bool:
        """
        Wait for a NEW artifact to appear AND finish loading.

        Uses:
        - Artifact counting for progress tracking
        - Shimmer detection for completion
        - Stability polling (artifact present without shimmer)

        Args:
            initial_count: Number of artifacts before generation started
            timeout_sec: Maximum wait time in seconds

        Returns:
            True if new artifact is ready, False on timeout
        """
        print(f"  Waiting for {self.artifact_type} to generate... (initial count: {initial_count})")

        artifact_appeared = False
        poll_interval = 2

        for i in range(timeout_sec // poll_interval):
            time.sleep(poll_interval)
            current_count = self.count_artifacts()

            if current_count > initial_count:
                if not artifact_appeared:
                    print(f"  New artifact appeared! (count: {current_count})")
                    artifact_appeared = True

                # Check if the latest artifact is still loading
                artifacts = self.get_artifacts()
                if artifacts:
                    latest = artifacts[-1]
                    if not self.is_shimmer_loading(latest):
                        elapsed = i * poll_interval
                        print(f"  Artifact ready! (took ~{elapsed}s)")
                        return True
                    elif i % 10 == 0:
                        print(f"  Still loading... ({i * poll_interval}s)")

            elif i % 15 == 0 and i > 0 and not artifact_appeared:
                print(f"  Still generating... ({i * poll_interval}s)")

        print(f"  Timeout waiting for {self.artifact_type}")
        return False

    def wait_for_multiple_ready(
        self,
        expected_count: int,
        timeout_sec: int = ARTIFACT_TIMEOUT_SECONDS
    ) -> int:
        """
        Wait for multiple artifacts to be ready.

        Args:
            expected_count: Expected total artifact count
            timeout_sec: Maximum wait time

        Returns:
            Number of ready artifacts
        """
        print(f"  Waiting for {expected_count} {self.artifact_type} to be ready...")

        poll_interval = 2

        for i in range(timeout_sec // poll_interval):
            time.sleep(poll_interval)
            current_count = self.count_artifacts()
            loading_count = self.get_loading_count()
            ready_count = current_count - loading_count

            if i % 10 == 0:
                print(f"  [{i * poll_interval}s] Total: {current_count}, Ready: {ready_count}, Loading: {loading_count}")

            # All done when we have expected count and none are loading
            if current_count >= expected_count and loading_count == 0:
                print(f"  All {current_count} artifacts ready!")
                return ready_count

        # Return what we have
        return self.get_ready_count()

    def get_artifact_info(self, artifact: ElementHandle) -> Dict[str, Any]:
        """
        Get information about an artifact.

        Args:
            artifact: Artifact element

        Returns:
            Dict with artifact info (title, loading status, etc.)
        """
        try:
            title_el = artifact.query_selector(".artifact-title")
            title = title_el.text_content() if title_el else "Untitled"

            return {
                "title": title.strip() if title else "Untitled",
                "loading": self.is_shimmer_loading(artifact),
                "type": self.artifact_type,
            }
        except Exception:
            return {
                "title": "Unknown",
                "loading": False,
                "type": self.artifact_type,
            }

#!/usr/bin/env python3
"""
Authentication Manager for NotebookLM SuperSkill
Handles Google login and browser state persistence

Implements hybrid auth approach:
- Persistent browser profile for fingerprint consistency
- Manual cookie injection from state.json (Playwright bug workaround)
See: https://github.com/microsoft/playwright/issues/36139
"""

import json
import time
import argparse
import shutil
import re
import sys
from pathlib import Path
from typing import Dict, Any

from patchright.sync_api import sync_playwright, BrowserContext

sys.path.insert(0, str(Path(__file__).parent))

from config import BROWSER_STATE_DIR, STATE_FILE, AUTH_INFO_FILE, DATA_DIR
from browser_factory import BrowserFactory


class AuthManager:
    """
    Manages authentication and browser state for NotebookLM

    Features:
    - Interactive Google login
    - Browser state persistence
    - Session restoration
    - Authentication validation
    """

    def __init__(self):
        """Initialize the authentication manager"""
        DATA_DIR.mkdir(parents=True, exist_ok=True)
        BROWSER_STATE_DIR.mkdir(parents=True, exist_ok=True)

        self.state_file = STATE_FILE
        self.auth_info_file = AUTH_INFO_FILE
        self.browser_state_dir = BROWSER_STATE_DIR

    def is_authenticated(self) -> bool:
        """Check if valid authentication exists"""
        if not self.state_file.exists():
            return False

        # Check if state file is not too old (7 days)
        age_days = (time.time() - self.state_file.stat().st_mtime) / 86400
        if age_days > 7:
            print(f"  Browser state is {age_days:.1f} days old, may need re-authentication")

        return True

    def get_auth_info(self) -> Dict[str, Any]:
        """Get authentication information"""
        info = {
            'authenticated': self.is_authenticated(),
            'state_file': str(self.state_file),
            'state_exists': self.state_file.exists()
        }

        if self.auth_info_file.exists():
            try:
                with open(self.auth_info_file, 'r') as f:
                    saved_info = json.load(f)
                    info.update(saved_info)
            except Exception:
                pass

        if info['state_exists']:
            age_hours = (time.time() - self.state_file.stat().st_mtime) / 3600
            info['state_age_hours'] = age_hours

        return info

    def setup_auth(self, headless: bool = False, timeout_minutes: int = 10) -> bool:
        """
        Perform interactive authentication setup.

        IMPORTANT: Browser must be visible (headless=False) for login.

        Args:
            headless: Run browser in headless mode (False for login)
            timeout_minutes: Maximum time to wait for login

        Returns:
            True if authentication successful
        """
        print("Starting authentication setup...")
        print(f"  Timeout: {timeout_minutes} minutes")

        playwright = None
        context = None

        try:
            playwright = sync_playwright().start()

            context = BrowserFactory.launch_persistent_context(
                playwright,
                headless=headless
            )

            page = context.new_page()
            page.goto("https://notebooklm.google.com", wait_until="domcontentloaded")

            # Check if already authenticated
            if "notebooklm.google.com" in page.url and "accounts.google.com" not in page.url:
                print("  Already authenticated!")
                self._save_browser_state(context)
                return True

            # Wait for manual login
            print("\n  Please log in to your Google account...")
            print(f"  Waiting up to {timeout_minutes} minutes for login...")

            try:
                timeout_ms = int(timeout_minutes * 60 * 1000)
                page.wait_for_url(re.compile(r"^https://notebooklm\.google\.com/"), timeout=timeout_ms)

                print("  Login successful!")

                self._save_browser_state(context)
                self._save_auth_info()
                return True

            except Exception as e:
                print(f"  Authentication timeout: {e}")
                return False

        except Exception as e:
            print(f"  Error: {e}")
            return False

        finally:
            if context:
                try:
                    context.close()
                except Exception:
                    pass
            if playwright:
                try:
                    playwright.stop()
                except Exception:
                    pass

    def _save_browser_state(self, context: BrowserContext):
        """Save browser state to disk"""
        try:
            context.storage_state(path=str(self.state_file))
            print(f"  Saved browser state to: {self.state_file}")
        except Exception as e:
            print(f"  Failed to save browser state: {e}")
            raise

    def _save_auth_info(self):
        """Save authentication metadata"""
        try:
            info = {
                'authenticated_at': time.time(),
                'authenticated_at_iso': time.strftime('%Y-%m-%d %H:%M:%S')
            }
            with open(self.auth_info_file, 'w') as f:
                json.dump(info, f, indent=2)
        except Exception:
            pass

    def clear_auth(self) -> bool:
        """Clear all authentication data"""
        print("Clearing authentication data...")

        try:
            if self.state_file.exists():
                self.state_file.unlink()
                print("  Removed browser state")

            if self.auth_info_file.exists():
                self.auth_info_file.unlink()
                print("  Removed auth info")

            if self.browser_state_dir.exists():
                shutil.rmtree(self.browser_state_dir)
                self.browser_state_dir.mkdir(parents=True, exist_ok=True)
                print("  Cleared browser data")

            return True

        except Exception as e:
            print(f"  Error clearing auth: {e}")
            return False

    def re_auth(self, headless: bool = False, timeout_minutes: int = 10) -> bool:
        """Perform re-authentication (clear and setup)"""
        print("Starting re-authentication...")
        self.clear_auth()
        return self.setup_auth(headless, timeout_minutes)

    def validate_auth(self) -> bool:
        """Validate that stored authentication works"""
        if not self.is_authenticated():
            return False

        print("Validating authentication...")

        playwright = None
        context = None

        try:
            playwright = sync_playwright().start()

            context = BrowserFactory.launch_persistent_context(
                playwright,
                headless=True
            )

            page = context.new_page()
            page.goto("https://notebooklm.google.com", wait_until="domcontentloaded", timeout=30000)

            if "notebooklm.google.com" in page.url and "accounts.google.com" not in page.url:
                print("  Authentication is valid")
                return True
            else:
                print("  Authentication is invalid (redirected to login)")
                return False

        except Exception as e:
            print(f"  Validation failed: {e}")
            return False

        finally:
            if context:
                try:
                    context.close()
                except Exception:
                    pass
            if playwright:
                try:
                    playwright.stop()
                except Exception:
                    pass


def main():
    """Command-line interface for authentication management"""
    parser = argparse.ArgumentParser(description='Manage NotebookLM authentication')

    subparsers = parser.add_subparsers(dest='command', help='Commands')

    setup_parser = subparsers.add_parser('setup', help='Setup authentication')
    setup_parser.add_argument('--headless', action='store_true', help='Run in headless mode')
    setup_parser.add_argument('--timeout', type=float, default=10, help='Login timeout in minutes')

    subparsers.add_parser('status', help='Check authentication status')
    subparsers.add_parser('validate', help='Validate authentication')
    subparsers.add_parser('clear', help='Clear authentication')

    reauth_parser = subparsers.add_parser('reauth', help='Re-authenticate')
    reauth_parser.add_argument('--timeout', type=float, default=10, help='Login timeout in minutes')

    args = parser.parse_args()

    auth = AuthManager()

    if args.command == 'setup':
        if auth.setup_auth(headless=args.headless, timeout_minutes=args.timeout):
            print("\nAuthentication setup complete!")
        else:
            print("\nAuthentication setup failed")
            exit(1)

    elif args.command == 'status':
        info = auth.get_auth_info()
        print("\nAuthentication Status:")
        print(f"  Authenticated: {'Yes' if info['authenticated'] else 'No'}")
        if info.get('state_age_hours'):
            print(f"  State age: {info['state_age_hours']:.1f} hours")
        if info.get('authenticated_at_iso'):
            print(f"  Last auth: {info['authenticated_at_iso']}")

    elif args.command == 'validate':
        if auth.validate_auth():
            print("Authentication is valid and working")
        else:
            print("Authentication is invalid or expired")
            print("Run: python run.py auth_manager.py setup")

    elif args.command == 'clear':
        if auth.clear_auth():
            print("Authentication cleared")

    elif args.command == 'reauth':
        if auth.re_auth(timeout_minutes=args.timeout):
            print("\nRe-authentication complete!")
        else:
            print("\nRe-authentication failed")
            exit(1)

    else:
        parser.print_help()


if __name__ == "__main__":
    main()

"""
Browser Factory for NotebookLM SuperSkill
Handles browser launching with anti-detection features
"""

import json
from typing import Optional

from patchright.sync_api import Playwright, BrowserContext

from config import BROWSER_PROFILE_DIR, STATE_FILE, BROWSER_ARGS, USER_AGENT


class BrowserFactory:
    """Factory for creating configured browser contexts with anti-detection"""

    @staticmethod
    def launch_persistent_context(
        playwright: Playwright,
        headless: bool = True,
        user_data_dir: str = str(BROWSER_PROFILE_DIR)
    ) -> BrowserContext:
        """
        Launch a persistent browser context with anti-detection features.

        Uses:
        - Real Chrome (not Chromium) for reliability
        - Persistent profile for fingerprint consistency
        - Cookie injection workaround for Playwright bug #36139

        Args:
            playwright: Playwright instance
            headless: Run in headless mode
            user_data_dir: Path to browser profile directory

        Returns:
            Configured BrowserContext
        """
        context = playwright.chromium.launch_persistent_context(
            user_data_dir=user_data_dir,
            channel="chrome",  # Use real Chrome
            headless=headless,
            no_viewport=True,
            ignore_default_args=["--enable-automation"],
            user_agent=USER_AGENT,
            args=BROWSER_ARGS
        )

        # Cookie Workaround for Playwright bug #36139
        # Session cookies (expires=-1) don't persist in user_data_dir automatically
        BrowserFactory._inject_cookies(context)

        return context

    @staticmethod
    def _inject_cookies(context: BrowserContext):
        """Inject cookies from state.json if available"""
        if STATE_FILE.exists():
            try:
                with open(STATE_FILE, 'r') as f:
                    state = json.load(f)
                    if 'cookies' in state and len(state['cookies']) > 0:
                        context.add_cookies(state['cookies'])
            except Exception:
                pass  # Non-critical - cookies might not be needed

"""
Configuration for NotebookLM SuperSkill
Centralizes paths, selectors, timeouts, and browser settings
"""

from pathlib import Path

# Paths
SKILL_DIR = Path(__file__).parent.parent
DATA_DIR = SKILL_DIR / "data"
BROWSER_STATE_DIR = DATA_DIR / "browser_state"
BROWSER_PROFILE_DIR = BROWSER_STATE_DIR / "browser_profile"
STATE_FILE = BROWSER_STATE_DIR / "state.json"
AUTH_INFO_FILE = DATA_DIR / "auth_info.json"

# Browser Configuration
BROWSER_ARGS = [
    '--disable-blink-features=AutomationControlled',  # Patches navigator.webdriver
    '--disable-dev-shm-usage',
    '--no-sandbox',
    '--no-first-run',
    '--no-default-browser-check'
]

USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'

# Timeouts (seconds unless noted)
LOGIN_TIMEOUT_MINUTES = 10
ARTIFACT_TIMEOUT_SECONDS = 180      # Slides, infographics
AUDIO_TIMEOUT_SECONDS = 600         # Podcasts take longer (10 min)
VIDEO_TIMEOUT_SECONDS = 900         # Videos take longest (15 min)
DOWNLOAD_TIMEOUT_MS = 60000
PAGE_LOAD_TIMEOUT = 30000

# Stealth Configuration
TYPING_WPM_MIN = 320
TYPING_WPM_MAX = 480
CLICK_DELAY_MIN_MS = 100
CLICK_DELAY_MAX_MS = 300

# Common Selectors
QUERY_INPUT_SELECTORS = [
    "textarea.query-box-input",
    'textarea[aria-label="Input for queries"]',
]

RESPONSE_SELECTORS = [
    ".to-user-container .message-text-content",
    "[data-message-author='bot']",
    "[data-message-author='assistant']",
]

# Artifact Selectors
ARTIFACT_SELECTORS = {
    "slides": "button[aria-description='Slides']",
    "audio": "button[aria-description='Audio Overview']",
    "infographic": "button[aria-description='Infographic']",
    "video": "button[aria-description='Video']",
}

# Customization Dialog Selectors
CUSTOMIZE_DIALOG = "mat-dialog-container:has-text('Customise')"
GENERATE_BUTTON = "mat-dialog-container button:has-text('Generate')"

"""
Download Handler for NotebookLM SuperSkill
Unified download management for all artifact types
"""

import time
from pathlib import Path
from typing import Optional, Dict, Any

from patchright.sync_api import Page, ElementHandle

from config import DOWNLOAD_TIMEOUT_MS
from stealth_utils import StealthUtils


class DownloadHandler:
    """Handle artifact downloads with consistent error handling"""

    def __init__(self, page: Page, output_dir: Path):
        """
        Initialize download handler.

        Args:
            page: Playwright page
            output_dir: Directory to save downloads
        """
        self.page = page
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)

    def download_artifact(
        self,
        artifact: ElementHandle,
        prefix: str = "",
        timeout: int = DOWNLOAD_TIMEOUT_MS
    ) -> Optional[Dict[str, Any]]:
        """
        Download artifact via More menu > Download.

        Args:
            artifact: Artifact element to download
            prefix: Prefix to add to filename
            timeout: Download timeout in milliseconds

        Returns:
            Dict with download info, or None on failure
        """
        try:
            # Click More menu (may need to hover first)
            more_btn = artifact.query_selector("button.artifact-more-button")
            if not more_btn:
                more_btn = artifact.query_selector("button[aria-label='More']")

            if more_btn:
                more_btn.click()
            else:
                # Try hovering to reveal the button
                artifact.hover()
                time.sleep(0.3)
                more_btn = self.page.query_selector("button[aria-label='More']")
                if more_btn:
                    more_btn.click()
                else:
                    print("  More button not found")
                    return None

            time.sleep(0.5)

            # Click Download
            download_btn = self.page.query_selector("button:has-text('Download')")
            if not download_btn:
                print("  Download button not found in menu")
                return None

            # Handle download with expect_download
            with self.page.expect_download(timeout=timeout) as download_info:
                download_btn.click()

            download = download_info.value

            # Build filename
            suggested = download.suggested_filename or f"artifact_{int(time.time())}.pdf"
            filename = self._format_filename(suggested, prefix)
            save_path = self.output_dir / filename

            # Save file
            download.save_as(str(save_path))
            print(f"  Saved: {filename}")

            return {
                "filename": filename,
                "path": str(save_path),
                "suggested_filename": suggested,
            }

        except Exception as e:
            print(f"  Download error: {e}")
            return None

    def download_latest(
        self,
        artifact_selector: str,
        prefix: str = ""
    ) -> Optional[Dict[str, Any]]:
        """
        Download the most recent artifact matching selector.

        Args:
            artifact_selector: CSS selector for artifact type
            prefix: Filename prefix

        Returns:
            Download info dict, or None
        """
        artifacts = self.page.query_selector_all(artifact_selector)
        if not artifacts:
            print("  No artifacts found")
            return None

        latest = artifacts[-1]
        return self.download_artifact(latest, prefix)

    def download_all(
        self,
        artifact_selector: str,
        prefix: str = "",
        skip_loading: bool = True
    ) -> list:
        """
        Download all artifacts matching selector.

        Args:
            artifact_selector: CSS selector for artifact type
            prefix: Filename prefix
            skip_loading: Skip artifacts still loading

        Returns:
            List of download info dicts
        """
        from artifact_monitor import ArtifactMonitor

        artifacts = self.page.query_selector_all(artifact_selector)
        if not artifacts:
            print("  No artifacts found")
            return []

        results = []
        monitor = ArtifactMonitor(self.page)

        for i, artifact in enumerate(artifacts):
            # Skip if still loading
            if skip_loading and monitor.is_shimmer_loading(artifact):
                print(f"  [{i+1}] Skipping (still loading)")
                continue

            indexed_prefix = f"{i+1:02d}_{prefix}" if prefix else f"{i+1:02d}"
            result = self.download_artifact(artifact, indexed_prefix)

            if result:
                result["index"] = i + 1
                results.append(result)

            # Small delay between downloads
            time.sleep(0.5)

        return results

    def _format_filename(self, suggested: str, prefix: str) -> str:
        """
        Format filename with optional prefix.

        Args:
            suggested: Original suggested filename
            prefix: Prefix to add

        Returns:
            Formatted filename
        """
        if not prefix:
            return suggested

        # Split name and extension
        if '.' in suggested:
            name, ext = suggested.rsplit('.', 1)
        else:
            name, ext = suggested, 'pdf'

        # Clean prefix (replace spaces with underscores)
        clean_prefix = prefix.replace(' ', '_')

        return f"{clean_prefix}_{name}.{ext}"

"""
Element Finder for NotebookLM SuperSkill
Multi-selector resilient element finding patterns
"""

from typing import Optional, List

from patchright.sync_api import Page, ElementHandle


def wait_and_find(
    page: Page,
    selectors: List[str],
    timeout: int = 10,
    description: str = "element",
    state: str = "visible"
) -> Optional[ElementHandle]:
    """
    Try multiple selectors until one works - resilient element finding.

    This pattern handles UI changes gracefully by trying multiple
    selector variants in order.

    Args:
        page: Playwright page
        selectors: List of CSS selectors to try in order
        timeout: Timeout per selector in seconds
        description: Human-readable description for logging
        state: Element state to wait for (visible, attached, etc.)

    Returns:
        First matching element, or None if all selectors fail
    """
    for sel in selectors:
        try:
            el = page.wait_for_selector(sel, timeout=timeout * 1000, state=state)
            if el:
                print(f"  Found {description}: {sel}")
                return el
        except Exception:
            continue

    print(f"  Could not find {description}")
    return None


def find_any(page: Page, selectors: List[str]) -> Optional[ElementHandle]:
    """
    Find first matching element without waiting.

    Args:
        page: Playwright page
        selectors: List of CSS selectors to try

    Returns:
        First matching element, or None
    """
    for sel in selectors:
        try:
            el = page.query_selector(sel)
            if el and el.is_visible():
                return el
        except Exception:
            continue
    return None


def find_all(page: Page, selector: str) -> List[ElementHandle]:
    """
    Find all matching elements.

    Args:
        page: Playwright page
        selector: CSS selector

    Returns:
        List of matching elements (may be empty)
    """
    try:
        return page.query_selector_all(selector)
    except Exception:
        return []

#!/usr/bin/env python3
"""
Audio Overview Generator for NotebookLM SuperSkill
Generate AI podcast-style audio overviews from NotebookLM notebooks
"""

import sys
import time
import argparse
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))

from patchright.sync_api import sync_playwright

from browser_factory import BrowserFactory
from element_finder import wait_and_find
from artifact_monitor import ArtifactMonitor
from download_handler import DownloadHandler
from config import AUDIO_TIMEOUT_SECONDS


# Audio format descriptions
AUDIO_FORMATS = {
    "deep-dive": "Create a comprehensive deep dive podcast exploring all aspects of the content in detail.",
    "brief": "Create a concise overview podcast summarizing the key points quickly.",
    "critique": "Create a critical analysis podcast examining strengths, weaknesses, and implications.",
    "debate": "Create a debate-style podcast with multiple perspectives and counterarguments.",
}

# Common language codes (subset of 80+ supported)
SUPPORTED_LANGUAGES = [
    "en-US", "en-GB", "es-ES", "es-MX", "fr-FR", "de-DE",
    "it-IT", "pt-BR", "pt-PT", "ja-JP", "ko-KR", "zh-CN",
    "zh-TW", "ru-RU", "ar-SA", "hi-IN", "nl-NL", "pl-PL",
    "sv-SE", "da-DK", "fi-FI", "no-NO", "tr-TR", "th-TH",
    "vi-VN", "id-ID", "ms-MY", "tl-PH", "uk-UA", "cs-CZ",
]


def generate_audio_with_options(
    page,
    format_type: str = "deep-dive",
    language: str = "en-US",
    custom_prompt: str = None,
) -> bool:
    """
    Generate audio overview using the customization dialog.

    Args:
        page: Playwright page
        format_type: Audio format (deep-dive, brief, critique, debate)
        language: Language code (e.g., en-US, es-ES)
        custom_prompt: Custom instructions

    Returns:
        True if generation triggered successfully
    """
    print(f"\nGenerating audio overview...")
    print(f"   Format: {format_type}, Language: {language}")

    # Find Audio Overview in Studio panel
    audio_selectors = [
        "button[aria-label='Customise audio overview']",
        "button.edit-button[data-edit-button-type='audio']",
        ".create-artifact-button-container[aria-label='Audio Overview'] button.edit-button",
        "div[aria-label='Audio Overview'] button.edit-button",
    ]

    edit_btn = None
    for sel in audio_selectors:
        try:
            el = page.query_selector(sel)
            if el and el.is_visible():
                edit_btn = el
                print(f"  Found edit button: {sel}")
                break
        except:
            continue

    if not edit_btn:
        # Try direct container approach
        audio_container = page.query_selector("div[aria-label='Audio Overview']") or \
                          page.query_selector(".create-artifact-button-container:has-text('Audio Overview')")
        if audio_container:
            edit_btn = audio_container.query_selector("button.edit-button")

    if not edit_btn:
        # Fallback: click Audio Overview directly
        audio_btn = page.query_selector("div[aria-label='Audio Overview']") or \
                    page.query_selector("button:has-text('Audio Overview')")
        if audio_btn:
            audio_btn.click()
            time.sleep(1)
            dialog = page.query_selector("mat-dialog-container")
            if not dialog:
                print("  Triggered direct generation")
                return True
        else:
            print("  Could not find Audio Overview option")
            return False

    edit_btn.click()
    time.sleep(1)

    # Wait for dialog
    dialog = page.query_selector("mat-dialog-container")
    if not dialog:
        print("  Dialog didn't open, generation may have started directly")
        return True

    print("  Customization dialog opened")

    # Select format
    format_labels = {
        "deep-dive": "Deep dive",
        "brief": "Brief",
        "critique": "Critique",
        "debate": "Debate",
    }
    format_label = format_labels.get(format_type, "Deep dive")
    format_option = page.query_selector(f"mat-radio-button:has-text('{format_label}')")
    if format_option:
        format_option.click()
        print(f"  Selected format: {format_label}")
        time.sleep(0.3)

    # Select language
    lang_dropdown = page.query_selector("mat-select[aria-label*='language']") or \
                    page.query_selector("mat-select:has-text('Language')")
    if lang_dropdown:
        lang_dropdown.click()
        time.sleep(0.5)
        lang_option = page.query_selector(f"mat-option:has-text('{language}')")
        if lang_option:
            lang_option.click()
            print(f"  Selected language: {language}")
            time.sleep(0.3)

    # Fill custom prompt if provided
    if custom_prompt:
        textarea = page.query_selector("mat-dialog-container textarea")
        if textarea:
            textarea.click()
            textarea.fill("")
            textarea.fill(custom_prompt)
            print("  Filled custom prompt")
            time.sleep(0.3)

    # Click Generate
    gen_btn = page.query_selector("mat-dialog-container button:has-text('Generate')") or \
              page.query_selector("button:has-text('Generate')")
    if gen_btn:
        gen_btn.click()
        print("  Clicked Generate!")
        return True
    else:
        print("  Generate button not found")
        return False


def generate_audio(
    notebook_url: str,
    output_dir: str = None,
    format_type: str = "deep-dive",
    language: str = "en-US",
    custom_prompt: str = None,
    headless: bool = True
) -> str:
    """
    Generate an audio overview from a NotebookLM notebook.

    Args:
        notebook_url: NotebookLM notebook URL
        output_dir: Output directory
        format_type: Audio format (deep-dive, brief, critique, debate)
        language: Language code
        custom_prompt: Custom instructions
        headless: Run in headless mode

    Returns:
        Path to downloaded audio file, or None on failure
    """
    output_path = Path(output_dir) if output_dir else Path.cwd()
    output_path.mkdir(parents=True, exist_ok=True)

    print(f"Notebook: {notebook_url}")
    print(f"Output: {output_path}")
    print(f"Format: {format_type}")
    print(f"Language: {language}")
    print(f"Headless: {headless}\n")

    playwright = sync_playwright().start()
    context = BrowserFactory.launch_persistent_context(playwright, headless=headless)
    page = context.new_page()

    try:
        # Navigate
        print("1. Opening notebook...")
        page.goto(notebook_url, wait_until="domcontentloaded")
        time.sleep(4)

        # Count initial audio artifacts
        monitor = ArtifactMonitor(page, "audio")
        initial_count = monitor.count_artifacts()
        print(f"   Initial audio count: {initial_count}")

        # Trigger generation
        print("\n2. Triggering audio generation...")
        if not generate_audio_with_options(page, format_type, language, custom_prompt):
            print("Failed to trigger generation")
            return None

        # Wait for audio (longer timeout - podcasts take 5-10 min)
        print("\n3. Waiting for audio generation...")
        print("   (This may take 5-10 minutes for podcasts)")

        if not monitor.wait_for_artifact_ready(initial_count, AUDIO_TIMEOUT_SECONDS):
            print("Timeout waiting for audio")
            return None

        # Download
        print("\n4. Downloading audio...")
        time.sleep(2)

        downloader = DownloadHandler(page, output_path)
        result = downloader.download_latest("button[aria-description='Audio Overview']", f"{format_type}_{language}")

        if result:
            print(f"\nSuccess! Saved to: {result['path']}")
            return result['path']
        else:
            print("Download failed")
            return None

    except Exception as e:
        print(f"\nError: {e}")
        import traceback
        traceback.print_exc()
        return None

    finally:
        context.close()
        playwright.stop()


def main():
    parser = argparse.ArgumentParser(
        description='Generate audio overviews (podcasts) from NotebookLM',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Deep dive podcast in English
  python run.py generate_audio.py --notebook-url URL --format deep-dive

  # Brief overview in Spanish
  python run.py generate_audio.py --notebook-url URL --format brief --language es-ES

  # Debate format with custom prompt
  python run.py generate_audio.py --notebook-url URL --format debate --prompt "Focus on pros and cons"

Available formats:
  deep-dive  - Comprehensive exploration (10-15 min)
  brief      - Quick summary (3-5 min)
  critique   - Critical analysis
  debate     - Multiple perspectives

Common languages:
  en-US, en-GB, es-ES, fr-FR, de-DE, it-IT, pt-BR, ja-JP, ko-KR, zh-CN
        """
    )
    parser.add_argument('--notebook-url', required=True, help='NotebookLM notebook URL')
    parser.add_argument('--output', help='Output directory')
    parser.add_argument('--format', choices=['deep-dive', 'brief', 'critique', 'debate'],
                        default='deep-dive', help='Audio format')
    parser.add_argument('--language', default='en-US', help='Language code (e.g., en-US, es-ES)')
    parser.add_argument('--prompt', help='Custom instructions')
    parser.add_argument('--headless', action='store_true', help='Run in headless mode')

    args = parser.parse_args()

    result = generate_audio(
        notebook_url=args.notebook_url,
        output_dir=args.output,
        format_type=args.format,
        language=args.language,
        custom_prompt=args.prompt,
        headless=args.headless
    )
    sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Infographic Generator for NotebookLM SuperSkill
Generate visual infographics from NotebookLM notebooks
"""

import sys
import time
import argparse
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))

from patchright.sync_api import sync_playwright

from browser_factory import BrowserFactory
from element_finder import wait_and_find
from artifact_monitor import ArtifactMonitor
from download_handler import DownloadHandler
from config import ARTIFACT_TIMEOUT_SECONDS


# Orientation descriptions
ORIENTATIONS = {
    "square": "1:1 aspect ratio - ideal for social media posts",
    "portrait": "9:16 vertical - ideal for Instagram Stories, TikTok",
    "landscape": "16:9 horizontal - ideal for LinkedIn, presentations",
}

# Detail levels
DETAIL_LEVELS = {
    "concise": "High-level summary with key points only",
    "standard": "Balanced detail with main concepts",
    "detailed": "Comprehensive with supporting details",
}


def generate_infographic_with_options(
    page,
    orientation: str = "landscape",
    detail: str = "standard",
    custom_prompt: str = None,
) -> bool:
    """
    Generate infographic using the customization dialog.

    Args:
        page: Playwright page
        orientation: Aspect ratio (square, portrait, landscape)
        detail: Detail level (concise, standard, detailed)
        custom_prompt: Custom instructions

    Returns:
        True if generation triggered successfully
    """
    print(f"\nGenerating infographic...")
    print(f"   Orientation: {orientation}, Detail: {detail}")

    # Find Infographic in Studio panel
    infographic_selectors = [
        "button[aria-label='Customise infographic']",
        "button.edit-button[data-edit-button-type='infographic']",
        ".create-artifact-button-container[aria-label='Infographic'] button.edit-button",
        "div[aria-label='Infographic'] button.edit-button",
    ]

    edit_btn = None
    for sel in infographic_selectors:
        try:
            el = page.query_selector(sel)
            if el and el.is_visible():
                edit_btn = el
                print(f"  Found edit button: {sel}")
                break
        except:
            continue

    if not edit_btn:
        # Try container approach
        container = page.query_selector("div[aria-label='Infographic']") or \
                    page.query_selector(".create-artifact-button-container:has-text('Infographic')")
        if container:
            edit_btn = container.query_selector("button.edit-button")

    if not edit_btn:
        # Fallback: click Infographic directly
        btn = page.query_selector("div[aria-label='Infographic']") or \
              page.query_selector("button:has-text('Infographic')")
        if btn:
            btn.click()
            time.sleep(1)
            dialog = page.query_selector("mat-dialog-container")
            if not dialog:
                print("  Triggered direct generation")
                return True
        else:
            print("  Could not find Infographic option")
            return False

    edit_btn.click()
    time.sleep(1)

    # Wait for dialog
    dialog = page.query_selector("mat-dialog-container")
    if not dialog:
        print("  Dialog didn't open, generation may have started directly")
        return True

    print("  Customization dialog opened")

    # Select orientation
    orientation_labels = {
        "square": "Square",
        "portrait": "Portrait",
        "landscape": "Landscape",
    }
    orientation_label = orientation_labels.get(orientation, "Landscape")
    orientation_option = page.query_selector(f"mat-button-toggle:has-text('{orientation_label}')") or \
                         page.query_selector(f"mat-radio-button:has-text('{orientation_label}')")
    if orientation_option:
        orientation_option.click()
        print(f"  Selected orientation: {orientation_label}")
        time.sleep(0.3)

    # Select detail level
    detail_labels = {
        "concise": "Concise",
        "standard": "Standard",
        "detailed": "Detailed",
    }
    detail_label = detail_labels.get(detail, "Standard")
    detail_option = page.query_selector(f"mat-button-toggle:has-text('{detail_label}')") or \
                    page.query_selector(f"mat-radio-button:has-text('{detail_label}')")
    if detail_option:
        detail_option.click()
        print(f"  Selected detail: {detail_label}")
        time.sleep(0.3)

    # Fill custom prompt if provided
    if custom_prompt:
        textarea = page.query_selector("mat-dialog-container textarea")
        if textarea:
            textarea.click()
            textarea.fill("")
            textarea.fill(custom_prompt)
            print("  Filled custom prompt")
            time.sleep(0.3)

    # Click Generate
    gen_btn = page.query_selector("mat-dialog-container button:has-text('Generate')") or \
              page.query_selector("button:has-text('Generate')")
    if gen_btn:
        gen_btn.click()
        print("  Clicked Generate!")
        return True
    else:
        print("  Generate button not found")
        return False


def generate_infographic(
    notebook_url: str,
    output_dir: str = None,
    orientation: str = "landscape",
    detail: str = "standard",
    custom_prompt: str = None,
    headless: bool = True
) -> str:
    """
    Generate an infographic from a NotebookLM notebook.

    Args:
        notebook_url: NotebookLM notebook URL
        output_dir: Output directory
        orientation: Aspect ratio (square, portrait, landscape)
        detail: Detail level (concise, standard, detailed)
        custom_prompt: Custom instructions
        headless: Run in headless mode

    Returns:
        Path to downloaded infographic, or None on failure
    """
    output_path = Path(output_dir) if output_dir else Path.cwd()
    output_path.mkdir(parents=True, exist_ok=True)

    print(f"Notebook: {notebook_url}")
    print(f"Output: {output_path}")
    print(f"Orientation: {orientation}")
    print(f"Detail: {detail}")
    print(f"Headless: {headless}\n")

    playwright = sync_playwright().start()
    context = BrowserFactory.launch_persistent_context(playwright, headless=headless)
    page = context.new_page()

    try:
        # Navigate
        print("1. Opening notebook...")
        page.goto(notebook_url, wait_until="domcontentloaded")
        time.sleep(4)

        # Count initial infographic artifacts
        monitor = ArtifactMonitor(page, "infographic")
        initial_count = monitor.count_artifacts()
        print(f"   Initial infographic count: {initial_count}")

        # Trigger generation
        print("\n2. Triggering infographic generation...")
        if not generate_infographic_with_options(page, orientation, detail, custom_prompt):
            print("Failed to trigger generation")
            return None

        # Wait for infographic
        print("\n3. Waiting for infographic...")
        if not monitor.wait_for_artifact_ready(initial_count, ARTIFACT_TIMEOUT_SECONDS):
            print("Timeout waiting for infographic")
            return None

        # Download
        print("\n4. Downloading infographic...")
        time.sleep(2)

        downloader = DownloadHandler(page, output_path)
        result = downloader.download_latest("button[aria-description='Infographic']", f"{orientation}_{detail}")

        if result:
            print(f"\nSuccess! Saved to: {result['path']}")
            return result['path']
        else:
            print("Download failed")
            return None

    except Exception as e:
        print(f"\nError: {e}")
        import traceback
        traceback.print_exc()
        return None

    finally:
        context.close()
        playwright.stop()


def main():
    parser = argparse.ArgumentParser(
        description='Generate infographics from NotebookLM',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Landscape infographic with standard detail
  python run.py generate_infographic.py --notebook-url URL

  # Portrait for social media with concise detail
  python run.py generate_infographic.py --notebook-url URL --orientation portrait --detail concise

  # Square with custom prompt
  python run.py generate_infographic.py --notebook-url URL --orientation square --prompt "Focus on statistics"

Orientations:
  square     - 1:1 ratio (social media posts)
  portrait   - 9:16 ratio (Instagram Stories, TikTok)
  landscape  - 16:9 ratio (LinkedIn, presentations)

Detail levels:
  concise   - High-level key points only
  standard  - Balanced detail
  detailed  - Comprehensive with supporting info
        """
    )
    parser.add_argument('--notebook-url', required=True, help='NotebookLM notebook URL')
    parser.add_argument('--output', help='Output directory')
    parser.add_argument('--orientation', choices=['square', 'portrait', 'landscape'],
                        default='landscape', help='Aspect ratio')
    parser.add_argument('--detail', choices=['concise', 'standard', 'detailed'],
                        default='standard', help='Detail level')
    parser.add_argument('--prompt', help='Custom instructions')
    parser.add_argument('--headless', action='store_true', help='Run in headless mode')

    args = parser.parse_args()

    result = generate_infographic(
        notebook_url=args.notebook_url,
        output_dir=args.output,
        orientation=args.orientation,
        detail=args.detail,
        custom_prompt=args.prompt,
        headless=args.headless
    )
    sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Slide Deck Generator for NotebookLM SuperSkill
Generate customized slide decks from NotebookLM notebooks
"""

import sys
import time
import argparse
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))

from patchright.sync_api import sync_playwright

from browser_factory import BrowserFactory
from element_finder import wait_and_find
from artifact_monitor import ArtifactMonitor
from download_handler import DownloadHandler
from stealth_utils import StealthUtils
from config import ARTIFACT_TIMEOUT_SECONDS


# Predefined audience prompts
AUDIENCE_PROMPTS = {
    "technical": "Create a detailed technical presentation for software engineers and developers. Focus on architecture, implementation details, technical specifications, and code examples. Use precise technical terminology.",
    "investor": "Create a compelling investor pitch deck. Focus on market opportunity, business model, competitive advantages, financial projections, and growth potential. Use clear metrics and persuasive language.",
    "customer": "Create a customer-facing presentation that highlights benefits and value proposition. Focus on how the product solves problems, ease of use, and success stories. Use simple, accessible language.",
    "executive": "Create an executive summary presentation for C-level decision makers. Focus on strategic value, ROI, key metrics, and high-level roadmap. Be concise and business-focused.",
    "beginner": "Create an introductory presentation for beginners new to the topic. Focus on fundamentals, step-by-step explanations, and simple examples. Use clear, educational language.",
}


def upload_source(page, source_path: Path) -> bool:
    """Upload a source file to the current notebook"""
    print("Uploading source file...")

    upload_selectors = [
        "button[aria-label='Upload sources from your computer']",
        "button[aria-label='Opens the upload source dialogue']",
        "button:has-text('Upload a source')",
    ]

    upload_btn = wait_and_find(page, upload_selectors, timeout=5, description="upload button")
    if upload_btn:
        upload_btn.click()
        time.sleep(1)

    file_input = page.query_selector("input[type='file']")
    if file_input:
        file_input.set_input_files(str(source_path))
        print(f"  File selected: {source_path.name}")
    else:
        print("  No file input found")
        return False

    # Wait for upload to complete
    print("  Processing source...")
    time.sleep(5)

    for i in range(30):
        modal = page.query_selector("[role='dialog']:has-text('Add sources')")
        if not modal or not modal.is_visible():
            print("  Source added!")
            return True
        time.sleep(1)
        if i % 10 == 0 and i > 0:
            print(f"  Still processing... ({i}s)")

    return True


def generate_slide_with_options(
    page,
    prompt: str = "",
    format_type: str = "detailed",
    length: str = "default",
) -> bool:
    """
    Generate slides using the customization dialog.

    Args:
        page: Playwright page
        prompt: Custom prompt for slide content
        format_type: "detailed" or "presenter"
        length: "short", "default", or "long"

    Returns:
        True if generation triggered successfully
    """
    print(f"\nGenerating slides...")
    print(f"   Format: {format_type}, Length: {length}")
    if prompt:
        print(f"   Prompt: {prompt[:50]}...")

    # Find and click the Edit button on Slide Deck
    edit_btn_selectors = [
        "button[aria-label='Customise slide deck']",
        "button.edit-button[data-edit-button-type='8']",
        ".create-artifact-button-container[aria-label='Slide deck'] button.edit-button",
        "div[aria-label='Slide deck'] button.edit-button",
    ]

    edit_btn = None
    for sel in edit_btn_selectors:
        try:
            el = page.query_selector(sel)
            if el and el.is_visible():
                edit_btn = el
                print(f"  Found edit button: {sel}")
                break
        except:
            continue

    if not edit_btn:
        # Try container approach
        slide_container = page.query_selector("div.create-artifact-button-container[aria-label='Slide deck']") or \
                          page.query_selector("div[aria-label='Slide deck']")
        if slide_container:
            edit_btn = slide_container.query_selector("button.edit-button")
            if edit_btn:
                print("  Found edit button via container")

    if not edit_btn:
        print("  Edit button not found, trying direct click...")
        slide_btn = page.query_selector("div[aria-label='Slide deck']")
        if slide_btn:
            slide_btn.click()
            time.sleep(1)
            dialog = page.query_selector("mat-dialog-container:has-text('Customise')")
            if not dialog:
                return True
        else:
            print("  Could not find Slide Deck option")
            return False

    edit_btn.click()
    time.sleep(1)

    # Wait for dialog
    dialog = page.wait_for_selector("mat-dialog-container:has-text('Customise')", timeout=5000)
    if not dialog:
        print("  Customization dialog didn't open")
        return False

    print("  Customization dialog opened")

    # Set Format
    if format_type == "presenter":
        presenter_radio = page.query_selector("mat-radio-button:has-text('Presenter slides')")
        if presenter_radio:
            presenter_radio.click()
            print("  Selected: Presenter slides")
            time.sleep(0.3)
    else:
        detailed_radio = page.query_selector("mat-radio-button:has-text('Detailed deck')")
        if detailed_radio:
            detailed_radio.click()
            print("  Selected: Detailed deck")
            time.sleep(0.3)

    # Set Length
    length_map = {"short": "Short", "default": "Default", "long": "Long"}
    length_label = length_map.get(length, "Default")
    length_btn = page.query_selector(f"mat-button-toggle:has-text('{length_label}')")
    if length_btn:
        length_btn.click()
        print(f"  Selected length: {length_label}")
        time.sleep(0.3)

    # Set Prompt
    if prompt:
        textarea = page.query_selector("mat-dialog-container textarea")
        if textarea:
            textarea.click()
            textarea.fill("")
            textarea.fill(prompt)
            print("  Filled prompt")
            time.sleep(0.3)

    # Click Generate
    gen_btn = page.query_selector("mat-dialog-container button:has-text('Generate')")
    if gen_btn:
        gen_btn.click()
        print("  Clicked Generate!")
        return True
    else:
        print("  Generate button not found")
        return False


def generate_slides(
    notebook_url: str,
    source_file: str = None,
    output_dir: str = None,
    audience: str = "technical",
    format_type: str = "detailed",
    length: str = "default",
    custom_prompt: str = None,
    headless: bool = True
) -> str:
    """
    Generate a slide deck from a NotebookLM notebook.

    Args:
        notebook_url: NotebookLM notebook URL
        source_file: Optional source file to upload
        output_dir: Output directory for slides
        audience: Audience type (technical, investor, customer, executive, beginner)
        format_type: Slide format (detailed, presenter)
        length: Slide length (short, default, long)
        custom_prompt: Custom prompt (overrides audience)
        headless: Run in headless mode

    Returns:
        Path to downloaded slides, or None on failure
    """
    output_path = Path(output_dir) if output_dir else Path.cwd()
    output_path.mkdir(parents=True, exist_ok=True)

    # Use custom prompt or audience prompt
    prompt = custom_prompt if custom_prompt else AUDIENCE_PROMPTS.get(audience, audience)

    print(f"Notebook: {notebook_url}")
    print(f"Output: {output_path}")
    print(f"Audience: {audience}")
    print(f"Headless: {headless}\n")

    playwright = sync_playwright().start()
    context = BrowserFactory.launch_persistent_context(playwright, headless=headless)
    page = context.new_page()

    try:
        # Navigate to notebook
        print("1. Opening notebook...")
        page.goto(notebook_url, wait_until="domcontentloaded")
        time.sleep(4)

        # Upload source if provided
        if source_file:
            source_path = Path(source_file).absolute()
            if not source_path.exists():
                print(f"File not found: {source_file}")
                return None

            modal = page.query_selector("[role='dialog']:has-text('Add sources')")
            if modal and modal.is_visible():
                print("2. Uploading source...")
                if not upload_source(page, source_path):
                    print("Failed to upload source")
                    return None
                time.sleep(3)
            else:
                print("2. Notebook already has sources")
        else:
            print("2. Using existing sources")

        # Count initial artifacts
        monitor = ArtifactMonitor(page, "slides")
        initial_count = monitor.count_artifacts()
        print(f"   Initial slide count: {initial_count}")

        # Trigger generation
        print("\n3. Triggering slide generation...")
        if not generate_slide_with_options(page, prompt, format_type, length):
            print("Failed to trigger generation")
            return None

        # Wait for slides to be ready
        print("\n4. Waiting for slides...")
        if not monitor.wait_for_artifact_ready(initial_count, ARTIFACT_TIMEOUT_SECONDS):
            print("Timeout waiting for slides")
            return None

        # Download
        print("\n5. Downloading slides...")
        time.sleep(1)

        downloader = DownloadHandler(page, output_path)
        result = downloader.download_latest("button[aria-description='Slides']", audience)

        if result:
            print(f"\nSuccess! Saved to: {result['path']}")
            return result['path']
        else:
            print("Download failed")
            return None

    except Exception as e:
        print(f"\nError: {e}")
        import traceback
        traceback.print_exc()
        return None

    finally:
        context.close()
        playwright.stop()


def generate_multiple_slides(
    notebook_url: str,
    source_file: str = None,
    output_dir: str = None,
    audiences: list = None,
    format_type: str = "detailed",
    length: str = "default",
    headless: bool = True
) -> list:
    """
    Generate multiple slide decks for different audiences.

    Uses 3-phase approach:
    1. Trigger all generations quickly
    2. Wait for all to complete
    3. Download all slides

    Args:
        notebook_url: NotebookLM notebook URL
        source_file: Optional source file
        output_dir: Output directory
        audiences: List of audience types
        format_type: Slide format
        length: Slide length
        headless: Run in headless mode

    Returns:
        List of downloaded file paths
    """
    if not audiences:
        audiences = ["technical", "investor", "customer"]

    output_path = Path(output_dir) if output_dir else Path.cwd()
    output_path.mkdir(parents=True, exist_ok=True)

    print(f"Notebook: {notebook_url}")
    print(f"Output: {output_path}")
    print(f"Audiences: {', '.join(audiences)}\n")

    playwright = sync_playwright().start()
    context = BrowserFactory.launch_persistent_context(playwright, headless=headless)
    page = context.new_page()

    results = []

    try:
        # Navigate
        print("1. Opening notebook...")
        page.goto(notebook_url, wait_until="domcontentloaded")
        time.sleep(4)

        # Upload source if provided
        if source_file:
            source_path = Path(source_file).absolute()
            if source_path.exists():
                modal = page.query_selector("[role='dialog']:has-text('Add sources')")
                if modal and modal.is_visible():
                    print("2. Uploading source...")
                    upload_source(page, source_path)
                    time.sleep(3)

        # Count initial artifacts
        monitor = ArtifactMonitor(page, "slides")
        initial_count = monitor.count_artifacts()
        print(f"   Initial slide count: {initial_count}")

        # PHASE 1: Trigger all generations
        print(f"\n{'='*50}")
        print(f"PHASE 1: TRIGGERING {len(audiences)} GENERATIONS")
        print('='*50)

        triggered = []
        for i, audience in enumerate(audiences, 1):
            print(f"\n[{i}/{len(audiences)}] Triggering: {audience.upper()}")
            prompt = AUDIENCE_PROMPTS.get(audience, audience)

            if generate_slide_with_options(page, prompt, format_type, length):
                triggered.append(audience)
                print(f"  {audience} triggered!")
            else:
                print(f"  {audience}: Failed to trigger")

            time.sleep(1)

        print(f"\nTriggered {len(triggered)}/{len(audiences)} generations")

        # PHASE 2: Wait for all slides
        print(f"\n{'='*50}")
        print("PHASE 2: WAITING FOR COMPLETION")
        print('='*50)

        expected_count = initial_count + len(triggered)
        monitor.wait_for_multiple_ready(expected_count, ARTIFACT_TIMEOUT_SECONDS * 2)

        time.sleep(2)

        # PHASE 3: Download all
        print(f"\n{'='*50}")
        print("PHASE 3: DOWNLOADING")
        print('='*50)

        artifacts = page.query_selector_all("button[aria-description='Slides']")
        new_artifacts = artifacts[initial_count:]

        for i, (audience, artifact) in enumerate(zip(triggered, new_artifacts)):
            print(f"\n[{i+1}/{len(new_artifacts)}] Downloading: {audience}")

            try:
                downloader = DownloadHandler(page, output_path)
                result = downloader.download_artifact(artifact, audience)
                if result:
                    results.append(result['path'])
            except Exception as e:
                print(f"  Error: {e}")

            time.sleep(0.5)

        print(f"\n{'='*50}")
        print(f"COMPLETED: {len(results)}/{len(audiences)} slide decks")
        print('='*50)

        for r in results:
            print(f"   {Path(r).name}")

        return results

    except Exception as e:
        print(f"\nError: {e}")
        import traceback
        traceback.print_exc()
        return results

    finally:
        context.close()
        playwright.stop()


def main():
    parser = argparse.ArgumentParser(
        description='Generate slide decks from NotebookLM',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Single slide deck
  python run.py generate_slides.py --notebook-url URL --audience technical

  # Multiple audiences
  python run.py generate_slides.py --notebook-url URL --audiences technical,investor,customer

  # With source file
  python run.py generate_slides.py --notebook-url URL --source spec.md --audience investor

Available audience types:
  technical  - For developers (architecture, code, specs)
  investor   - For investors (market, financials, growth)
  customer   - For customers (benefits, value, ease of use)
  executive  - For C-level (strategy, ROI, metrics)
  beginner   - For newcomers (fundamentals, step-by-step)
        """
    )
    parser.add_argument('--notebook-url', required=True, help='NotebookLM notebook URL')
    parser.add_argument('--source', help='Path to source file to upload')
    parser.add_argument('--output', help='Output directory')
    parser.add_argument('--audience', default='technical', help='Audience type')
    parser.add_argument('--audiences', help='Comma-separated audience types for batch generation')
    parser.add_argument('--format', choices=['detailed', 'presenter'], default='detailed', help='Slide format')
    parser.add_argument('--length', choices=['short', 'default', 'long'], default='default', help='Slide length')
    parser.add_argument('--prompt', help='Custom prompt (overrides audience)')
    parser.add_argument('--headless', action='store_true', help='Run in headless mode')

    args = parser.parse_args()

    if args.audiences:
        audiences = [a.strip() for a in args.audiences.split(',')]
        results = generate_multiple_slides(
            notebook_url=args.notebook_url,
            source_file=args.source,
            output_dir=args.output,
            audiences=audiences,
            format_type=args.format,
            length=args.length,
            headless=args.headless
        )
        sys.exit(0 if results else 1)
    else:
        result = generate_slides(
            notebook_url=args.notebook_url,
            source_file=args.source,
            output_dir=args.output,
            audience=args.audience,
            format_type=args.format,
            length=args.length,
            custom_prompt=args.prompt,
            headless=args.headless
        )
        sys.exit(0 if result else 1)


if __name__ == "__main__":
    main()