Claude Code transcript - page 1/9

"""Pydantic models for ReviewLens."""

from __future__ import annotations

from datetime import datetime
from enum import Enum
from typing import Any

from pydantic import BaseModel, Field


class Review(BaseModel):
    """A single review record."""

    id: str = ""
    text: str
    rating: float | None = None
    date: datetime | None = None
    author: str = ""
    platform: str = ""
    metadata: dict[str, Any] = Field(default_factory=dict)


class IngestionSummary(BaseModel):
    """Summary shown after ingestion."""

    total_reviews: int = 0
    date_range: str = ""
    rating_distribution: dict[str, int] = Field(default_factory=dict)
    average_rating: float | None = None
    platform: str = ""
    product_name: str = ""
    source_type: str = ""  # "csv" or "url"


class ChatMessage(BaseModel):
    """A single chat message."""

    role: str  # "user" or "assistant"
    content: str
    charts: list[dict[str, Any]] = Field(default_factory=list)
    follow_ups: list[str] = Field(default_factory=list)
    timestamp: datetime = Field(default_factory=datetime.utcnow)


class Session(BaseModel):
    """A review analysis session."""

    session_id: str
    product_name: str = ""
    platform: str = ""
    summary: IngestionSummary = Field(default_factory=IngestionSummary)
    messages: list[ChatMessage] = Field(default_factory=list)
    status: str = "pending"  # pending, ready, error
    created_at: datetime = Field(default_factory=datetime.utcnow)

"""File-based session and message persistence."""

from __future__ import annotations

import json
import os
from pathlib import Path

from .models import ChatMessage, IngestionSummary, Session

DATA_DIR = Path(os.getenv("DATA_DIR", "data"))


def _session_dir(session_id: str) -> Path:
    d = DATA_DIR / session_id
    d.mkdir(parents=True, exist_ok=True)
    return d


# ── Session lifecycle ────────────────────────────────────────────────

def save_session(session: Session) -> None:
    path = _session_dir(session.session_id) / "session.json"
    path.write_text(session.model_dump_json(indent=2))


def load_session(session_id: str) -> Session | None:
    path = _session_dir(session_id) / "session.json"
    if not path.exists():
        return None
    return Session.model_validate_json(path.read_text())


def set_status(session_id: str, status: str) -> None:
    session = load_session(session_id)
    if session:
        session.status = status
        save_session(session)


def update_summary(session_id: str, summary: IngestionSummary) -> None:
    session = load_session(session_id)
    if session:
        session.summary = summary
        session.product_name = summary.product_name
        session.platform = summary.platform
        save_session(session)


# ── Chat messages ────────────────────────────────────────────────────

def append_message(session_id: str, message: ChatMessage) -> None:
    session = load_session(session_id)
    if session:
        session.messages.append(message)
        save_session(session)


def get_messages(session_id: str) -> list[ChatMessage]:
    session = load_session(session_id)
    return session.messages if session else []


# ── Reviews (raw JSON for reference) ────────────────────────────────

def save_reviews_json(session_id: str, reviews: list[dict]) -> None:
    path = _session_dir(session_id) / "reviews.json"
    path.write_text(json.dumps(reviews, default=str, indent=2))


def load_reviews_json(session_id: str) -> list[dict]:
    path = _session_dir(session_id) / "reviews.json"
    if not path.exists():
        return []
    return json.loads(path.read_text())

"""ChromaDB vector store for review embeddings."""

from __future__ import annotations

import hashlib
import os
from typing import Any

import chromadb
from chromadb.config import Settings

from .models import Review

# In-process persistent ChromaDB — no external server needed.
_client: chromadb.ClientAPI | None = None


def _get_client() -> chromadb.ClientAPI:
    global _client
    if _client is None:
        persist_dir = os.getenv("CHROMA_DIR", "data/chroma")
        _client = chromadb.PersistentClient(
            path=persist_dir,
            settings=Settings(anonymized_telemetry=False),
        )
    return _client


def _collection_name(session_id: str) -> str:
    """ChromaDB collection names must be 3-63 chars, alphanumeric + underscores."""
    h = hashlib.md5(session_id.encode()).hexdigest()[:12]
    return f"reviews_{h}"


def index_reviews(session_id: str, reviews: list[Review]) -> int:
    """Embed and store reviews. Returns count indexed."""
    client = _get_client()
    col = client.get_or_create_collection(
        name=_collection_name(session_id),
        metadata={"hnsw:space": "cosine"},
    )

    if not reviews:
        return 0

    ids = []
    documents = []
    metadatas = []

    for i, r in enumerate(reviews):
        if not r.text.strip():
            continue
        doc_id = r.id or f"review_{i}"
        ids.append(doc_id)
        documents.append(r.text)
        meta: dict[str, Any] = {}
        if r.rating is not None:
            meta["rating"] = float(r.rating)
        if r.date:
            meta["date"] = r.date.isoformat()
        if r.author:
            meta["author"] = r.author
        if r.platform:
            meta["platform"] = r.platform
        metadatas.append(meta)

    # ChromaDB has a batch limit — upsert in chunks of 500.
    batch_size = 500
    for start in range(0, len(ids), batch_size):
        end = start + batch_size
        col.upsert(
            ids=ids[start:end],
            documents=documents[start:end],
            metadatas=metadatas[start:end],
        )

    return len(ids)


def search_reviews(
    session_id: str,
    query: str,
    n_results: int = 10,
    where: dict | None = None,
) -> list[dict[str, Any]]:
    """Semantic search over indexed reviews. Returns list of result dicts."""
    client = _get_client()
    col_name = _collection_name(session_id)

    try:
        col = client.get_collection(col_name)
    except Exception:
        return []

    kwargs: dict[str, Any] = {
        "query_texts": [query],
        "n_results": min(n_results, col.count() or 1),
    }
    if where:
        kwargs["where"] = where

    results = col.query(**kwargs)

    out = []
    for i in range(len(results["ids"][0])):
        out.append(
            {
                "id": results["ids"][0][i],
                "text": results["documents"][0][i],
                "distance": results["distances"][0][i] if results.get("distances") else None,
                "metadata": results["metadatas"][0][i] if results.get("metadatas") else {},
            }
        )
    return out


def get_all_reviews(session_id: str) -> list[dict[str, Any]]:
    """Retrieve all reviews from the collection (for stats/analysis)."""
    client = _get_client()
    col_name = _collection_name(session_id)

    try:
        col = client.get_collection(col_name)
    except Exception:
        return []

    count = col.count()
    if count == 0:
        return []

    results = col.get(include=["documents", "metadatas"])

    out = []
    for i in range(len(results["ids"])):
        out.append(
            {
                "id": results["ids"][i],
                "text": results["documents"][i],
                "metadata": results["metadatas"][i] if results.get("metadatas") else {},
            }
        )
    return out


def get_review_count(session_id: str) -> int:
    client = _get_client()
    try:
        col = client.get_collection(_collection_name(session_id))
        return col.count()
    except Exception:
        return 0

"""Ingestion module: CSV parsing and Firecrawl URL scraping."""

from __future__ import annotations

import csv
import io
import os
import re
import uuid
from collections import Counter
from datetime import datetime
from typing import Any

import httpx

from .models import IngestionSummary, Review


# ── CSV Ingestion (primary path) ────────────────────────────────────

# Common column name variants we normalise to our schema.
_COL_MAP: dict[str, list[str]] = {
    "text": ["text", "review", "review_text", "content", "body", "comment", "review_body", "reviews", "feedback"],
    "rating": ["rating", "score", "stars", "star_rating", "review_rating", "overall_rating"],
    "date": ["date", "review_date", "created_at", "timestamp", "time", "posted_date", "review_time"],
    "author": ["author", "reviewer", "user", "username", "reviewer_name", "name", "user_name"],
    "platform": ["platform", "source", "site", "channel"],
}


def _normalise_col(name: str) -> str:
    return re.sub(r"[^a-z0-9]", "", name.lower().strip())


def _map_columns(headers: list[str]) -> dict[str, str]:
    """Map CSV column names → our field names. Returns {our_field: csv_col}."""
    mapping: dict[str, str] = {}
    normalised = {_normalise_col(h): h for h in headers}

    for field, aliases in _COL_MAP.items():
        for alias in aliases:
            norm = _normalise_col(alias)
            if norm in normalised:
                mapping[field] = normalised[norm]
                break
    return mapping


def _parse_date(val: str) -> datetime | None:
    for fmt in (
        "%Y-%m-%d",
        "%Y-%m-%dT%H:%M:%S",
        "%Y-%m-%dT%H:%M:%SZ",
        "%Y-%m-%d %H:%M:%S",
        "%m/%d/%Y",
        "%d/%m/%Y",
        "%B %d, %Y",
        "%b %d, %Y",
        "%Y/%m/%d",
    ):
        try:
            return datetime.strptime(val.strip(), fmt)
        except (ValueError, AttributeError):
            continue
    return None


def _parse_rating(val: str) -> float | None:
    try:
        # Handle "4/5", "4 out of 5", or plain "4.5"
        val = val.strip()
        match = re.match(r"([\d.]+)\s*(?:/|out of)\s*\d+", val)
        if match:
            return float(match.group(1))
        return float(val)
    except (ValueError, TypeError):
        return None


def parse_csv(content: str | bytes, platform: str = "", product_name: str = "") -> list[Review]:
    """Parse CSV content into Review objects. Handles flexible column names."""
    if isinstance(content, bytes):
        content = content.decode("utf-8-sig")  # Handle BOM

    reader = csv.DictReader(io.StringIO(content))
    if not reader.fieldnames:
        return []

    col_map = _map_columns(list(reader.fieldnames))

    if "text" not in col_map:
        # Try: if there's only one text-like long column, use it
        for h in reader.fieldnames:
            if h not in col_map.values():
                col_map["text"] = h
                break

    if "text" not in col_map:
        return []

    reviews: list[Review] = []
    for i, row in enumerate(reader):
        text = row.get(col_map.get("text", ""), "").strip()
        if not text:
            continue

        rating_raw = row.get(col_map.get("rating", ""), "")
        date_raw = row.get(col_map.get("date", ""), "")
        author = row.get(col_map.get("author", ""), "").strip()
        plat = row.get(col_map.get("platform", ""), "").strip() or platform

        # Collect unmapped columns as metadata
        mapped_cols = set(col_map.values())
        metadata = {k: v for k, v in row.items() if k not in mapped_cols and v}

        reviews.append(
            Review(
                id=f"review_{i}",
                text=text,
                rating=_parse_rating(rating_raw),
                date=_parse_date(date_raw),
                author=author,
                platform=plat,
                metadata=metadata,
            )
        )

    return reviews


