import re
from typing import Optional, Dict
from bs4 import BeautifulSoup
import html2text
from curl_cffi import requests

class StealthScraper:
    """Chrome 124 TLS & HTTP/2 mimarisini taklit eden hafif kazıma motoru."""
    def __init__(self, impersonate_target: str = "chrome124", timeout: int = 20):
        self.impersonate_target = impersonate_target
        self.timeout = timeout
        self._h2t = html2text.HTML2Text()
        self._h2t.body_width = 0

    def scrape_to_markdown(self, url: str) -> str:
        headers = {
            "Accept-Language": "en-US,en;q=0.9",
            "Sec-Ch-Ua": '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
            "Sec-Ch-Ua-Mobile": "?0",
            "Sec-Ch-Ua-Platform": '"Windows"'
        }
        with requests.Session(impersonate=self.impersonate_target) as session:
            response = session.get(url, headers=headers, timeout=self.timeout)

        soup = BeautifulSoup(response.text, "html.parser")
        for tag in soup(["script", "style", "noscript", "iframe", "footer", "nav", "header"]):
            tag.decompose()
        for ad in soup.select(".ad, .advertisement, .cookie-banner"):
            ad.decompose()

        md = self._h2t.handle(str(soup))
        return re.sub(r"\n{3,}", "\n\n", md).strip()

def fetch_markdown(url: str) -> str:
    return StealthScraper().scrape_to_markdown(url)

import asyncio
from bs4 import BeautifulSoup
from trace_logger import AntigravityTraceLogger
from browser_manager import StealthBrowserManager
from playwright.async_api import async_playwright

class AutonomousResearchBrain:
    """Ana Sense-Plan-Act bilişsel motoru: Temiz Bilgi Sentez Motoru."""
    def __init__(self):
        self.logger = AntigravityTraceLogger()
        self.browser_manager = StealthBrowserManager(self.logger)

    def sense_and_clean_dom(self, html_content: str) -> str:
        """SENSE: DOM'u analiz eder, reklam, çerez ve SEO çöplerini temizler."""
        soup = BeautifulSoup(html_content, "html.parser")
        
        # Gürültü Filtreleme: Gereksiz etiketleri uçur
        for element in soup(["script", "style", "nav", "footer", "iframe", "noscript", "header"]):
            element.decompose()
            
        self.logger.log_step("SENSE", "DOM_Cleaned", {"characters_remaining": len(soup.get_text())})
        return " ".join(soup.get_text().split())

    async def execute_research(self, target_url: str):
        """PLAN & ACT: Sürekli döngüyü çalıştırır."""
        async with async_playwright() as p:
            browser, context = await self.browser_manager.get_stealth_context(p)
            page = await context.new_page()
            
            try:
                # Sayfaya git ve insan taklidi yap
                await self.browser_manager.human_like_navigate(page, target_url)
                
                # Sayfa içeriğini al
                raw_html = await page.content()
                
                # Bilgiyi işle ve temizle
                cleaned_data = self.sense_and_clean_dom(raw_html)
                
                # PLAN: Bir sonraki adımda ne yapılacağına karar ver
                self.logger.log_step("PLAN", "Synthesize_Information", {"data_preview": cleaned_data[:100]})
                
                # Kalıcı çıktı oluştur
                self.logger.save_artifact("research_result.txt", cleaned_data)
                return cleaned_data
                
            except Exception as e:
                self.logger.log_step("ACT", "Execution_Failed", {"error": str(e)})
            finally:
                await browser.close()

if __name__ == "__main__":
    brain = AutonomousResearchBrain()
    asyncio.run(brain.execute_research("https://ycombinator.com"))

import asyncio
import random
from playwright.async_api import async_playwright
from trace_logger import AntigravityTraceLogger

class StealthBrowserManager:
    """Cloudflare, PerimeterX ve gelişmiş CAPTCHA sistemlerini atlatmak için Playwright Wrapper."""
    def __init__(self, logger: AntigravityTraceLogger):
        self.logger = logger
        self.user_agents = [
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
        ]

    async def get_stealth_context(self, playwright):
        """Rastgele kimlik ve insan taklitli başlıklar içeren tarayıcı oturumu açar."""
        ua = random.choice(self.user_agents)
        browser = await playwright.chromium.launch(headless=True)
        
        context = await browser.new_context(
            user_agent=ua,
            viewport={"width": 1920, "height": 1080},
            locale="en-US",
            timezone_id="America/New_York"
        )
        
        self.logger.log_step("ACT", "Browser_Rotation", {"user_agent": ua})
        return browser, context

    async def human_like_navigate(self, page, url: str):
        """İnsan benzeri gecikmeler ve hareketlerle sayfaya gider."""
        self.logger.log_step("ACT", "Navigate_To_URL", {"url": url})
        await page.goto(url, wait_until="networkidle")
        
        # İnsan taklidi: Rastgele kaydırma (scroll) hareketi
        await page.evaluate("window.scrollTo(0, document.body.scrollHeight / 3)")
        await asyncio.sleep(random.uniform(1.5, 3.5))

import json
import time
from typing import Any, Dict

class AntigravityTraceLogger:
    """
    Google Antigravity Trace API ile %100 uyumlu, deterministik takip katmanı.
    Vendor lock-in içermez, her altyapıda bağımsız çalışır.
    """
    def __init__(self, agent_id: str = "deep-research-agent-001"):
        self.agent_id = agent_id
        
    def log_step(self, phase: str, action: str, details: Dict[str, Any]):
        """Ajanın Sense-Plan-Act döngüsündeki her adımı kayıt altına alır."""
        payload = {
            "timestamp": time.time(),
            "agent_id": self.agent_id,
            "phase": phase,  # SENSE, PLAN, ACT
            "action": action,
            "details": details
        }
        # Üretim ortamında bu çıktı Antigravity Trace API'ye yönlendirilir
        print(f"[TRACE][{phase}] {action} -> {json.dumps(details, ensure_ascii=False)}")

    def save_artifact(self, name: str, content: Any):
        """Çıkarılan temiz veriyi bir kalıcı çıktı (artifact) olarak kaydeder."""
        print(f"[ARTIFACT] Saved: {name}")
        return {"artifact_name": name, "status": "stored"}

playwright>=1.40.0
beautifulsoup4>=4.12.0
pydantic>=2.5.0
asyncio>=3.4.3