Integrations

python forge.py --daytona

from forge import run_forge

result = run_forge(
    objective="Generate weekly AI events",
    use_daytona=True
)

# From daytona_runner.py:124-133
config = DaytonaConfig(api_key=api_key)
daytona = Daytona(config)

sandbox = daytona.create()
sandbox_id = sandbox.id if hasattr(sandbox, 'id') else str(sandbox)

# From daytona_runner.py:150-154
cmd = f"python3 {sandbox_script_path} '{escaped_objective}' {sandbox_output}"
result = sandbox.process.exec(cmd, timeout=60)

output = result.result if hasattr(result, 'result') else str(result)
exit_code = result.exit_code if hasattr(result, 'exit_code') else 0

# From daytona_runner.py:204-207
if sandbox:
    try:
        daytona.delete(sandbox)
    except Exception as e:
        log(f"[Warn] Cleanup failed: {e}")

# From forge.py:56-69
def init_sentry():
    global _sentry_initialized
    if _sentry_initialized:
        return True
    try:
        import sentry_sdk
        sentry_dsn = os.getenv("SENTRY_DSN")
        if sentry_dsn and not sentry_dsn.startswith("https://your"):
            sentry_sdk.init(dsn=sentry_dsn, traces_sample_rate=1.0)
            _sentry_initialized = True
            return True
    except ImportError:
        pass
    return False

# From forge.py:424-426
if init_sentry():
    print("[Sentry] Initialized")

# From forge.py:169-182
if result.returncode != 0:
    error_occurred = True
    error_message = result.stderr[:500] if result.stderr else f"Exit code {result.returncode}"
    log(f"[Error] {error_message[:80]}")

    try:
        import sentry_sdk
        sentry_sdk.capture_message(
            f"Candidate {candidate_id} failed: {error_message[:200]}",
            level="error"
        )
        log("[Sentry] Error captured")
    except:
        pass

# From specs/INTEGRATIONS.md:183-194
async def submit_for_review(candidate: PolishedCandidate) -> dict:
    """
    Submit candidate code to CodeRabbit for review.
    """
    response = await coderabbit_client.post("/reviews", json={
        "files": [
            {"path": f.path, "content": f.content}
            for f in candidate.code_files
        ],
        "context": f"Hackathon prototype for: {candidate.approach_description}",
        "review_type": "full",
        "language": "python"
    })
    return response

# Before
try:
    response = await fetch()
except:
    pass

# After
try:
    response = await fetch()
except httpx.HTTPError as e:
    logger.error(f"API error: {e}")
    raise

# Before
element = driver.find_element(...)
element.click()

# After
try:
    element = driver.find_element(...)
    element.click()
except NoSuchElementException:
    logger.warning("Element not found")

# Before
soup = BeautifulSoup(html)
events = parse_events(soup)
# No fallback for JS pages

# After
soup = BeautifulSoup(html, 'lxml')
events = parse_events(soup)
if not events:
    logger.info("JS page, using API")
    events = fallback_api_fetch()

# From src/elevenlabs.py (imported in app.py)
def is_configured() -> bool:
    """Check if ElevenLabs is configured."""
    api_key = os.getenv("ELEVENLABS_API_KEY")
    return api_key is not None and not api_key.startswith("your_")

# From app.py:655-659
narration_script = generate_winner_script(
    winner_name,
    result.winner_score,
    result.objective,
)

# From src/elevenlabs.py
def generate_winner_script(
    winner_name: str,
    score: float,
    objective: str
) -> str:
    return f"""Congratulations! After a fierce competition in the Dream Foundry,
    {winner_name} has emerged victorious with a score of {score:.1f} out of 100.
    
    The objective was: {objective}
    
    {winner_name} delivered exceptional results, demonstrating the perfect balance
    of speed, quality, and reliability. This winning implementation will now be
    deployed to production.
    
    The Dream Foundry - where AI agents compete, and the best code wins.
    """

# From app.py:663-670
if st.button("Generate & Play Audio", use_container_width=True):
    with st.spinner("Generating audio with ElevenLabs..."):
        audio_bytes = generate_audio(narration_script)
        if audio_bytes:
            st.session_state.winner_audio = audio_bytes
            st.success("Audio generated!")
        else:
            st.error("Failed to generate audio. Check API key.")

# From app.py:672-674
if st.session_state.winner_audio:
    st.audio(st.session_state.winner_audio, format="audio/mp3")

# From specs/INTEGRATIONS.md:289-315
async def generate_voice(
    text: str,
    voice_type: Literal["engineering", "marketing", "executive"],
    output_path: str
) -> str:
    """
    Generate voice audio from text using ElevenLabs.
    Returns path to generated audio file.
    """
    voice_id = VOICES[voice_type]

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}",
            headers={
                "xi-api-key": os.getenv("ELEVENLABS_API_KEY"),
                "Content-Type": "application/json"
            },
            json={
                "text": text,
                "model_id": "eleven_multilingual_v2",
                "voice_settings": {
                    "stability": 0.5,
                    "similarity_boost": 0.75
                }
            }
        )

        with open(output_path, "wb") as f:
            f.write(response.content)

        return output_path

# .env
DISCORD_WEBHOOK_URL=your_discord_webhook_url

# From app.py:691-705
if st.button("Post to Discord", use_container_width=True):
    with st.spinner("Posting to Discord..."):
        success, msg = post_winner_announcement(
            winner_id=result.winner_id,
            winner_score=result.winner_score,
            artifact_content=result.winner_artifact or "No content",
            objective=result.objective,
        )
        if success:
            st.session_state.posted_to_discord = True
            st.success("Posted to Discord!")
            st.balloons()
            st.rerun()
        else:
            st.error(f"Failed: {msg}")

# Daytona - Sandbox execution
DAYTONA_API_KEY=your_daytona_api_key
DAYTONA_BASE_URL=https://api.daytona.io/v1

# Sentry - Error monitoring
SENTRY_DSN=https://[email protected]/xxx

# CodeRabbit - Code review
CODERABBIT_TOKEN=your_coderabbit_token

# ElevenLabs - Voice synthesis
ELEVENLABS_API_KEY=your_elevenlabs_api_key

# Discord - Demo posting (optional)
DISCORD_WEBHOOK_URL=your_discord_webhook

#!/usr/bin/env python3
"""Check integration status."""

import os
from src.daytona_runner import is_daytona_configured
from src.elevenlabs import is_configured as elevenlabs_configured
from src.discord_poster import is_discord_configured

def check_integrations():
    print("Integration Status")
    print("=" * 40)
    
    # Daytona
    daytona_ok = is_daytona_configured()
    print(f"Daytona:    {'✓' if daytona_ok else '✗'}")
    
    # Sentry
    sentry_ok = bool(os.getenv("SENTRY_DSN"))
    print(f"Sentry:     {'✓' if sentry_ok else '✗'}")
    
    # CodeRabbit
    coderabbit_ok = bool(os.getenv("CODERABBIT_TOKEN"))
    print(f"CodeRabbit: {'✓' if coderabbit_ok else '✗'}")
    
    # ElevenLabs
    elevenlabs_ok = elevenlabs_configured()
    print(f"ElevenLabs: {'✓' if elevenlabs_ok else '✗'}")
    
    # Discord
    discord_ok = is_discord_configured()
    print(f"Discord:    {'✓' if discord_ok else '✗'}")
    
    print("=" * 40)
    
    if all([daytona_ok, sentry_ok, coderabbit_ok, elevenlabs_ok]):
        print("All core integrations configured! 🎉")
    else:
        print("Some integrations need configuration.")

if __name__ == "__main__":
    check_integrations()

python check_integrations.py