# ── Firecrawl URL Scraping (secondary, best-effort) ─────────────────

FIRECRAWL_API_KEY = os.getenv("FIRECRAWL_API_KEY", "")
FIRECRAWL_API_URL = "https://api.firecrawl.dev/v1"


async def scrape_url(url: str, platform: str = "") -> list[Review]:
    """Best-effort URL scraping via Firecrawl. Returns whatever we can get."""
    if not FIRECRAWL_API_KEY:
        raise ValueError("FIRECRAWL_API_KEY not set. Use CSV upload instead.")

    async with httpx.AsyncClient(timeout=60.0) as client:
        resp = await client.post(
            f"{FIRECRAWL_API_URL}/scrape",
            headers={
                "Authorization": f"Bearer {FIRECRAWL_API_KEY}",
                "Content-Type": "application/json",
            },
            json={
                "url": url,
                "formats": ["markdown"],
            },
        )
        resp.raise_for_status()
        data = resp.json()

    markdown = data.get("data", {}).get("markdown", "")
    if not markdown:
        return []

    # Try to extract individual reviews from the markdown.
    # This is best-effort — review platforms have varied structures.
    reviews = _extract_reviews_from_markdown(markdown, platform, url)
    return reviews


def _extract_reviews_from_markdown(
    markdown: str, platform: str, url: str
) -> list[Review]:
    """Attempt to parse review blocks from scraped markdown."""
    reviews: list[Review] = []

    # Strategy: split on patterns that look like review boundaries.
    # Common patterns: "★★★★☆", "Rating: X/5", numbered reviews, horizontal rules
    blocks = re.split(r"\n(?:---+|\*\*\*+|#{1,3}\s)", markdown)

    for i, block in enumerate(blocks):
        block = block.strip()
        if len(block) < 20:
            continue

        # Try to extract rating
        rating = None
        star_match = re.search(r"([★]{1,5})", block)
        if star_match:
            rating = float(len(star_match.group(1)))
        else:
            rating_match = re.search(r"(\d(?:\.\d)?)\s*(?:/\s*5|out of 5|stars?)", block, re.I)
            if rating_match:
                rating = float(rating_match.group(1))

        # Try to extract date
        date = None
        date_match = re.search(
            r"(\w+ \d{1,2},? \d{4}|\d{4}-\d{2}-\d{2}|\d{1,2}/\d{1,2}/\d{4})",
            block,
        )
        if date_match:
            date = _parse_date(date_match.group(1))

        reviews.append(
            Review(
                id=f"scraped_{i}",
                text=block[:2000],  # Cap individual review length
                rating=rating,
                date=date,
                platform=platform or _guess_platform(url),
                metadata={"source_url": url},
            )
        )

    return reviews


def _guess_platform(url: str) -> str:
    url_lower = url.lower()
    if "amazon" in url_lower:
        return "Amazon"
    if "google" in url_lower and "maps" in url_lower:
        return "Google Maps"
    if "g2" in url_lower:
        return "G2"
    if "capterra" in url_lower:
        return "Capterra"
    if "yelp" in url_lower:
        return "Yelp"
    if "trustpilot" in url_lower:
        return "Trustpilot"
    return "Web"


# ── Summary builder ──────────────────────────────────────────────────

def build_summary(
    reviews: list[Review],
    source_type: str,
    product_name: str = "",
    platform: str = "",
) -> IngestionSummary:
    """Build an ingestion summary from parsed reviews."""
    if not reviews:
        return IngestionSummary(source_type=source_type)

    ratings = [r.rating for r in reviews if r.rating is not None]
    dates = [r.date for r in reviews if r.date is not None]

    # Rating distribution (bucket by integer star)
    dist: dict[str, int] = {}
    for r in ratings:
        bucket = str(int(round(r)))
        dist[bucket] = dist.get(bucket, 0) + 1

    # Date range
    date_range = ""
    if dates:
        earliest = min(dates).strftime("%Y-%m-%d")
        latest = max(dates).strftime("%Y-%m-%d")
        date_range = f"{earliest} to {latest}" if earliest != latest else earliest

    # Platform detection
    platforms = [r.platform for r in reviews if r.platform]
    detected_platform = platform or (Counter(platforms).most_common(1)[0][0] if platforms else "Unknown")

    return IngestionSummary(
        total_reviews=len(reviews),
        date_range=date_range,
        rating_distribution=dist,
        average_rating=round(sum(ratings) / len(ratings), 2) if ratings else None,
        platform=detected_platform,
        product_name=product_name or "Unknown Product",
        source_type=source_type,
    )

"""System prompt builder for the ReviewLens agent."""

from __future__ import annotations

from .models import IngestionSummary


def build_system_prompt(summary: IngestionSummary) -> str:
    """Build the scope-guarded system prompt for the conversational agent."""

    rating_info = ""
    if summary.rating_distribution:
        dist_lines = [f"  {k}★: {v} reviews" for k, v in sorted(summary.rating_distribution.items())]
        rating_info = "\n".join(dist_lines)

    return f"""You are ReviewLens AI, a review intelligence analyst. You help users analyse customer reviews that have been ingested into your system.

## Dataset Context

- Product/Entity: {summary.product_name}
- Platform: {summary.platform}
- Total Reviews: {summary.total_reviews}
- Date Range: {summary.date_range or "Unknown"}
- Average Rating: {summary.average_rating or "Unknown"}
- Rating Distribution:
{rating_info or "  Not available"}

## CRITICAL: Scope Guard — Your #1 Rule

You MUST ONLY answer questions about the ingested review dataset described above. This is non-negotiable.

**You MUST refuse if the user asks about:**
- Reviews from other platforms (e.g., if data is from Amazon, refuse questions about Google Maps reviews)
- Competitor products or brands not mentioned in the reviews
- General knowledge, news, current events, or facts not in the dataset
- Predictions, forecasts, or speculation beyond what the data shows
- Anything requiring information you don't have from the reviews

**How to refuse:**
- Be friendly but firm: "I can only analyse the {summary.total_reviews} {summary.platform} reviews for {summary.product_name} that were uploaded. I don't have access to [what they asked about]. Would you like to explore something in this dataset instead?"
- Always suggest a relevant alternative question about the actual data.

**Before answering ANY question, verify:**
1. Can this be answered using ONLY the ingested reviews?
2. If you used the search_reviews tool, did it return relevant results?
3. Are you about to state something that comes from your general knowledge rather than the data? If so, STOP.

If your search returns no relevant results, say so honestly. Never fill gaps with general knowledge.

## Your Tools

You have access to these tools — use them to give data-grounded answers:

- **search_reviews**: Semantic search over the review database. Use this to find reviews relevant to the user's question. Always search before answering.
- **analyze_sentiment**: Extract aspects and sentiment from a set of reviews. Use for sentiment breakdowns, aspect analysis, and opinion mining.
- **generate_chart**: Create a Chart.js chart that renders inline in the chat. Use when a visual would communicate the answer better than text. Keep charts clean and focused.
- **calculate_stats**: Run aggregations, distributions, and trend analysis on the review data. Use for quantitative questions.
- **suggest_follow_ups**: Generate contextual follow-up question buttons based on what was just discussed. Call this at the end of EVERY response.

## Response Guidelines

1. **Always search first.** Before answering any question about the reviews, call search_reviews to ground your response in actual data.
2. **Cite specific reviews.** Quote or paraphrase actual review text to support your claims. Use phrases like "One reviewer noted..." or "Several reviews mention..."
3. **Use charts strategically.** A chart adds value for distributions, trends over time, and comparisons. Don't chart everything — use them when visual communication is genuinely better.
4. **Be quantitative.** When you can give numbers (counts, percentages, averages), do so. Use calculate_stats for aggregations.
5. **Always suggest follow-ups.** End every response by calling suggest_follow_ups to give the user contextual next steps.
6. **Be concise.** Users are analysts who want insights, not essays. Lead with the finding, support with data, suggest next steps.
"""

"""MCP tools for the ReviewLens agent, using create_sdk_mcp_server."""

from __future__ import annotations

import json
from collections import Counter
from typing import Any, Callable, Awaitable

from claude_agent_sdk import create_sdk_mcp_server, tool

from . import vectordb

# Type alias for the SSE emit callback
EmitFn = Callable[[str, str, str], Awaitable[None]]


def create_review_tools_server(
    session_id: str,
    emit_fn: EmitFn,
):
    """Create the MCP server with all review analysis tools.

    Like briefbot, uses closure over session_id so tools access the right data.
    """

    # ── search_reviews ───────────────────────────────────────────────

    @tool(
        name="search_reviews",
        description="Semantic search over the ingested review database. Use this to find reviews relevant to the user's question. Returns the most relevant reviews ranked by similarity.",
        schema={
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query — describe what you're looking for in natural language.",
                },
                "n_results": {
                    "type": "integer",
                    "description": "Number of results to return (default 10, max 25).",
                    "default": 10,
                },
                "min_rating": {
                    "type": "number",
                    "description": "Optional: only return reviews with rating >= this value.",
                },
                "max_rating": {
                    "type": "number",
                    "description": "Optional: only return reviews with rating <= this value.",
                },
            },
            "required": ["query"],
        },
    )
    async def search_reviews_tool(args: dict[str, Any]) -> dict[str, Any]:
        query = args["query"]
        n = min(args.get("n_results", 10), 25)

        where = None
        if "min_rating" in args and "max_rating" in args:
            where = {
                "$and": [
                    {"rating": {"$gte": args["min_rating"]}},
                    {"rating": {"$lte": args["max_rating"]}},
                ]
            }
        elif "min_rating" in args:
            where = {"rating": {"$gte": args["min_rating"]}}
        elif "max_rating" in args:
            where = {"rating": {"$lte": args["max_rating"]}}

        results = vectordb.search_reviews(session_id, query, n_results=n, where=where)

        await emit_fn(
            session_id,
            f"Searched reviews: \"{query}\" — {len(results)} results",
            "tool",
        )

        return {
            "content": [
                {
                    "type": "text",
                    "text": json.dumps(
                        {
                            "query": query,
                            "result_count": len(results),
                            "results": results,
                            "note": "If no results are relevant, tell the user you couldn't find matching reviews. Do NOT make up information.",
                        }
                    ),
                }
            ]
        }

    # ── analyze_sentiment ────────────────────────────────────────────

    @tool(
        name="analyze_sentiment",
        description="Analyse sentiment and extract aspects from reviews matching a query. Returns aspect-sentiment pairs and overall sentiment distribution. Use for questions about what people like/dislike, pain points, praise, etc.",
        schema={
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Search query to find relevant reviews for analysis.",
                },
                "n_reviews": {
                    "type": "integer",
                    "description": "Number of reviews to analyse (default 15, max 30).",
                    "default": 15,
                },
            },
            "required": ["query"],
        },
    )
    async def analyze_sentiment_tool(args: dict[str, Any]) -> dict[str, Any]:
        query = args["query"]
        n = min(args.get("n_reviews", 15), 30)

        results = vectordb.search_reviews(session_id, query, n_results=n)

        if not results:
            return {
                "content": [
                    {
                        "type": "text",
                        "text": json.dumps({"error": "No reviews found matching query.", "results": []}),
                    }
                ]
            }

        # Provide the raw reviews to the LLM — it does the actual sentiment analysis.
        # This is more flexible and accurate than a rule-based approach.
        await emit_fn(
            session_id,
            f"Analysing sentiment: \"{query}\" — {len(results)} reviews",
            "tool",
        )

        return {
            "content": [
                {
                    "type": "text",
                    "text": json.dumps(
                        {
                            "query": query,
                            "review_count": len(results),
                            "reviews": results,
                            "instruction": (
                                "Analyse these reviews for sentiment and aspects. "
                                "For each review, identify: (1) key aspects mentioned "
                                "(e.g., 'battery life', 'customer service', 'price'), "
                                "(2) sentiment per aspect (positive/negative/neutral/mixed), "
                                "(3) overall sentiment. Then summarise the patterns across all reviews. "
                                "Only report what the reviews actually say."
                            ),
                        }
                    ),
                }
            ]
        }

    # ── generate_chart ───────────────────────────────────────────────

    @tool(
        name="generate_chart",
        description="Generate a Chart.js chart configuration that renders inline in the chat. Use for visualising rating distributions, sentiment breakdowns, trends over time, aspect comparisons, etc. The chart renders automatically — just return valid config.",
        schema={
            "type": "object",
            "properties": {
                "chart_type": {
                    "type": "string",
                    "enum": ["bar", "line", "pie", "doughnut"],
                    "description": "The type of chart to generate.",
                },
                "title": {
                    "type": "string",
                    "description": "Chart title displayed above the visualisation.",
                },
                "labels": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "X-axis labels (categories, dates, etc.).",
                },
                "datasets": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "label": {"type": "string"},
                            "data": {
                                "type": "array",
                                "items": {"type": "number"},
                            },
                        },
                        "required": ["label", "data"],
                    },
                    "description": "One or more data series.",
                },
            },
            "required": ["chart_type", "title", "labels", "datasets"],
        },
    )
    async def generate_chart_tool(args: dict[str, Any]) -> dict[str, Any]:
        chart_config = {
            "type": args["chart_type"],
            "title": args["title"],
            "data": {
                "labels": args["labels"],
                "datasets": args["datasets"],
            },
        }

        await emit_fn(
            session_id,
            f"Generated chart: {args['title']}",
            "tool",
        )

        return {
            "content": [
                {
                    "type": "text",
                    "text": json.dumps(
                        {
                            "chart": chart_config,
                            "instruction": "This chart will render automatically in the chat. Reference it in your text response.",
                        }
                    ),
                }
            ]
        }

    # ── calculate_stats ──────────────────────────────────────────────

    @tool(
        name="calculate_stats",
        description="Calculate aggregate statistics over the full review dataset. Use for quantitative questions: average ratings, distributions, counts by category, trends over time periods, etc.",
        schema={
            "type": "object",
            "properties": {
                "operation": {
                    "type": "string",
                    "enum": [
                        "rating_distribution",
                        "rating_over_time",
                        "review_volume_over_time",
                        "keyword_frequency",
                        "summary_stats",
                    ],
                    "description": "The type of statistical analysis to run.",
                },
                "keyword": {
                    "type": "string",
                    "description": "For keyword_frequency: the keyword or phrase to count.",
                },
            },
            "required": ["operation"],
        },
    )
    async def calculate_stats_tool(args: dict[str, Any]) -> dict[str, Any]:
        operation = args["operation"]
        all_reviews = vectordb.get_all_reviews(session_id)

        if not all_reviews:
            return {
                "content": [
                    {
                        "type": "text",
                        "text": json.dumps({"error": "No reviews in database."}),
                    }
                ]
            }

        result: dict[str, Any] = {"operation": operation}

        if operation == "rating_distribution":
            ratings = [r["metadata"].get("rating") for r in all_reviews if r["metadata"].get("rating") is not None]
            dist = Counter(int(round(r)) for r in ratings)
            result["distribution"] = {str(k): v for k, v in sorted(dist.items())}
            result["total_with_ratings"] = len(ratings)
            result["total_reviews"] = len(all_reviews)
            if ratings:
                result["average"] = round(sum(ratings) / len(ratings), 2)

        elif operation == "rating_over_time":
            by_month: dict[str, list[float]] = {}
            for r in all_reviews:
                date_str = r["metadata"].get("date", "")
                rating = r["metadata"].get("rating")
                if date_str and rating is not None:
                    month = date_str[:7]  # YYYY-MM
                    by_month.setdefault(month, []).append(rating)
            result["monthly_averages"] = {
                m: round(sum(v) / len(v), 2)
                for m, v in sorted(by_month.items())
            }

        elif operation == "review_volume_over_time":
            by_month: dict[str, int] = {}
            for r in all_reviews:
                date_str = r["metadata"].get("date", "")
                if date_str:
                    month = date_str[:7]
                    by_month[month] = by_month.get(month, 0) + 1
            result["monthly_volume"] = dict(sorted(by_month.items()))

        elif operation == "keyword_frequency":
            keyword = args.get("keyword", "").lower()
            if not keyword:
                return {
                    "content": [
                        {
                            "type": "text",
                            "text": json.dumps({"error": "keyword parameter required"}),
                        }
                    ]
                }
            count = sum(1 for r in all_reviews if keyword in r["text"].lower())
            result["keyword"] = keyword
            result["count"] = count
            result["percentage"] = round(count / len(all_reviews) * 100, 1)

        elif operation == "summary_stats":
            ratings = [r["metadata"].get("rating") for r in all_reviews if r["metadata"].get("rating") is not None]
            result["total_reviews"] = len(all_reviews)
            result["total_with_ratings"] = len(ratings)
            if ratings:
                result["average_rating"] = round(sum(ratings) / len(ratings), 2)
                result["min_rating"] = min(ratings)
                result["max_rating"] = max(ratings)
            dates = [r["metadata"].get("date", "") for r in all_reviews if r["metadata"].get("date")]
            if dates:
                result["earliest_review"] = min(dates)
                result["latest_review"] = max(dates)
            avg_length = sum(len(r["text"]) for r in all_reviews) / len(all_reviews)
            result["average_review_length"] = round(avg_length)

        await emit_fn(
            session_id,
            f"Calculated stats: {operation}",
            "tool",
        )

        return {
            "content": [
                {
                    "type": "text",
                    "text": json.dumps(result),
                }
            ]
        }

    # ── suggest_follow_ups ───────────────────────────────────────────

    @tool(
        name="suggest_follow_ups",
        description="Generate contextual follow-up question buttons based on the current conversation. Call this at the END of every response. The questions should be specific to what was just discussed and lead the user deeper into the data.",
        schema={
            "type": "object",
            "properties": {
                "questions": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "3-4 contextual follow-up questions. Make them specific and actionable.",
                    "minItems": 2,
                    "maxItems": 4,
                },
            },
            "required": ["questions"],
        },
    )
    async def suggest_follow_ups_tool(args: dict[str, Any]) -> dict[str, Any]:
        questions = args["questions"]

        await emit_fn(
            session_id,
            f"Suggested {len(questions)} follow-up questions",
            "tool",
        )

        return {
            "content": [
                {
                    "type": "text",
                    "text": json.dumps(
                        {
                            "follow_ups": questions,
                            "instruction": "These will appear as clickable buttons below your message. Do not repeat them in your text response.",
                        }
                    ),
                }
            ]
        }

    # ── Build and return the MCP server ──────────────────────────────

    return create_sdk_mcp_server(
        name="reviewlens",
        version="1.0.0",
        tools=[
            search_reviews_tool,
            analyze_sentiment_tool,
            generate_chart_tool,
            calculate_stats_tool,
            suggest_follow_ups_tool,
        ],
    )

"""Conversational agent loop — invoked per-message, not per-session."""

from __future__ import annotations

import json
import os
from typing import Any

from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ClaudeSDKClient,
    HookMatcher,
    ResultMessage,
    TextBlock,
)

from .models import ChatMessage, IngestionSummary
from .prompts import build_system_prompt
from .tools import create_review_tools_server

DEFAULT_MODEL = os.getenv("CLAUDE_MODEL", "claude-sonnet-4-6-20250514")


async def handle_message(
    session_id: str,
    user_message: str,
    conversation_history: list[ChatMessage],
    summary: IngestionSummary,
    emit_fn,
) -> ChatMessage:
    """Run the agent for a single user message. Returns the assistant's response."""

    system_prompt = build_system_prompt(summary)

    # Build conversation context for the agent
    messages_for_context = []
    for msg in conversation_history[-20:]:  # Last 20 messages for context window
        messages_for_context.append(f"{'User' if msg.role == 'user' else 'Assistant'}: {msg.content}")

    prompt_parts = []
    if messages_for_context:
        prompt_parts.append("Previous conversation:\n" + "\n".join(messages_for_context))
    prompt_parts.append(f"User: {user_message}")
    prompt = "\n\n".join(prompt_parts)

    # Create per-request MCP server (closure over session_id)
    server = create_review_tools_server(
        session_id=session_id,
        emit_fn=emit_fn,
    )

    # Track tool outputs for charts and follow-ups
    charts: list[dict[str, Any]] = []
    follow_ups: list[str] = []

    async def post_tool_hook(input_data, tool_use_id, context):
        """Intercept tool results to extract charts and follow-ups."""
        # The tool result is in context
        try:
            result = context.get("result", {})
            content = result.get("content", [])
            for block in content:
                if block.get("type") == "text":
                    data = json.loads(block["text"])
                    if "chart" in data:
                        charts.append(data["chart"])
                    if "follow_ups" in data:
                        follow_ups.extend(data["follow_ups"])
        except (json.JSONDecodeError, KeyError, TypeError):
            pass
        return {}

    options = ClaudeAgentOptions(
        system_prompt=system_prompt,
        allowed_tools=["mcp__reviewlens__*"],
        permission_mode="bypassPermissions",
        max_turns=15,
        model=DEFAULT_MODEL,
        mcp_servers={"reviewlens": server},
        hooks={
            "PostToolUse": [HookMatcher(matcher=".*", hooks=[post_tool_hook])],
        },
    )

    response_text = ""

    try:
        async with ClaudeSDKClient(options=options) as client:
            await client.query(prompt)
            async for message in client.receive_response():
                if isinstance(message, AssistantMessage):
                    for block in message.content:
                        if isinstance(block, TextBlock) and block.text.strip():
                            response_text += block.text.strip() + "\n"
                elif isinstance(message, ResultMessage):
                    if message.result and not response_text.strip():
                        response_text = message.result

    except Exception as e:
        response_text = f"I encountered an error processing your question. Please try again.\n\nError: {str(e)}"
        await emit_fn(session_id, f"Agent error: {e}", "error")

    return ChatMessage(
        role="assistant",
        content=response_text.strip(),
        charts=charts,
        follow_ups=follow_ups,
    )

"""FastAPI application for ReviewLens AI."""

from __future__ import annotations

import asyncio
import html as html_module
import json
import os
import uuid
from collections import deque
from datetime import datetime
from pathlib import Path
from typing import Any

import markdown
from dotenv import load_dotenv
from fastapi import FastAPI, File, Form, Request, UploadFile
from fastapi.responses import HTMLResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from sse_starlette.sse import EventSourceResponse

from . import store, vectordb
from .agent import handle_message
from .ingest import build_summary, parse_csv, scrape_url
from .models import ChatMessage, IngestionSummary, Session

load_dotenv()

BASE_DIR = Path(__file__).resolve().parent.parent
app = FastAPI(title="ReviewLens AI")
app.mount("/static", StaticFiles(directory=str(BASE_DIR / "static")), name="static")
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))

# ── In-memory SSE event queues (per-session) ────────────────────────
# For streaming agent activity and chat responses to the frontend.
_event_queues: dict[str, deque[dict[str, str]]] = {}
_response_events: dict[str, asyncio.Event] = {}


def _get_queue(session_id: str) -> deque[dict[str, str]]:
    if session_id not in _event_queues:
        _event_queues[session_id] = deque()
    return _event_queues[session_id]


def _get_response_event(session_id: str) -> asyncio.Event:
    if session_id not in _response_events:
        _response_events[session_id] = asyncio.Event()
    return _response_events[session_id]


async def _emit(session_id: str, message: str, level: str = "info") -> None:
    """Push an SSE event to the session's queue."""
    _get_queue(session_id).append({"event": level, "data": message})


# ── Health check ─────────────────────────────────────────────────────

@app.get("/health")
async def health():
    return {"status": "ok"}


# ── Landing page ─────────────────────────────────────────────────────

@app.get("/", response_class=HTMLResponse)
async def index(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})


# ── CSV Upload ───────────────────────────────────────────────────────

@app.post("/upload")
async def upload_csv(
    request: Request,
    file: UploadFile = File(...),
    product_name: str = Form(""),
    platform: str = Form(""),
):
    session_id = str(uuid.uuid4())

    # Read and parse CSV
    content = await file.read()
    try:
        reviews = parse_csv(content, platform=platform, product_name=product_name)
    except Exception as e:
        return templates.TemplateResponse(
            "partials/error.html",
            {"request": request, "error": f"Failed to parse CSV: {e}"},
            status_code=400,
        )

    if not reviews:
        return templates.TemplateResponse(
            "partials/error.html",
            {"request": request, "error": "No reviews found in the CSV. Make sure it has a text/review column."},
            status_code=400,
        )

    # Build summary
    summary = build_summary(reviews, source_type="csv", product_name=product_name, platform=platform)

    # Create session
    session = Session(
        session_id=session_id,
        product_name=summary.product_name,
        platform=summary.platform,
        summary=summary,
        status="indexing",
    )
    store.save_session(session)

    # Save raw reviews
    store.save_reviews_json(session_id, [r.model_dump(mode="json") for r in reviews])

    # Index into ChromaDB
    indexed = vectordb.index_reviews(session_id, reviews)
    summary.total_reviews = indexed
    store.update_summary(session_id, summary)
    store.set_status(session_id, "ready")

    # Redirect to chat
    return HTMLResponse(
        status_code=200,
        content=f'<script>window.location.href="/chat/{session_id}";</script>',
        headers={"HX-Redirect": f"/chat/{session_id}"},
    )


# ── URL Scrape ───────────────────────────────────────────────────────

@app.post("/scrape")
async def scrape(
    request: Request,
    url: str = Form(...),
    product_name: str = Form(""),
    platform: str = Form(""),
):
    session_id = str(uuid.uuid4())

    try:
        reviews = await scrape_url(url, platform=platform)
    except Exception as e:
        return templates.TemplateResponse(
            "partials/error.html",
            {"request": request, "error": f"Scraping failed: {e}. Try uploading a CSV instead."},
            status_code=400,
        )

    if not reviews:
        return templates.TemplateResponse(
            "partials/error.html",
            {"request": request, "error": "No reviews could be extracted from that URL. Try uploading a CSV instead."},
            status_code=400,
        )

    summary = build_summary(reviews, source_type="url", product_name=product_name, platform=platform)

    session = Session(
        session_id=session_id,
        product_name=summary.product_name,
        platform=summary.platform,
        summary=summary,
        status="indexing",
    )
    store.save_session(session)
    store.save_reviews_json(session_id, [r.model_dump(mode="json") for r in reviews])

    indexed = vectordb.index_reviews(session_id, reviews)
    summary.total_reviews = indexed
    store.update_summary(session_id, summary)
    store.set_status(session_id, "ready")

    return HTMLResponse(
        status_code=200,
        content=f'<script>window.location.href="/chat/{session_id}";</script>',
        headers={"HX-Redirect": f"/chat/{session_id}"},
    )


# ── Chat page ────────────────────────────────────────────────────────

@app.get("/chat/{session_id}", response_class=HTMLResponse)
async def chat_page(request: Request, session_id: str):
    session = store.load_session(session_id)
    if not session:
        return HTMLResponse("<h1>Session not found</h1>", status_code=404)

    return templates.TemplateResponse(
        "chat.html",
        {
            "request": request,
            "session": session,
            "summary": session.summary,
            "messages": session.messages,
        },
    )


# ── Send chat message ───────────────────────────────────────────────

@app.post("/chat/{session_id}/send")
async def send_message(
    request: Request,
    session_id: str,
    message: str = Form(...),
):
    session = store.load_session(session_id)
    if not session:
        return JSONResponse({"error": "Session not found"}, status_code=404)

    # Save user message
    user_msg = ChatMessage(role="user", content=message)
    store.append_message(session_id, user_msg)

    # Signal that we're processing
    event = _get_response_event(session_id)
    event.clear()

    # Render user message HTML immediately
    user_html = _render_message(user_msg)

    # Spawn agent task in background
    asyncio.create_task(_run_agent_and_respond(session_id, message, session))

    # Return user message + thinking indicator
    thinking_html = (
        '<div id="thinking-indicator" class="message assistant-message thinking">'
        '<div class="message-content">'
        '<div class="thinking-dots"><span></span><span></span><span></span></div>'
        '</div></div>'
    )
    return HTMLResponse(user_html + thinking_html)


async def _run_agent_and_respond(session_id: str, message: str, session: Session):
    """Run agent in background and push response via SSE."""
    try:
        history = store.get_messages(session_id)

        assistant_msg = await handle_message(
            session_id=session_id,
            user_message=message,
            conversation_history=history[:-1],  # Exclude the message we just added
            summary=session.summary,
            emit_fn=_emit,
        )

        store.append_message(session_id, assistant_msg)

        # Push the rendered response via SSE
        html = _render_message(assistant_msg)
        _get_queue(session_id).append({"event": "message", "data": html})

    except Exception as e:
        error_msg = ChatMessage(
            role="assistant",
            content=f"Sorry, I encountered an error: {e}",
        )
        store.append_message(session_id, error_msg)
        html = _render_message(error_msg)
        _get_queue(session_id).append({"event": "message", "data": html})

    # Signal done
    _get_response_event(session_id).set()


# ── SSE stream ───────────────────────────────────────────────────────

@app.get("/chat/{session_id}/stream")
async def chat_stream(session_id: str):
    """SSE endpoint for streaming agent activity and responses."""

    async def event_generator():
        queue = _get_queue(session_id)
        event = _get_response_event(session_id)

        while True:
            # Drain queued events
            while queue:
                item = queue.popleft()
                yield {"event": item["event"], "data": item["data"]}

                # If this was a message event, we're done with this request
                if item["event"] == "message":
                    yield {"event": "done", "data": ""}
                    return

            # Check if we should stop
            if event.is_set() and not queue:
                yield {"event": "done", "data": ""}
                return

            await asyncio.sleep(0.15)

    return EventSourceResponse(event_generator())


# ── Ingestion summary endpoint ───────────────────────────────────────

@app.get("/api/summary/{session_id}", response_class=HTMLResponse)
async def get_summary(request: Request, session_id: str):
    session = store.load_session(session_id)
    if not session:
        return HTMLResponse("Session not found", status_code=404)

    return templates.TemplateResponse(
        "partials/summary.html",
        {"request": request, "summary": session.summary},
    )


# ── HTML rendering helpers ───────────────────────────────────────────

def _render_message(msg: ChatMessage) -> str:
    """Render a ChatMessage as HTML for the chat interface."""
    role_class = "user-message" if msg.role == "user" else "assistant-message"
    escaped = html_module.escape(msg.content)

    if msg.role == "assistant":
        # Convert markdown to HTML for assistant messages
        content_html = markdown.markdown(
            msg.content,
            extensions=["tables", "fenced_code"],
        )
    else:
        content_html = f"<p>{escaped}</p>"

    parts = [f'<div class="message {role_class}">']
    parts.append(f'<div class="message-content">{content_html}</div>')

    # Render charts
    for i, chart in enumerate(msg.charts):
        chart_id = f"chart-{uuid.uuid4().hex[:8]}"
        parts.append(
            f'<div class="chart-container">'
            f'<canvas id="{chart_id}"></canvas>'
            f'<script>renderChart("{chart_id}", {json.dumps(chart)});</script>'
            f'</div>'
        )

    # Render follow-up buttons
    if msg.follow_ups:
        parts.append('<div class="follow-ups">')
        for q in msg.follow_ups:
            escaped_q = html_module.escape(q)
            parts.append(
                f'<button class="follow-up-btn" onclick="sendFollowUp(this)" '
                f'data-question="{escaped_q}">{escaped_q}</button>'
            )
        parts.append('</div>')

    parts.append('</div>')
    return "\n".join(parts)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ReviewLens AI</title>
    <link rel="stylesheet" href="/static/style.css">
    <script src="https://unpkg.com/htmx.org@2.0.4"></script>
</head>
<body>
    <div class="landing">
        <header class="landing-header">
            <h1>ReviewLens <span class="accent">AI</span></h1>
            <p class="tagline">Upload customer reviews. Ask questions. Get insights.</p>
        </header>

        <main class="upload-section">
            <!-- CSV Upload (primary) -->
            <div class="upload-card primary">
                <h2>Upload Reviews</h2>
                <p class="upload-desc">Upload a CSV file with review data. We'll detect columns automatically.</p>

                <form id="csv-form"
                      hx-post="/upload"
                      hx-encoding="multipart/form-data"
                      hx-target="#upload-result"
                      hx-indicator="#upload-spinner">

                    <div class="form-group">
                        <label for="product_name">Product / Entity Name</label>
                        <input type="text" id="product_name" name="product_name"
                               placeholder="e.g., AcmeCo Widget Pro" required>
                    </div>

                    <div class="form-group">
                        <label for="platform">Platform</label>
                        <select id="platform" name="platform">
                            <option value="">Auto-detect</option>
                            <option value="Amazon">Amazon</option>
                            <option value="Google Maps">Google Maps</option>
                            <option value="G2">G2</option>
                            <option value="Capterra">Capterra</option>
                            <option value="Trustpilot">Trustpilot</option>
                            <option value="Yelp">Yelp</option>
                            <option value="App Store">App Store</option>
                            <option value="Other">Other</option>
                        </select>
                    </div>

                    <div class="file-drop" id="file-drop">
                        <input type="file" id="file" name="file" accept=".csv" required>
                        <div class="file-drop-content">
                            <div class="file-icon">&#128196;</div>
                            <p>Drop a CSV file here or <span class="browse-link">browse</span></p>
                            <p class="file-hint">Expects columns like: text/review, rating, date, author</p>
                        </div>
                        <div class="file-selected" style="display:none">
                            <span class="file-name"></span>
                            <button type="button" class="file-clear" onclick="clearFile()">&#10005;</button>
                        </div>
                    </div>

                    <button type="submit" class="btn btn-primary" id="upload-btn">
                        <span class="btn-text">Analyse Reviews</span>
                        <span class="btn-spinner" id="upload-spinner" style="display:none">
                            <span class="spinner"></span> Processing...
                        </span>
                    </button>
                </form>

                <div id="upload-result"></div>
            </div>

            <!-- URL Scrape (secondary) -->
            <div class="upload-card secondary">
                <h2>Scrape from URL <span class="badge">Best-effort</span></h2>
                <p class="upload-desc">Paste a review page URL. Works best with static pages — anti-bot measures may block some platforms.</p>

                <form id="scrape-form"
                      hx-post="/scrape"
                      hx-target="#scrape-result"
                      hx-indicator="#scrape-spinner">

                    <div class="form-group">
                        <label for="scrape-product">Product / Entity Name</label>
                        <input type="text" id="scrape-product" name="product_name"
                               placeholder="e.g., AcmeCo Widget Pro">
                    </div>

                    <div class="form-group">
                        <label for="scrape-platform">Platform</label>
                        <select id="scrape-platform" name="platform">
                            <option value="">Auto-detect</option>
                            <option value="Amazon">Amazon</option>
                            <option value="Google Maps">Google Maps</option>
                            <option value="G2">G2</option>
                            <option value="Capterra">Capterra</option>
                            <option value="Trustpilot">Trustpilot</option>
                            <option value="Yelp">Yelp</option>
                        </select>
                    </div>

                    <div class="form-group">
                        <label for="url">Review Page URL</label>
                        <input type="url" id="url" name="url"
                               placeholder="https://..." required>
                    </div>

                    <button type="submit" class="btn btn-secondary">
                        <span class="btn-text">Scrape &amp; Analyse</span>
                        <span class="btn-spinner" id="scrape-spinner" style="display:none">
                            <span class="spinner"></span> Scraping...
                        </span>
                    </button>
                </form>

                <div id="scrape-result"></div>
            </div>
        </main>

        <footer class="landing-footer">
            <p>ReviewLens AI analyses only the reviews you provide. No external data. No hallucination.</p>
        </footer>
    </div>

    <script src="/static/app.js"></script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ReviewLens AI — {{ summary.product_name }}</title>
    <link rel="stylesheet" href="/static/style.css">
    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js"></script>
    <script src="https://unpkg.com/htmx.org@2.0.4"></script>
</head>
<body>
    <div class="chat-layout">
        <!-- Sidebar: Ingestion Summary -->
        <aside class="sidebar">
            <div class="sidebar-header">
                <a href="/" class="logo-link">
                    <h1 class="logo">ReviewLens <span class="accent">AI</span></h1>
                </a>
            </div>

            <div class="summary-card">
                <h3>{{ summary.product_name }}</h3>
                <div class="summary-meta">
                    <div class="meta-item">
                        <span class="meta-label">Platform</span>
                        <span class="meta-value">{{ summary.platform }}</span>
                    </div>
                    <div class="meta-item">
                        <span class="meta-label">Reviews</span>
                        <span class="meta-value">{{ summary.total_reviews }}</span>
                    </div>
                    {% if summary.average_rating %}
                    <div class="meta-item">
                        <span class="meta-label">Avg Rating</span>
                        <span class="meta-value">{{ "%.1f"|format(summary.average_rating) }} &#9733;</span>
                    </div>
                    {% endif %}
                    {% if summary.date_range %}
                    <div class="meta-item">
                        <span class="meta-label">Date Range</span>
                        <span class="meta-value">{{ summary.date_range }}</span>
                    </div>
                    {% endif %}
                    <div class="meta-item">
                        <span class="meta-label">Source</span>
                        <span class="meta-value">{{ summary.source_type | upper }}</span>
                    </div>
                </div>

                {% if summary.rating_distribution %}
                <div class="rating-dist">
                    <h4>Rating Distribution</h4>
                    {% for star in ['5','4','3','2','1'] %}
                    {% set count = summary.rating_distribution.get(star, 0) %}
                    {% set pct = (count / summary.total_reviews * 100) if summary.total_reviews else 0 %}
                    <div class="dist-row">
                        <span class="dist-label">{{ star }}&#9733;</span>
                        <div class="dist-bar-track">
                            <div class="dist-bar-fill" style="width: {{ pct }}%"></div>
                        </div>
                        <span class="dist-count">{{ count }}</span>
                    </div>
                    {% endfor %}
                </div>
                {% endif %}
            </div>

            <div class="sidebar-footer">
                <a href="/" class="btn btn-small">New Analysis</a>
            </div>
        </aside>

        <!-- Main Chat Area -->
        <main class="chat-main">
            <div class="chat-messages" id="chat-messages">
                <!-- Existing messages -->
                {% for msg in messages %}
                    {% if msg.role == 'assistant' %}
                    <div class="message assistant-message">
                        <div class="message-content">{{ msg.content }}</div>
                    </div>
                    {% else %}
                    <div class="message user-message">
                        <div class="message-content"><p>{{ msg.content }}</p></div>
                    </div>
                    {% endif %}
                {% endfor %}

                <!-- Welcome message if no messages yet -->
                {% if not messages %}
                <div class="message assistant-message welcome">
                    <div class="message-content">
                        <p>Hello! I see you want to analyse reviews for <strong>{{ summary.product_name }}</strong>.
                        I have <strong>{{ summary.total_reviews }}</strong> reviews loaded from <strong>{{ summary.platform }}</strong>{% if summary.date_range %}, spanning {{ summary.date_range }}{% endif %}.</p>
                        <p>I can only answer questions about this specific dataset — no external data, no guesswork. What would you like to know?</p>
                    </div>
                    <div class="follow-ups">
                        <button class="follow-up-btn" onclick="sendFollowUp(this)" data-question="What's the overall sentiment breakdown?">What's the overall sentiment breakdown?</button>
                        <button class="follow-up-btn" onclick="sendFollowUp(this)" data-question="What are the most common complaints?">What are the most common complaints?</button>
                        <button class="follow-up-btn" onclick="sendFollowUp(this)" data-question="Show me the rating distribution over time">Show me the rating distribution over time</button>
                        <button class="follow-up-btn" onclick="sendFollowUp(this)" data-question="What do people praise the most?">What do people praise the most?</button>
                    </div>
                </div>
                {% endif %}
            </div>

            <!-- Chat Input -->
            <div class="chat-input-area">
                <form id="chat-form" onsubmit="sendMessage(event)">
                    <div class="input-row">
                        <textarea id="chat-input"
                                  name="message"
                                  placeholder="Ask about the reviews..."
                                  rows="1"
                                  autofocus></textarea>
                        <button type="submit" class="btn btn-send" id="send-btn">
                            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                <path d="M22 2L11 13M22 2l-7 20-4-9-9-4 20-7z"/>
                            </svg>
                        </button>
                    </div>
                </form>
                <p class="input-hint">ReviewLens only analyses the uploaded reviews. It cannot access external data.</p>
            </div>
        </main>
    </div>

    <script>
        var SESSION_ID = "{{ session.session_id }}";
    </script>
    <script src="/static/app.js"></script>
</body>
</html>

<div class="error-banner">
    <p>{{ error }}</p>
</div>

<div class="summary-card">
    <h3>{{ summary.product_name }}</h3>
    <dl class="summary-dl">
        <dt>Platform</dt><dd>{{ summary.platform }}</dd>
        <dt>Reviews</dt><dd>{{ summary.total_reviews }}</dd>
        {% if summary.average_rating %}
        <dt>Avg Rating</dt><dd>{{ "%.1f"|format(summary.average_rating) }} &#9733;</dd>
        {% endif %}
        {% if summary.date_range %}
        <dt>Date Range</dt><dd>{{ summary.date_range }}</dd>
        {% endif %}
        <dt>Source</dt><dd>{{ summary.source_type | upper }}</dd>
    </dl>
</div>

/* ReviewLens AI — Client-side logic */

// ── File upload drag & drop ────────────────────────────────────────

(function () {
  var dropZone = document.getElementById("file-drop");
  var fileInput = document.getElementById("file");
  if (!dropZone || !fileInput) return;

  dropZone.addEventListener("click", function () {
    fileInput.click();
  });

  dropZone.addEventListener("dragover", function (e) {
    e.preventDefault();
    dropZone.classList.add("drag-over");
  });

  dropZone.addEventListener("dragleave", function () {
    dropZone.classList.remove("drag-over");
  });

  dropZone.addEventListener("drop", function (e) {
    e.preventDefault();
    dropZone.classList.remove("drag-over");
    if (e.dataTransfer.files.length) {
      fileInput.files = e.dataTransfer.files;
      showFileName(e.dataTransfer.files[0].name);
    }
  });

  fileInput.addEventListener("change", function () {
    if (fileInput.files.length) {
      showFileName(fileInput.files[0].name);
    }
  });

  function showFileName(name) {
    var content = dropZone.querySelector(".file-drop-content");
    var selected = dropZone.querySelector(".file-selected");
    var nameEl = dropZone.querySelector(".file-name");
    content.style.display = "none";
    selected.style.display = "flex";
    nameEl.textContent = name;
  }
})();

function clearFile() {
  var dropZone = document.getElementById("file-drop");
  var fileInput = document.getElementById("file");
  var content = dropZone.querySelector(".file-drop-content");
  var selected = dropZone.querySelector(".file-selected");
  content.style.display = "";
  selected.style.display = "none";
  fileInput.value = "";
}

// ── HTMX loading states ────────────────────────────────────────────

document.addEventListener("htmx:beforeRequest", function (e) {
  var form = e.detail.elt;
  var btn = form.querySelector("button[type=submit]");
  if (btn) {
    btn.disabled = true;
    var text = btn.querySelector(".btn-text");
    var spinner = btn.querySelector(".btn-spinner");
    if (text) text.style.display = "none";
    if (spinner) spinner.style.display = "inline-flex";
  }
});

document.addEventListener("htmx:afterRequest", function (e) {
  var form = e.detail.elt;
  var btn = form.querySelector("button[type=submit]");
  if (btn) {
    btn.disabled = false;
    var text = btn.querySelector(".btn-text");
    var spinner = btn.querySelector(".btn-spinner");
    if (text) text.style.display = "";
    if (spinner) spinner.style.display = "none";
  }
});

// ── Chat functionality ─────────────────────────────────────────────

var chatMessages = document.getElementById("chat-messages");
var chatInput = document.getElementById("chat-input");
var chatForm = document.getElementById("chat-form");
var sendBtn = document.getElementById("send-btn");
var eventSource = null;

function scrollToBottom() {
  if (chatMessages) {
    chatMessages.scrollTop = chatMessages.scrollHeight;
  }
}

// Auto-resize textarea
if (chatInput) {
  chatInput.addEventListener("input", function () {
    this.style.height = "auto";
    this.style.height = Math.min(this.scrollHeight, 150) + "px";
  });

  chatInput.addEventListener("keydown", function (e) {
    if (e.key === "Enter" && !e.shiftKey) {
      e.preventDefault();
      chatForm.dispatchEvent(new Event("submit"));
    }
  });
}

function sendMessage(e) {
  e.preventDefault();
  var message = chatInput.value.trim();
  if (!message) return;

  // Disable input while processing
  chatInput.disabled = true;
  sendBtn.disabled = true;

  // Remove existing follow-up buttons
  var existingFollowUps = chatMessages.querySelectorAll(".follow-ups");
  existingFollowUps.forEach(function (el) {
    el.remove();
  });

  // Add user message to chat
  var userDiv = document.createElement("div");
  userDiv.className = "message user-message";
  userDiv.innerHTML =
    '<div class="message-content"><p>' + escapeHtml(message) + "</p></div>";
  chatMessages.appendChild(userDiv);

  // Add thinking indicator
  var thinkingDiv = document.createElement("div");
  thinkingDiv.id = "thinking-indicator";
  thinkingDiv.className = "message assistant-message thinking";
  thinkingDiv.innerHTML =
    '<div class="message-content">' +
    '<div class="thinking-dots"><span></span><span></span><span></span></div>' +
    "</div>";
  chatMessages.appendChild(thinkingDiv);
  scrollToBottom();

  // Send via fetch and listen for SSE response
  var formData = new FormData();
  formData.append("message", message);

  fetch("/chat/" + SESSION_ID + "/send", {
    method: "POST",
    body: formData,
  })
    .then(function () {
      // Start listening for SSE events
      listenForResponse();
    })
    .catch(function (err) {
      removeThinking();
      appendError("Failed to send message: " + err.message);
      chatInput.disabled = false;
      sendBtn.disabled = false;
    });

  chatInput.value = "";
  chatInput.style.height = "auto";
}

function listenForResponse() {
  if (eventSource) {
    eventSource.close();
  }

  eventSource = new EventSource("/chat/" + SESSION_ID + "/stream");

  eventSource.addEventListener("tool", function (e) {
    // Show tool activity in a subtle indicator
    var thinking = document.getElementById("thinking-indicator");
    if (thinking) {
      var content = thinking.querySelector(".message-content");
      content.innerHTML =
        '<div class="thinking-dots"><span></span><span></span><span></span></div>' +
        '<div class="tool-activity">' +
        escapeHtml(e.data) +
        "</div>";
      scrollToBottom();
    }
  });

  eventSource.addEventListener("message", function (e) {
    removeThinking();
    // Insert the rendered HTML from the server
    var temp = document.createElement("div");
    temp.innerHTML = e.data;
    while (temp.firstChild) {
      chatMessages.appendChild(temp.firstChild);
    }
    // Execute any chart scripts
    runChartScripts();
    scrollToBottom();
    chatInput.disabled = false;
    sendBtn.disabled = false;
    chatInput.focus();
  });

  eventSource.addEventListener("done", function () {
    eventSource.close();
    eventSource = null;
    removeThinking();
    chatInput.disabled = false;
    sendBtn.disabled = false;
  });

  eventSource.onerror = function () {
    eventSource.close();
    eventSource = null;
    removeThinking();
    chatInput.disabled = false;
    sendBtn.disabled = false;
  };
}

function removeThinking() {
  var el = document.getElementById("thinking-indicator");
  if (el) el.remove();
}

function appendError(msg) {
  var div = document.createElement("div");
  div.className = "message assistant-message error";
  div.innerHTML = '<div class="message-content"><p>' + escapeHtml(msg) + "</p></div>";
  chatMessages.appendChild(div);
  scrollToBottom();
}

function sendFollowUp(btn) {
  var question = btn.getAttribute("data-question");
  chatInput.value = question;
  chatForm.dispatchEvent(new Event("submit"));
}

// ── Chart rendering ────────────────────────────────────────────────

// Color palette
var CHART_COLORS = [
  "rgba(99, 102, 241, 0.8)", // indigo
  "rgba(16, 185, 129, 0.8)", // emerald
  "rgba(245, 158, 11, 0.8)", // amber
  "rgba(239, 68, 68, 0.8)", // red
  "rgba(139, 92, 246, 0.8)", // violet
  "rgba(6, 182, 212, 0.8)", // cyan
  "rgba(236, 72, 153, 0.8)", // pink
];

var CHART_BORDERS = [
  "rgba(99, 102, 241, 1)",
  "rgba(16, 185, 129, 1)",
  "rgba(245, 158, 11, 1)",
  "rgba(239, 68, 68, 1)",
  "rgba(139, 92, 246, 1)",
  "rgba(6, 182, 212, 1)",
  "rgba(236, 72, 153, 1)",
];

function renderChart(canvasId, config) {
  var canvas = document.getElementById(canvasId);
  if (!canvas) return;

  var datasets = config.data.datasets.map(function (ds, i) {
    var colors =
      config.type === "pie" || config.type === "doughnut"
        ? CHART_COLORS.slice(0, ds.data.length)
        : [CHART_COLORS[i % CHART_COLORS.length]];

    var borders =
      config.type === "pie" || config.type === "doughnut"
        ? CHART_BORDERS.slice(0, ds.data.length)
        : [CHART_BORDERS[i % CHART_BORDERS.length]];

    return {
      label: ds.label,
      data: ds.data,
      backgroundColor: colors.length === 1 ? colors[0] : colors,
      borderColor: borders.length === 1 ? borders[0] : borders,
      borderWidth: config.type === "line" ? 2 : 1,
      tension: 0.3,
      fill: config.type === "line",
    };
  });

  new Chart(canvas, {
    type: config.type,
    data: {
      labels: config.data.labels,
      datasets: datasets,
    },
    options: {
      responsive: true,
      maintainAspectRatio: true,
      plugins: {
        title: {
          display: true,
          text: config.title,
          font: { size: 14, weight: "600" },
          color: "#e2e8f0",
        },
        legend: {
          labels: { color: "#94a3b8" },
        },
      },
      scales:
        config.type !== "pie" && config.type !== "doughnut"
          ? {
              x: {
                ticks: { color: "#94a3b8" },
                grid: { color: "rgba(148, 163, 184, 0.1)" },
              },
              y: {
                ticks: { color: "#94a3b8" },
                grid: { color: "rgba(148, 163, 184, 0.1)" },
                beginAtZero: true,
              },
            }
          : undefined,
    },
  });
}

function runChartScripts() {
  // Find and execute any chart script tags just added
  var scripts = chatMessages.querySelectorAll("script");
  scripts.forEach(function (script) {
    if (script.textContent.indexOf("renderChart") !== -1 && !script.dataset.executed) {
      script.dataset.executed = "true";
      eval(script.textContent);
    }
  });
}

// ── Utilities ──────────────────────────────────────────────────────

function escapeHtml(str) {
  var div = document.createElement("div");
  div.appendChild(document.createTextNode(str));
  return div.innerHTML;
}

// Auto-scroll on new content
if (chatMessages) {
  var observer = new MutationObserver(function () {
    scrollToBottom();
  });
  observer.observe(chatMessages, { childList: true, subtree: true });
}

// Initial scroll
scrollToBottom();

/* ReviewLens AI — Stylesheet */

/* ── Reset & Base ──────────────────────────────────────────────── */

*, *::before, *::after {
    box-sizing: border-box;
    margin: 0;
    padding: 0;
}

:root {
    --bg: #0f172a;
    --bg-card: #1e293b;
    --bg-input: #334155;
    --bg-hover: #475569;
    --text: #e2e8f0;
    --text-muted: #94a3b8;
    --text-dim: #64748b;
    --accent: #6366f1;
    --accent-hover: #818cf8;
    --accent-dim: rgba(99, 102, 241, 0.15);
    --success: #10b981;
    --warning: #f59e0b;
    --error: #ef4444;
    --border: #334155;
    --radius: 8px;
    --radius-lg: 12px;
    --shadow: 0 4px 6px -1px rgba(0,0,0,0.3);
    --font: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
    --mono: 'JetBrains Mono', 'Fira Code', monospace;
}

html, body {
    height: 100%;
    font-family: var(--font);
    background: var(--bg);
    color: var(--text);
    line-height: 1.6;
    -webkit-font-smoothing: antialiased;
}

a { color: var(--accent); text-decoration: none; }
a:hover { color: var(--accent-hover); }

/* ── Landing Page ──────────────────────────────────────────────── */

.landing {
    min-height: 100vh;
    display: flex;
    flex-direction: column;
    align-items: center;
    padding: 3rem 1.5rem;
}

.landing-header {
    text-align: center;
    margin-bottom: 3rem;
}

.landing-header h1 {
    font-size: 2.5rem;
    font-weight: 700;
    letter-spacing: -0.02em;
}

.accent { color: var(--accent); }

.tagline {
    color: var(--text-muted);
    font-size: 1.1rem;
    margin-top: 0.5rem;
}

.upload-section {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 2rem;
    max-width: 900px;
    width: 100%;
}

@media (max-width: 768px) {
    .upload-section { grid-template-columns: 1fr; }
}

.upload-card {
    background: var(--bg-card);
    border: 1px solid var(--border);
    border-radius: var(--radius-lg);
    padding: 2rem;
}

.upload-card.primary { border-color: var(--accent); }

.upload-card h2 {
    font-size: 1.25rem;
    margin-bottom: 0.5rem;
}

.upload-desc {
    color: var(--text-muted);
    font-size: 0.9rem;
    margin-bottom: 1.5rem;
}

.badge {
    font-size: 0.7rem;
    background: var(--warning);
    color: #000;
    padding: 2px 8px;
    border-radius: 999px;
    font-weight: 600;
    vertical-align: middle;
}

/* ── Forms ──────────────────────────────────────────────────────── */

.form-group {
    margin-bottom: 1rem;
}

.form-group label {
    display: block;
    font-size: 0.85rem;
    font-weight: 500;
    color: var(--text-muted);
    margin-bottom: 0.35rem;
}

.form-group input,
.form-group select,
.form-group textarea {
    width: 100%;
    padding: 0.6rem 0.75rem;
    background: var(--bg-input);
    border: 1px solid var(--border);
    border-radius: var(--radius);
    color: var(--text);
    font-size: 0.9rem;
    font-family: var(--font);
    transition: border-color 0.15s;
}

.form-group input:focus,
.form-group select:focus,
.form-group textarea:focus {
    outline: none;
    border-color: var(--accent);
}

.form-group select {
    cursor: pointer;
}

/* ── File Drop Zone ────────────────────────────────────────────── */

.file-drop {
    border: 2px dashed var(--border);
    border-radius: var(--radius);
    padding: 2rem;
    text-align: center;
    cursor: pointer;
    transition: border-color 0.15s, background 0.15s;
    margin-bottom: 1.5rem;
    position: relative;
}

.file-drop:hover,
.file-drop.drag-over {
    border-color: var(--accent);
    background: var(--accent-dim);
}

.file-drop input[type="file"] {
    position: absolute;
    inset: 0;
    opacity: 0;
    cursor: pointer;
}

.file-icon { font-size: 2rem; margin-bottom: 0.5rem; }

.file-drop p {
    color: var(--text-muted);
    font-size: 0.9rem;
}

.browse-link {
    color: var(--accent);
    text-decoration: underline;
}

.file-hint {
    font-size: 0.8rem;
    color: var(--text-dim);
    margin-top: 0.25rem;
}

.file-selected {
    display: flex;
    align-items: center;
    justify-content: center;
    gap: 0.75rem;
}

.file-name {
    color: var(--text);
    font-weight: 500;
}

.file-clear {
    background: none;
    border: none;
    color: var(--text-muted);
    cursor: pointer;
    font-size: 1.1rem;
    padding: 0.25rem;
}

/* ── Buttons ───────────────────────────────────────────────────── */

.btn {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    gap: 0.5rem;
    padding: 0.7rem 1.5rem;
    border: none;
    border-radius: var(--radius);
    font-size: 0.9rem;
    font-weight: 600;
    font-family: var(--font);
    cursor: pointer;
    transition: background 0.15s, transform 0.1s;
    width: 100%;
}

.btn:active { transform: scale(0.98); }
.btn:disabled { opacity: 0.6; cursor: not-allowed; }

.btn-primary {
    background: var(--accent);
    color: #fff;
}
.btn-primary:hover:not(:disabled) { background: var(--accent-hover); }

.btn-secondary {
    background: var(--bg-input);
    color: var(--text);
    border: 1px solid var(--border);
}
.btn-secondary:hover:not(:disabled) { background: var(--bg-hover); }

.btn-small {
    padding: 0.4rem 1rem;
    font-size: 0.8rem;
    width: auto;
}

.btn-spinner {
    display: inline-flex;
    align-items: center;
    gap: 0.5rem;
}

.spinner {
    width: 16px;
    height: 16px;
    border: 2px solid rgba(255,255,255,0.3);
    border-top-color: #fff;
    border-radius: 50%;
    animation: spin 0.6s linear infinite;
}

@keyframes spin { to { transform: rotate(360deg); } }

/* ── Error Banner ──────────────────────────────────────────────── */

.error-banner {
    background: rgba(239, 68, 68, 0.15);
    border: 1px solid var(--error);
    color: var(--error);
    padding: 0.75rem 1rem;
    border-radius: var(--radius);
    font-size: 0.9rem;
    margin-top: 1rem;
}

/* ── Landing Footer ────────────────────────────────────────────── */

.landing-footer {
    margin-top: 3rem;
    text-align: center;
    color: var(--text-dim);
    font-size: 0.85rem;
}

/* ── Chat Layout ───────────────────────────────────────────────── */

.chat-layout {
    display: grid;
    grid-template-columns: 280px 1fr;
    height: 100vh;
}

@media (max-width: 768px) {
    .chat-layout { grid-template-columns: 1fr; }
    .sidebar { display: none; }
}

/* ── Sidebar ───────────────────────────────────────────────────── */

.sidebar {
    background: var(--bg-card);
    border-right: 1px solid var(--border);
    display: flex;
    flex-direction: column;
    overflow-y: auto;
}

.sidebar-header {
    padding: 1.25rem 1.5rem;
    border-bottom: 1px solid var(--border);
}

.logo {
    font-size: 1.1rem;
    font-weight: 700;
}

.logo-link { color: var(--text); }
.logo-link:hover { color: var(--text); }

.summary-card {
    padding: 1.5rem;
    flex: 1;
}

.summary-card h3 {
    font-size: 1rem;
    margin-bottom: 1rem;
    word-break: break-word;
}

.summary-meta {
    display: flex;
    flex-direction: column;
    gap: 0.6rem;
}

.meta-item {
    display: flex;
    justify-content: space-between;
    font-size: 0.85rem;
}

.meta-label { color: var(--text-muted); }
.meta-value { font-weight: 500; }

/* ── Rating Distribution ───────────────────────────────────────── */

.rating-dist {
    margin-top: 1.5rem;
}

.rating-dist h4 {
    font-size: 0.8rem;
    color: var(--text-muted);
    text-transform: uppercase;
    letter-spacing: 0.05em;
    margin-bottom: 0.75rem;
}

.dist-row {
    display: flex;
    align-items: center;
    gap: 0.5rem;
    margin-bottom: 0.35rem;
    font-size: 0.8rem;
}

.dist-label {
    width: 2rem;
    text-align: right;
    color: var(--text-muted);
    flex-shrink: 0;
}

.dist-bar-track {
    flex: 1;
    height: 6px;
    background: var(--bg-input);
    border-radius: 3px;
    overflow: hidden;
}

.dist-bar-fill {
    height: 100%;
    background: var(--accent);
    border-radius: 3px;
    transition: width 0.3s ease;
}

.dist-count {
    width: 2.5rem;
    text-align: right;
    color: var(--text-muted);
    flex-shrink: 0;
}

.sidebar-footer {
    padding: 1rem 1.5rem;
    border-top: 1px solid var(--border);
}

/* ── Chat Main ─────────────────────────────────────────────────── */

.chat-main {
    display: flex;
    flex-direction: column;
    height: 100vh;
    overflow: hidden;
}

.chat-messages {
    flex: 1;
    overflow-y: auto;
    padding: 2rem;
    display: flex;
    flex-direction: column;
    gap: 1rem;
}

/* ── Messages ──────────────────────────────────────────────────── */

.message {
    max-width: 720px;
    animation: fadeIn 0.2s ease;
}

@keyframes fadeIn {
    from { opacity: 0; transform: translateY(4px); }
    to { opacity: 1; transform: translateY(0); }
}

.user-message {
    align-self: flex-end;
}

.user-message .message-content {
    background: var(--accent);
    color: #fff;
    padding: 0.75rem 1rem;
    border-radius: var(--radius-lg) var(--radius-lg) 4px var(--radius-lg);
}

.user-message .message-content p { margin: 0; }

.assistant-message {
    align-self: flex-start;
}

.assistant-message .message-content {
    background: var(--bg-card);
    border: 1px solid var(--border);
    padding: 1rem 1.25rem;
    border-radius: 4px var(--radius-lg) var(--radius-lg) var(--radius-lg);
    line-height: 1.7;
}

.assistant-message .message-content p { margin-bottom: 0.5rem; }
.assistant-message .message-content p:last-child { margin-bottom: 0; }

.assistant-message .message-content h1,
.assistant-message .message-content h2,
.assistant-message .message-content h3 {
    margin: 1rem 0 0.5rem;
    font-size: 1rem;
    font-weight: 600;
}

.assistant-message .message-content ul,
.assistant-message .message-content ol {
    padding-left: 1.5rem;
    margin-bottom: 0.5rem;
}

.assistant-message .message-content li {
    margin-bottom: 0.25rem;
}

.assistant-message .message-content strong {
    color: #fff;
}

.assistant-message .message-content code {
    background: var(--bg-input);
    padding: 0.15rem 0.4rem;
    border-radius: 4px;
    font-size: 0.85em;
    font-family: var(--mono);
}

.assistant-message .message-content blockquote {
    border-left: 3px solid var(--accent);
    padding-left: 1rem;
    color: var(--text-muted);
    margin: 0.5rem 0;
}

.assistant-message .message-content table {
    width: 100%;
    border-collapse: collapse;
    margin: 0.75rem 0;
    font-size: 0.85rem;
}

.assistant-message .message-content th,
.assistant-message .message-content td {
    padding: 0.5rem 0.75rem;
    border: 1px solid var(--border);
    text-align: left;
}

.assistant-message .message-content th {
    background: var(--bg-input);
    font-weight: 600;
}

/* ── Thinking Indicator ────────────────────────────────────────── */

.thinking .message-content {
    display: flex;
    flex-direction: column;
    gap: 0.5rem;
}

.thinking-dots {
    display: flex;
    gap: 4px;
    padding: 0.25rem 0;
}

.thinking-dots span {
    width: 8px;
    height: 8px;
    background: var(--text-muted);
    border-radius: 50%;
    animation: bounce 1.4s ease-in-out infinite;
}

.thinking-dots span:nth-child(2) { animation-delay: 0.16s; }
.thinking-dots span:nth-child(3) { animation-delay: 0.32s; }

@keyframes bounce {
    0%, 80%, 100% { transform: scale(0.6); opacity: 0.4; }
    40% { transform: scale(1); opacity: 1; }
}

.tool-activity {
    font-size: 0.8rem;
    color: var(--text-dim);
    font-family: var(--mono);
}

/* ── Charts ────────────────────────────────────────────────────── */

.chart-container {
    margin: 1rem 0;
    padding: 1rem;
    background: var(--bg);
    border-radius: var(--radius);
    border: 1px solid var(--border);
    max-width: 500px;
}

.chart-container canvas {
    max-height: 300px;
}

/* ── Follow-up Buttons ─────────────────────────────────────────── */

.follow-ups {
    display: flex;
    flex-wrap: wrap;
    gap: 0.5rem;
    margin-top: 0.75rem;
}

.follow-up-btn {
    background: var(--accent-dim);
    color: var(--accent-hover);
    border: 1px solid rgba(99, 102, 241, 0.3);
    border-radius: 999px;
    padding: 0.4rem 1rem;
    font-size: 0.8rem;
    font-family: var(--font);
    cursor: pointer;
    transition: background 0.15s, border-color 0.15s;
    white-space: nowrap;
}

.follow-up-btn:hover {
    background: rgba(99, 102, 241, 0.25);
    border-color: var(--accent);
}

/* ── Chat Input ────────────────────────────────────────────────── */

.chat-input-area {
    padding: 1rem 2rem 1.5rem;
    border-top: 1px solid var(--border);
    background: var(--bg);
}

.input-row {
    display: flex;
    gap: 0.75rem;
    align-items: flex-end;
}

.input-row textarea {
    flex: 1;
    resize: none;
    padding: 0.75rem 1rem;
    background: var(--bg-card);
    border: 1px solid var(--border);
    border-radius: var(--radius-lg);
    color: var(--text);
    font-size: 0.9rem;
    font-family: var(--font);
    line-height: 1.5;
    max-height: 150px;
    transition: border-color 0.15s;
}

.input-row textarea:focus {
    outline: none;
    border-color: var(--accent);
}

.input-row textarea:disabled {
    opacity: 0.5;
}

.btn-send {
    width: 44px;
    height: 44px;
    padding: 0;
    border-radius: 50%;
    flex-shrink: 0;
    background: var(--accent);
    color: #fff;
    border: none;
    cursor: pointer;
    display: flex;
    align-items: center;
    justify-content: center;
    transition: background 0.15s, transform 0.1s;
}

.btn-send:hover:not(:disabled) { background: var(--accent-hover); }
.btn-send:active { transform: scale(0.95); }
.btn-send:disabled { opacity: 0.5; cursor: not-allowed; }

.input-hint {
    text-align: center;
    font-size: 0.75rem;
    color: var(--text-dim);
    margin-top: 0.5rem;
}

/* ── Scrollbar ─────────────────────────────────────────────────── */

::-webkit-scrollbar {
    width: 6px;
}

::-webkit-scrollbar-track {
    background: transparent;
}

::-webkit-scrollbar-thumb {
    background: var(--bg-hover);
    border-radius: 3px;
}

::-webkit-scrollbar-thumb:hover {
    background: var(--text-dim);
}

fastapi>=0.115.0
uvicorn[standard]
sse-starlette
claude-agent-sdk
chromadb
httpx
jinja2
python-multipart
python-dotenv
markdown

# Required
ANTHROPIC_API_KEY=sk-ant-...

# Optional: model override (default: claude-sonnet-4-6-20250514)
# CLAUDE_MODEL=claude-sonnet-4-6-20250514

# Optional: Firecrawl for URL scraping (secondary path)
# FIRECRAWL_API_KEY=fc-...

# Optional: data directory (default: data)
# DATA_DIR=data

# Optional: ChromaDB directory (default: data/chroma)
# CHROMA_DIR=data/chroma

FROM python:3.12-slim

WORKDIR /app

# Install build deps for chromadb (needs sqlite3, gcc for some wheels)
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN mkdir -p data

EXPOSE 8000

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

services:
  - type: web
    name: reviewlens
    runtime: docker
    plan: free
    envVars:
      - key: ANTHROPIC_API_KEY
        sync: false
      - key: FIRECRAWL_API_KEY
        sync: false
    healthCheckPath: /health

# ReviewLens AI

A review intelligence portal that ingests customer reviews and lets analysts explore them through a guardrailed conversational interface.

## Architecture

```
CSV Upload / URL Scrape
        │
        ▼
   Parse & Index ──→ ChromaDB (in-process vector store)
        │
        ▼
  Ingestion Summary ──→ Chat Interface
                            │
                      User Message
                            │
                            ▼
                    Claude Agent SDK
                    (per-message loop)
                            │
                    ┌───────┼───────┐
                    │       │       │
              search_reviews │  generate_chart
                    analyze_sentiment
                    calculate_stats
                    suggest_follow_ups
                            │
                            ▼
                   SSE Stream → Chat UI
                   (text + charts + follow-ups)
```

**Stack:** FastAPI, Jinja2/HTMX, SSE streaming, Claude Agent SDK with custom MCP tools, ChromaDB, Chart.js.

## Key Design Decisions

### Scope Guard (Three-Layer Defense)
The AI only answers questions about the ingested reviews:
1. **System prompt** — explicit instructions to refuse out-of-scope questions
2. **Retrieval confidence** — if ChromaDB returns nothing relevant, auto-reject
3. **Architectural boundary** — the agent has no tools that access external data

### CSV-First Ingestion
CSV upload is the polished primary path. URL scraping via Firecrawl is best-effort secondary — review platforms are heavily anti-bot and the results are unpredictable.

### Conversational Agent Loop
Unlike a fire-and-forget agent, ReviewLens invokes the agent per-message. Each user message triggers a fresh agent loop with conversation history as context.

### Chart.js Inline Charts
The `generate_chart` tool returns Chart.js config JSON. The frontend renders charts inline in chat messages. The agent decides when a chart adds value.

## Setup

```bash
cd reviewlens
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

cp .env.example .env
# Edit .env with your ANTHROPIC_API_KEY

uvicorn app.main:app --reload
```

Open http://localhost:8000

## Deploy (Render)

1. Push to GitHub
2. Connect repo in Render dashboard
3. Set `ANTHROPIC_API_KEY` environment variable
4. Deploy — uses `render.yaml` for config

## CSV Format

The parser auto-detects common column names. Minimum required: a text/review column.

| Column | Aliases |
|--------|---------|
| text | text, review, review_text, content, body, comment |
| rating | rating, score, stars, star_rating |
| date | date, review_date, created_at, timestamp |
| author | author, reviewer, user, username |
| platform | platform, source, site |

## Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `ANTHROPIC_API_KEY` | Yes | Claude API key |
| `CLAUDE_MODEL` | No | Model override (default: claude-sonnet-4-6-20250514) |
| `FIRECRAWL_API_KEY` | No | Enables URL scraping |
| `DATA_DIR` | No | Data directory (default: data) |
| `CHROMA_DIR` | No | ChromaDB directory (default: data/chroma) |